ElectroMagneticPython 2.1.4__py3-none-any.whl

EMpy/modesolvers/__init__.py

@@ -0,0 +1,13 @@
+"""Collection of different algorithms to find modes of optical waveguides.
+
+Modesolvers:
+
+    1. FD.
+    2. FMM.
+
+
+"""
+__all__ = ["FD", "FMM", "geometries"]
+__author__ = "Lorenzo Bolla"
+
+from . import FD, FMM, geometries

EMpy/modesolvers/geometries.py

@@ -0,0 +1,231 @@
+"""Geometries.
+
+"""
+import numpy
+import pylab
+
+from EMpy.modesolvers.interface import interface_matrix
+
+
+def S2T(S):
+    dim = S.shape[0] / 2.0
+    s11 = S[:dim, :dim]
+    s22 = S[dim:, dim:]
+    s12 = S[:dim, dim:]
+    s21 = S[dim:, :dim]
+    T = numpy.zeros_like(S)
+    s12_1 = numpy.linalg.inv(s12)
+    T[:dim, :dim] = s21 - numpy.dot(numpy.dot(s22, s12_1), s11)
+    T[dim:, dim:] = s12_1
+    T[:dim, dim:] = numpy.dot(s22, s12_1)
+    T[dim:, :dim] = -numpy.dot(s12_1, s11)
+    return T
+
+
+def T2S(T):
+    dim = T.shape[0] / 2.0
+    t11 = T[:dim, :dim]
+    t22 = T[dim:, dim:]
+    t12 = T[:dim, dim:]
+    t21 = T[dim:, :dim]
+    S = numpy.zeros_like(T)
+    t22_1 = numpy.linalg.inv(t22)
+    S[:dim, :dim] = -numpy.dot(t22_1, t21)
+    S[dim:, dim:] = numpy.dot(t12, t22_1)
+    S[:dim, dim:] = t22_1
+    S[dim:, :dim] = t11 - numpy.dot(numpy.dot(t12, t22_1), t21)
+    return S
+
+
+class SWG:
+
+    #    def __init__(self, cs, solver, length, inputLHS=None, inputRHS=None):
+    def __init__(self, solver, length, inputLHS=None, inputRHS=None):
+        #        self.cs = cs
+        self.solver = solver
+        self.length = length
+        self.build_matrix()
+        self.compute_output(inputLHS, inputRHS)
+
+    def compute_output(self, inputLHS=None, inputRHS=None):
+        if inputLHS is None:
+            self.inputLHS = numpy.zeros(self.solver.nmodes)
+            self.inputLHS[0] = 1.0
+        else:
+            self.inputLHS = inputLHS
+        if inputRHS is None:
+            self.inputRHS = numpy.zeros(self.solver.nmodes)
+        else:
+            self.inputRHS = inputRHS
+        input = numpy.r_[self.inputLHS, self.inputRHS]
+        output = numpy.dot(self.S, input)
+        self.outputLHS = output[: self.solver.nmodes]
+        self.outputRHS = output[self.solver.nmodes :]
+
+    def build_matrix(self):
+        neffs = numpy.array([m.neff for m in self.solver.modes])
+        betas = 2 * numpy.pi / self.solver.wl * neffs
+        neigs = self.solver.nmodes
+        T = numpy.zeros((2 * neigs, 2 * neigs), dtype=complex)
+        T[:neigs, :neigs] = numpy.diag(numpy.exp(1j * betas * self.length))
+        T[neigs:, neigs:] = numpy.diag(numpy.exp(-1j * numpy.conj(betas) * self.length))
+        self.T = T
+        self.S = T2S(self.T)
+
+    def plot(self, sumx=1, nxy=100, nz=100, z0=0):
+        if sumx is None:  # sum in y
+            x = self.solver.modes[0].get_y(nxy)
+            axis = 0
+        else:  # sum in x
+            x = self.solver.modes[0].get_x(nxy)
+            axis = 1
+        z = numpy.linspace(0, self.length, nz)
+        const_z = numpy.ones_like(z)
+        f = numpy.zeros((len(x), len(z)), dtype=complex)
+        for im, (coeffLHS, coeffRHS) in enumerate(zip(self.inputLHS, self.inputRHS)):
+            m = self.solver.modes[im]
+            # beta = 2 * numpy.pi / self.solver.wl * m.neff
+            tmp = numpy.sum(m.intensity(x, x), axis=axis)
+            f += (
+                numpy.abs(coeffLHS) ** 2 * tmp[:, numpy.newaxis] * const_z
+                + numpy.abs(coeffRHS) ** 2 * tmp[:, numpy.newaxis] * const_z
+            )
+        pylab.hot()
+        pylab.contourf(x, z0 + z, numpy.abs(f).T, 16)
+
+
+class SimpleJoint:
+
+    #    def __init__(self, cs1, cs2, solver1, solver2, inputLHS=None, inputRHS=None):
+    def __init__(self, solver1, solver2, inputLHS=None, inputRHS=None):
+        #        self.cs1 = cs1
+        self.solver1 = solver1
+        #        self.cs2 = cs2
+        self.solver2 = solver2
+        self.length = 0.0
+        self.build_matrix()
+        self.compute_output(inputLHS, inputRHS)
+
+    def compute_output(self, inputLHS=None, inputRHS=None):
+        if inputLHS is None:
+            self.inputLHS = numpy.zeros(self.solver1.nmodes)
+            self.inputLHS[0] = 1.0
+        else:
+            self.inputLHS = inputLHS
+        if inputRHS is None:
+            self.inputRHS = numpy.zeros(self.solver1.nmodes)
+        else:
+            self.inputRHS = inputRHS
+        input = numpy.r_[self.inputLHS, self.inputRHS]
+        output = numpy.dot(self.S, input)
+        self.outputLHS = output[: self.solver1.nmodes]
+        self.outputRHS = output[self.solver1.nmodes :]
+
+    def build_matrix(self):
+        O11, O22, O12, O21 = interface_matrix(self.solver1, self.solver2)
+        neffA = numpy.array([m.neff for m in self.solver1.modes])
+        neffB = numpy.array([m.neff for m in self.solver2.modes])
+        betaA = 2 * numpy.pi / self.solver1.wl * neffA
+        betaB = 2 * numpy.pi / self.solver1.wl * neffB
+
+        BetaA = numpy.diag(betaA)
+        BetaB = numpy.diag(betaB)
+
+        #        MRA1 = numpy.dot(O12, BetaA + BetaB)
+        #        MRA2 = numpy.dot(O12, BetaA - BetaB)
+        #        MRA = numpy.dot(numpy.linalg.inv(MRA1), MRA2)
+        #        S11 = MRA
+        #
+        #        MRB1 = numpy.dot(O21, BetaA + BetaB)
+        #        MRB2 = numpy.dot(O21, BetaB - BetaA)
+        #        MRB = numpy.dot(numpy.linalg.inv(MRB1), MRB2)
+        #        S22 = MRB
+        #
+        #        MTAB1 = numpy.dot(O22, BetaA + BetaB)
+        #        MTAB2 = numpy.dot(O12, 2. * BetaA)
+        #        MTAB = numpy.dot(numpy.linalg.inv(MTAB1), MTAB2)
+        #        S12 = MTAB
+        #
+        #        MTBA1 = numpy.dot(O11, BetaA + BetaB)
+        #        MTBA2 = numpy.dot(O21, 2. * BetaB)
+        #        MTBA = numpy.dot(numpy.linalg.inv(MTBA1), MTBA2)
+        #        S21 = MTBA
+
+        SUM = numpy.dot(BetaA, O21) + numpy.dot(O21, BetaB)
+        DIF = numpy.dot(BetaA, O21) - numpy.dot(O21, BetaB)
+        A = 0.5 * numpy.dot(numpy.linalg.inv(BetaA), SUM)
+        B = 0.5 * numpy.dot(numpy.linalg.inv(BetaA), DIF)
+        A_1 = numpy.linalg.inv(A)
+        S11 = numpy.dot(B, A_1)
+        S12 = A - numpy.dot(numpy.dot(B, A_1), B)
+        S21 = A_1
+        S22 = -numpy.dot(A_1, B)
+
+        dim = O11.shape[0]
+
+        S = numpy.zeros((2 * dim, 2 * dim), dtype=complex)
+        S[:dim, :dim] = S11
+        S[dim:, dim:] = S22
+        S[:dim, dim:] = S12
+        S[dim:, :dim] = S21
+
+        self.S = S
+        self.T = S2T(self.S)
+
+    def plot(self, sumx=1, nxy=100, nz=100, z0=0):
+        pass
+
+
+class GenericDevice:
+    def __init__(self, devlist, inputLHS=None, inputRHS=None):
+        self.devlist = devlist
+        self.build_matrix()
+        self.compute_output(inputLHS, inputRHS)
+
+    def compute_output(self, inputLHS=None, inputRHS=None):
+        if inputLHS is None:
+            self.inputLHS = numpy.zeros_like(self.devlist[0].inputLHS)
+            self.inputLHS[0] = 1.0
+        else:
+            self.inputLHS = inputLHS
+        if inputRHS is None:
+            self.inputRHS = numpy.zeros_like(self.devlist[0].inputRHS)
+        else:
+            self.inputRHS = inputRHS
+        input = numpy.r_[self.inputLHS, self.inputRHS]
+        output = numpy.dot(self.S, input)
+        self.outputLHS = output[: len(self.inputLHS)]
+        self.outputRHS = output[len(self.inputLHS) :]
+        # compute for each device
+        inputLHS = self.inputLHS
+        outputLHS = self.outputLHS
+        dim = len(inputLHS)
+        for d in self.devlist:
+            d.inputLHS = inputLHS
+            d.outputLHS = outputLHS
+            LHS = numpy.r_[inputLHS, outputLHS]
+            RHS = numpy.dot(d.T, LHS)
+            d.outputRHS = RHS[:dim]
+            d.inputRHS = RHS[dim:]
+            inputLHS = d.outputRHS
+            outputLHS = d.inputRHS
+
+    def build_matrix(self):
+        dim = self.devlist[0].solver.nmodes
+        T = numpy.eye(2 * dim, dtype=complex)
+        for d in self.devlist:
+            T = numpy.dot(d.T, T)
+        self.T = T
+        self.S = T2S(self.T)
+
+    def plot(self, sumx=1, nxy=100, nz=100, z0=0):
+        z = z0
+        for d in self.devlist:
+            d.plot(sumx, nxy, nz, z0=z)
+            z += d.length
+        pylab.ylabel("z")
+        if sumx is None:
+            pylab.xlabel("y")
+        else:
+            pylab.xlabel("x")
+        pylab.axis("tight")

EMpy/modesolvers/interface.py

@@ -0,0 +1,71 @@
+import numpy
+
+
+class ModeSolver:
+    def solve(self, *argv):
+        raise NotImplementedError()
+
+
+class Mode:
+    def get_x(self, x=None, y=None):
+        raise NotImplementedError()
+
+    def get_y(self, x=None, y=None):
+        raise NotImplementedError()
+
+    def intensity(self, x=None, y=None):
+        raise NotImplementedError()
+
+    def TEfrac(self, x=None, y=None):
+        raise NotImplementedError()
+
+    def overlap(self, x=None, y=None):
+        raise NotImplementedError()
+
+    def get_fields_for_FDTD(self, x, y):
+        raise NotImplementedError()
+
+    def save_for_FDTD(self, mode_id="", x=None, y=None):
+        """Save mode's fields on a staggered grid."""
+        Ex_FDTD, Ey_FDTD, Ez_FDTD, Hx_FDTD, Hy_FDTD, Hz_FDTD = self.get_fields_for_FDTD(
+            x, y
+        )
+        Ex_FDTD.real.T.tofile("ex" + mode_id + ".dat", sep=" ")
+        Ex_FDTD.imag.T.tofile("iex" + mode_id + ".dat", sep=" ")
+        Ey_FDTD.real.T.tofile("ey" + mode_id + ".dat", sep=" ")
+        Ey_FDTD.imag.T.tofile("iey" + mode_id + ".dat", sep=" ")
+        Ez_FDTD.real.T.tofile("ez" + mode_id + ".dat", sep=" ")
+        Ez_FDTD.imag.T.tofile("iez" + mode_id + ".dat", sep=" ")
+        Hx_FDTD.real.T.tofile("hx" + mode_id + ".dat", sep=" ")
+        Hx_FDTD.imag.T.tofile("ihx" + mode_id + ".dat", sep=" ")
+        Hy_FDTD.real.T.tofile("hy" + mode_id + ".dat", sep=" ")
+        Hy_FDTD.imag.T.tofile("ihy" + mode_id + ".dat", sep=" ")
+        Hz_FDTD.real.T.tofile("hz" + mode_id + ".dat", sep=" ")
+        Hz_FDTD.imag.T.tofile("ihz" + mode_id + ".dat", sep=" ")
+
+    def plot(self, x=None, y=None):
+        raise NotImplementedError()
+
+
+def overlap(m1, m2, x=None, y=None):
+    return m1.overlap(m2, x, y)
+
+
+def interface_matrix(solver1, solver2, x=None, y=None):
+
+    neigs = solver1.nmodes
+
+    O11 = numpy.zeros((neigs, neigs), dtype=complex)
+    O22 = numpy.zeros((neigs, neigs), dtype=complex)
+    O12 = numpy.zeros((neigs, neigs), dtype=complex)
+    O21 = numpy.zeros((neigs, neigs), dtype=complex)
+
+    for i in range(neigs):
+        for j in range(neigs):
+
+            O11[i, j] = overlap(solver1.modes[i], solver1.modes[j], x, y)
+            O22[i, j] = overlap(solver2.modes[i], solver2.modes[j], x, y)
+            O12[i, j] = overlap(solver1.modes[i], solver2.modes[j], x, y)
+            O21[i, j] = overlap(solver2.modes[i], solver1.modes[j], x, y)
+
+    return (O11, O22, O12, O21)

EMpy/scattering.py

@@ -0,0 +1,236 @@
+import numpy
+import EMpy
+
+__author__ = "Julien Hillairet"
+
+
+class Field:
+    """Class to describe an electromagnetic field.
+
+    A EM field is a vector field which is the combination of an electric field E and a magnetic field H.
+    These fields are defined on some space point r
+
+    @ivar E: Electric vector on point M{r} in the cartesian coordinate system M{(Ex,Ey,Ez)}
+    @type E: 2d numpy.ndarray of shape (3,N)
+    @ivar H: Magnetic vector on point M{r} in the cartesian coordinate system M{(Mx,My,Mz)}
+    @type H: 2d numpy.ndarray of shape (3,N)
+    @ivar r: Position vector in cartesian coordinates M{(x,y,z)}
+    @type r: 2d numpy.ndarray of shape (3,N)
+
+    """
+
+    def __init__(
+        self, E=numpy.zeros((3, 1)), H=numpy.zeros((3, 1)), r=numpy.zeros((3, 1))
+    ):
+        """Initialize the Field object with an Electric, Magnetic and Position vectors."""
+        self.E = E
+        self.H = H
+        self.r = r
+
+
+"""
+##############################################################
+utils functions for field manipulations
+##############################################################
+"""
+
+
+def stack(X, Y, Z):
+    """Stack 3 vectors of different lengths into one vector.
+
+    stack 3 vectors of different length to one vector of type
+    M{P(n) = [x(n); y(n); z(n)]} with M{n=[1:Nx*Ny*Nz]}
+
+    Examples
+    ========
+        >>> import numpy
+        >>> X = numpy.arange(4); Y = numpy.arange(3); Z = numpy.arange(2)
+        >>> S = field.stack(X,Y,Z)
+        >>> print S
+        [[ 0.  0.  0.  0.  0.  0.  1.  1.  1.  1.  1.  1.  2.  2.  2.  2.  2.  2.  3.  3.  3.  3.  3.  3.]
+         [ 0.  0.  1.  1.  2.  2.  0.  0.  1.  1.  2.  2.  0.  0.  1.  1.  2.  2.  0.  0.  1.  1.  2.  2.]
+         [ 0.  1.  0.  1.  0.  1.  0.  1.  0.  1.  0.  1.  0.  1.  0.  1.  0.  1.  0.  1.  0.  1.  0.  1.]]
+
+    Checking the size of the returned array
+        >>> numpy.size(S,axis=1) == numpy.size(X,axis=0)*numpy.size(Y,axis=0)*numpy.size(Z,axis=0)
+        True
+
+    @param X: first vector.of length Nx
+    @type X: numpy.ndarray of shape (1, Nx).
+    @param Y: second vector.of length Ny
+    @type Y: numpy.ndarray of shape (1, Ny).
+    @param Z: third vector.of length Nz
+    @type Z: numpy.ndarray of shape (1, Nz).
+
+    @return: stacked array.
+    @rtype: numpy.ndarray of shape (3, Nx*Ny*Nz)
+
+    """
+    Nx = numpy.size(X, axis=0)
+    Ny = numpy.size(Y, axis=0)
+    Nz = numpy.size(Z, axis=0)
+
+    XX = numpy.reshape(numpy.transpose(numpy.ones((Ny * Nz, 1)) * X), (1, Ny * Nz * Nx))
+    YY = numpy.tile(
+        numpy.reshape(numpy.transpose(numpy.ones((Nz, 1)) * Y), (1, Ny * Nz)), (1, Nx)
+    )
+    ZZ = numpy.tile(Z, (1, Nx * Ny))
+
+    return numpy.vstack((XX, YY, ZZ))
+
+
+def matlab_dot(a, b):
+    """
+    "classical" dot product (as defined in octave or matlab)
+
+    Example
+    =======
+        >>> a=numpy.array([1,2,3]).repeat(6).reshape((3,6))
+        >>> print a
+        [[1 1 1 1 1 1]
+         [2 2 2 2 2 2]
+         [3 3 3 3 3 3]]
+        >>> field.matlab_dot(a,a)
+        array([14, 14, 14, 14, 14, 14])
+
+    where M{14=1*1+2*2+3*3}
+
+    @param a: first vector of length N
+    @type  a: numpy.ndarray of shape (M,N)
+    @param b: second vector of length N
+    @type  b: numpy.ndarray of shape (M,N)
+
+    @return: "classical" dot product between M{a} and M{b}
+    @rtype: numpy.ndarray of shape (1,N)
+
+    """
+    return numpy.sum(a * b, axis=0)
+
+
+"""
+##########################################
+Common functions for calculating EM fields
+##########################################
+"""
+
+
+def currentsScatteringKottler(P, J, M, Q, dS, f, epsr=1):
+    """
+    Compute the scattered fields on some point M{P} in cartesian coordinates M{P(Px,Py,Pz)}
+    by electric (and even magnetic) currents densities M{J}, M{M}
+    defined on a surface M{Q(Qx,Qy,Qz)}.
+    M{dS} corresponds to the surface element M{dS} of surface M{Q}
+
+    TODO:
+     - Maybe an option to compute only main expression in farfield
+     - Optimisation ? (At the present time, python version is slower than the matlab code)
+
+    @param P: observation points M{P(Px,Py,Pz)}.
+    @type  P: numpy.ndarray of shape (3,NbP)
+    @param J: electric current density on M{Q}
+    @type  J: numpy.ndarray of shape (3,NbQ)
+    @param M: magnetic current density on M{Q}
+    @type  M: numpy.ndarray of shape (3,NbQ)
+    @param Q: radiating (surface) points M{Q(Qx,Qy,Qz)}.
+    @type  Q: numpy.ndarray of shape (3,NbQ)
+    @param dS: surface elements of the radiating surface
+    @type dS: numpy.ndarray of shape (1,NbQ)
+    @param f: frequency
+    @type  f: float
+    @param epsr: relative permittivity (dielectric constant)  (defaut : 1, vacuum)
+    @type  epsr: float
+
+    @return: EM Field on M{P}
+    @rtype: L{Field}
+
+
+    """
+    # test if the parameters size are correct
+    if (
+        numpy.size(P, axis=0) != 3
+        or numpy.size(Q, axis=0) != 3
+        or numpy.size(J, axis=0) != 3
+        or numpy.size(M, axis=0) != 3
+    ):
+        EMpy.utils.warning(
+            "Bad parameters size : number of rows must be 3 for vectors P,Q,J,M"
+        )
+
+    if (
+        not numpy.size(Q, axis=1)
+        == numpy.size(J, axis=1)
+        == numpy.size(M, axis=1)
+        == numpy.size(dS, axis=1)
+    ):
+        EMpy.utils.warning(
+            "Bad parameters size : number of columns between Q,J,M and dS must be equal"
+        )
+
+    lambda0 = EMpy.constants.c / f
+    lambdam = lambda0 / numpy.sqrt(epsr)
+    # k0 = 2*numpy.pi/lambda0
+    km = 2 * numpy.pi / lambdam
+    Z0 = 120 * numpy.pi
+    NbP = numpy.size(P, axis=1)
+    NbQ = numpy.size(Q, axis=1)
+
+    # preallocation
+    EMF_P = Field(
+        numpy.zeros((3, NbP), dtype=complex), numpy.zeros((3, NbP), dtype=complex), P
+    )
+
+    # for all observation point
+    # PB = EMpy.utils.ProgressBar()
+    for ind in numpy.arange(NbP):
+        # distance between scattering and observation point
+        QP = P[:, ind].reshape((3, 1)) * numpy.ones((1, NbQ)) - Q
+        r = numpy.sqrt(numpy.sum(QP**2, axis=0))
+        # unit vector
+        r1 = QP / r
+        # integrand expression shorcuts
+        kmr = km * r
+        kmr_1 = 1 / kmr
+        kmr_2 = kmr_1**2
+        aa = 1 - 1j * kmr_1 - kmr_2
+        bb = -1 + 3 * 1j * kmr_1 + 3 * kmr_2
+        cc = 1 - 1j * kmr_1
+        # scalar product
+        r1dotJ = matlab_dot(r1, J)
+        r1dotM = matlab_dot(r1, -M)
+        # Kottler EM fields
+        EMF_P.E[:, ind] = (
+            km
+            / (4 * numpy.pi * 1j)
+            * numpy.sum(
+                (
+                    Z0
+                    / numpy.sqrt(epsr)
+                    * (aa * J + bb * (r1dotJ * numpy.ones((3, 1))) * r1)
+                    + cc * numpy.cross(r1, -M, axis=0)
+                )
+                * numpy.exp(-1j * km * r)
+                / r
+                * dS,
+                axis=1,
+            )
+        )
+        EMF_P.H[:, ind] = (
+            -km
+            / (4 * numpy.pi * 1j)
+            * numpy.sum(
+                (
+                    numpy.sqrt(epsr)
+                    / Z0
+                    * (-aa * M + bb * (r1dotM * numpy.ones((3, 1))) * r1)
+                    - cc * numpy.cross(r1, J, axis=0)
+                )
+                * numpy.exp(-1j * km * r)
+                / r
+                * dS,
+                axis=1,
+            )
+        )
+        # waitbar update
+        # PB.update((ind+1)*100.0/NbP)
+
+    return EMF_P