ElectroMagneticPython 2.1.5__py3-none-any.whl → 2.2.1__py3-none-any.whl

EMpy/RCWA.py

@@ -14,7 +14,7 @@ one, only stable for low diffraction orders and thin layers.
 """
 __author__ = "Lorenzo Bolla"
 
-import scipy as S
+import numpy as np
 from scipy.linalg import toeplitz, inv, eig, solve as linsolve
 from numpy import pi
 
@@ -41,7 +41,7 @@ def dispersion_relation_ordinary(kx, ky, k, nO):
         raise ValueError("kx and ky must have the same length")
 
     delta = (k * nO) ** 2 - (kx**2 + ky**2)
-    kz = S.sqrt(delta)
+    kz = np.sqrt(delta)
 
     # Adjust sign of real/imag part
     kz.real = abs(kz.real)
@@ -65,14 +65,14 @@ def dispersion_relation_extraordinary(kx, ky, k, nO, nE, c):
             "kx and ky must have the same length and c must have 3 components"
         )
 
-    kz = S.empty_like(kx)
+    kz = np.empty_like(kx)
 
     for ii in range(0, kx.size):
         alpha = nE**2 - nO**2
         beta = kx[ii] / k * c[0] + ky[ii] / k * c[1]
 
         # coeffs
-        C = S.array(
+        C = np.array(
             [
                 nO**2 + c[2] ** 2 * alpha,
                 2.0 * c[2] * beta * alpha,
@@ -83,13 +83,13 @@ def dispersion_relation_extraordinary(kx, ky, k, nO, nE, c):
         )
 
         # two solutions of type +x or -x, purely real or purely imag
-        tmp_kz = k * S.roots(C)
+        tmp_kz = k * np.roots(C)
 
         # get the negative imaginary part or the positive real one
-        if S.any(S.isreal(tmp_kz)):
-            kz[ii] = S.absolute(tmp_kz[0])
+        if np.any(np.isreal(tmp_kz)):
+            kz[ii] = np.absolute(tmp_kz[0])
         else:
-            kz[ii] = -1j * S.absolute(tmp_kz[0])
+            kz[ii] = -1j * np.absolute(tmp_kz[0])
 
     return kz
 
@@ -145,7 +145,7 @@ class RCWA:
     def get_pitch(self):
         """Inspect the multilayer to check that all the binary
         gratings present have the same pitch, and return it."""
-        idx = S.where(
+        idx = np.where(
             [
                 (
                     isinstance(m, BinaryGrating)
@@ -160,8 +160,8 @@ class RCWA:
             return 1.0  # return LAMBDA: any value will do
         else:
             # check that all the pitches are the same!
-            l = S.asarray([self.multilayer[i].pitch for i in idx])
-            if not S.all(l == l[0]):
+            l = np.asarray([self.multilayer[i].pitch for i in idx])
+            if not np.all(l == l[0]):
                 raise ValueError("All the BinaryGratings must have the same pitch.")
             else:
                 return l[0]
@@ -192,7 +192,7 @@ class IsotropicRCWA(RCWA):
         matrix approach", JOSA A, 12(5), 1995
         """
 
-        self.wls = S.atleast_1d(wls)
+        self.wls = np.atleast_1d(wls)
 
         LAMBDA = self.LAMBDA
         n = self.n
@@ -203,32 +203,32 @@ class IsotropicRCWA(RCWA):
         phi = self.phi
 
         nlayers = len(multilayer)
-        i = S.arange(-n, n + 1)
+        i = np.arange(-n, n + 1)
         nood = 2 * n + 1
         hmax = nood - 1
 
         # grating vector (on the xz plane)
         # grating on the xy plane
-        K = 2 * pi / LAMBDA * S.array([S.sin(phi), 0.0, S.cos(phi)], dtype=complex)
+        K = 2 * pi / LAMBDA * np.array([np.sin(phi), 0.0, np.cos(phi)], dtype=complex)
 
-        DE1 = S.zeros((nood, self.wls.size))
-        DE3 = S.zeros_like(DE1)
+        DE1 = np.zeros((nood, self.wls.size))
+        DE3 = np.zeros_like(DE1)
 
-        dirk1 = S.array(
-            [S.sin(alpha) * S.cos(delta), S.sin(alpha) * S.sin(delta), S.cos(alpha)]
+        dirk1 = np.array(
+            [np.sin(alpha) * np.cos(delta), np.sin(alpha) * np.sin(delta), np.cos(alpha)]
         )
 
         # usefull matrices
-        I = S.eye(i.size)
-        I2 = S.eye(i.size * 2)
-        ZERO = S.zeros_like(I)
+        I = np.eye(i.size)
+        I2 = np.eye(i.size * 2)
+        ZERO = np.zeros_like(I)
 
-        X = S.zeros((2 * nood, 2 * nood, nlayers), dtype=complex)
-        MTp1 = S.zeros((2 * nood, 2 * nood, nlayers), dtype=complex)
-        MTp2 = S.zeros_like(MTp1)
+        X = np.zeros((2 * nood, 2 * nood, nlayers), dtype=complex)
+        MTp1 = np.zeros((2 * nood, 2 * nood, nlayers), dtype=complex)
+        MTp2 = np.zeros_like(MTp1)
 
-        EPS2 = S.zeros(2 * hmax + 1, dtype=complex)
-        EPS21 = S.zeros_like(EPS2)
+        EPS2 = np.zeros(2 * hmax + 1, dtype=complex)
+        EPS21 = np.zeros_like(EPS2)
 
         dlt = (i == 0).astype(int)
 
@@ -244,40 +244,40 @@ class IsotropicRCWA(RCWA):
 
             # all the other wavevectors
             tmp_x = k1[0] - i * K[0]
-            tmp_y = k1[1] * S.ones_like(i)
+            tmp_y = k1[1] * np.ones_like(i)
             tmp_z = dispersion_relation_ordinary(tmp_x, tmp_y, k, n1)
-            k1i = S.r_[[tmp_x], [tmp_y], [tmp_z]]
+            k1i = np.r_[[tmp_x], [tmp_y], [tmp_z]]
 
-            # k2i = S.r_[[k1[0] - i*K[0]], [k1[1] - i * K[1]], [-i * K[2]]]
+            # k2i = np.r_[[k1[0] - i*K[0]], [k1[1] - i * K[1]], [-i * K[2]]]
 
             tmp_z = dispersion_relation_ordinary(tmp_x, tmp_y, k, n3)
-            k3i = S.r_[[k1i[0, :]], [k1i[1, :]], [tmp_z]]
+            k3i = np.r_[[k1i[0, :]], [k1i[1, :]], [tmp_z]]
 
             # aliases for constant wavevectors
             kx = k1i[0, :]
             ky = k1[1]
 
             # angles of reflection
-            # phi_i = S.arctan2(ky,kx)
-            phi_i = S.arctan2(ky, kx.real)  # OKKIO
+            # phi_i = np.arctan2(ky,kx)
+            phi_i = np.arctan2(ky, kx.real)  # OKKIO
 
-            Kx = S.diag(kx / k)
+            Kx = np.diag(kx / k)
             Ky = ky / k * I
-            Z1 = S.diag(k1i[2, :] / (k * n1**2))
-            Y1 = S.diag(k1i[2, :] / k)
-            Z3 = S.diag(k3i[2, :] / (k * n3**2))
-            Y3 = S.diag(k3i[2, :] / k)
-            # Fc = S.diag(S.cos(phi_i))
-            fc = S.cos(phi_i)
-            # Fs = S.diag(S.sin(phi_i))
-            fs = S.sin(phi_i)
-
-            MR = S.asarray(
-                S.bmat([[I, ZERO], [-1j * Y1, ZERO], [ZERO, I], [ZERO, -1j * Z1]])
+            Z1 = np.diag(k1i[2, :] / (k * n1**2))
+            Y1 = np.diag(k1i[2, :] / k)
+            Z3 = np.diag(k3i[2, :] / (k * n3**2))
+            Y3 = np.diag(k3i[2, :] / k)
+            # Fc = np.diag(np.cos(phi_i))
+            fc = np.cos(phi_i)
+            # Fs = np.diag(np.sin(phi_i))
+            fs = np.sin(phi_i)
+
+            MR = np.asarray(
+                np.bmat([[I, ZERO], [-1j * Y1, ZERO], [ZERO, I], [ZERO, -1j * Z1]])
             )
 
-            MT = S.asarray(
-                S.bmat([[I, ZERO], [1j * Y3, ZERO], [ZERO, I], [ZERO, 1j * Z3]])
+            MT = np.asarray(
+                np.bmat([[I, ZERO], [1j * Y3, ZERO], [ZERO, I], [ZERO, 1j * Z3]])
             )
 
             # internal layers (grating or layer)
@@ -293,10 +293,10 @@ class IsotropicRCWA(RCWA):
                 E = toeplitz(EPS2[hmax::-1], EPS2[hmax:])
                 E1 = toeplitz(EPS21[hmax::-1], EPS21[hmax:])
                 E11 = inv(E1)
-                # B = S.dot(Kx, linsolve(E,Kx)) - I
-                B = kx[:, S.newaxis] / k * linsolve(E, Kx) - I
-                # A = S.dot(Kx, Kx) - E
-                A = S.diag((kx / k) ** 2) - E
+                # B = np.dot(Kx, linsolve(E,Kx)) - I
+                B = kx[:, np.newaxis] / k * linsolve(E, Kx) - I
+                # A = np.dot(Kx, Kx) - E
+                A = np.diag((kx / k) ** 2) - E
 
                 # Note: solution bug alfredo
                 # randomizzo Kx un po' a caso finche' cond(A) e' piccolo (<1e10)
@@ -307,59 +307,59 @@ class IsotropicRCWA(RCWA):
                 if cond(A) > 1e10:
                     warning("BAD CONDITIONING: randomization of kx")
                     while cond(A) > 1e10:
-                        Kx = Kx * (1 + 1e-9 * S.rand())
-                        B = kx[:, S.newaxis] / k * linsolve(E, Kx) - I
-                        A = S.diag((kx / k) ** 2) - E
+                        Kx = Kx * (1 + 1e-9 * np.rand())
+                        B = kx[:, np.newaxis] / k * linsolve(E, Kx) - I
+                        A = np.diag((kx / k) ** 2) - E
 
-                if S.absolute(K[2] / k) > 1e-10:
+                if np.absolute(K[2] / k) > 1e-10:
                     raise ValueError(
                         "First Order Helmholtz Operator not implemented, yet!"
                     )
 
-                elif ky == 0 or S.allclose(S.diag(Ky / ky * k), 1):
+                elif ky == 0 or np.allclose(np.diag(Ky / ky * k), 1):
                     # lalanne
-                    # H_U_reduced = S.dot(Ky, Ky) + A
+                    # H_U_reduced = np.dot(Ky, Ky) + A
                     H_U_reduced = (ky / k) ** 2 * I + A
-                    # H_S_reduced = S.dot(Ky, Ky) + S.dot(Kx, linsolve(E, S.dot(Kx, E11))) - E11
+                    # H_S_reduced = np.dot(Ky, Ky) + np.dot(Kx, linsolve(E, np.dot(Kx, E11))) - E11
                     H_S_reduced = (
                         (ky / k) ** 2 * I
-                        + kx[:, S.newaxis] / k * linsolve(E, kx[:, S.newaxis] / k * E11)
+                        + kx[:, np.newaxis] / k * linsolve(E, kx[:, np.newaxis] / k * E11)
                         - E11
                     )
 
                     q1, W1 = eig(H_U_reduced)
-                    q1 = S.sqrt(q1)
+                    q1 = np.sqrt(q1)
                     q2, W2 = eig(H_S_reduced)
-                    q2 = S.sqrt(q2)
+                    q2 = np.sqrt(q2)
 
                     # boundary conditions
 
-                    # V11 = S.dot(linsolve(A, W1), S.diag(q1))
-                    V11 = linsolve(A, W1) * q1[S.newaxis, :]
-                    V12 = (ky / k) * S.dot(linsolve(A, Kx), W2)
-                    V21 = (ky / k) * S.dot(linsolve(B, Kx), linsolve(E, W1))
-                    # V22 = S.dot(linsolve(B, W2), S.diag(q2))
-                    V22 = linsolve(B, W2) * q2[S.newaxis, :]
-
-                    # Vss = S.dot(Fc, V11)
-                    Vss = fc[:, S.newaxis] * V11
-                    # Wss = S.dot(Fc, W1)  + S.dot(Fs, V21)
-                    Wss = fc[:, S.newaxis] * W1 + fs[:, S.newaxis] * V21
-                    # Vsp = S.dot(Fc, V12) - S.dot(Fs, W2)
-                    Vsp = fc[:, S.newaxis] * V12 - fs[:, S.newaxis] * W2
-                    # Wsp = S.dot(Fs, V22)
-                    Wsp = fs[:, S.newaxis] * V22
-                    # Wpp = S.dot(Fc, V22)
-                    Wpp = fc[:, S.newaxis] * V22
-                    # Vpp = S.dot(Fc, W2)  + S.dot(Fs, V12)
-                    Vpp = fc[:, S.newaxis] * W2 + fs[:, S.newaxis] * V12
-                    # Wps = S.dot(Fc, V21) - S.dot(Fs, W1)
-                    Wps = fc[:, S.newaxis] * V21 - fs[:, S.newaxis] * W1
-                    # Vps = S.dot(Fs, V11)
-                    Vps = fs[:, S.newaxis] * V11
-
-                    Mc2bar = S.asarray(
-                        S.bmat(
+                    # V11 = np.dot(linsolve(A, W1), np.diag(q1))
+                    V11 = linsolve(A, W1) * q1[np.newaxis, :]
+                    V12 = (ky / k) * np.dot(linsolve(A, Kx), W2)
+                    V21 = (ky / k) * np.dot(linsolve(B, Kx), linsolve(E, W1))
+                    # V22 = np.dot(linsolve(B, W2), np.diag(q2))
+                    V22 = linsolve(B, W2) * q2[np.newaxis, :]
+
+                    # Vss = np.dot(Fc, V11)
+                    Vss = fc[:, np.newaxis] * V11
+                    # Wss = np.dot(Fc, W1)  + np.dot(Fs, V21)
+                    Wss = fc[:, np.newaxis] * W1 + fs[:, np.newaxis] * V21
+                    # Vsp = np.dot(Fc, V12) - np.dot(Fs, W2)
+                    Vsp = fc[:, np.newaxis] * V12 - fs[:, np.newaxis] * W2
+                    # Wsp = np.dot(Fs, V22)
+                    Wsp = fs[:, np.newaxis] * V22
+                    # Wpp = np.dot(Fc, V22)
+                    Wpp = fc[:, np.newaxis] * V22
+                    # Vpp = np.dot(Fc, W2)  + np.dot(Fs, V12)
+                    Vpp = fc[:, np.newaxis] * W2 + fs[:, np.newaxis] * V12
+                    # Wps = np.dot(Fc, V21) - np.dot(Fs, W1)
+                    Wps = fc[:, np.newaxis] * V21 - fs[:, np.newaxis] * W1
+                    # Vps = np.dot(Fs, V11)
+                    Vps = fs[:, np.newaxis] * V11
+
+                    Mc2bar = np.asarray(
+                        np.bmat(
                             [
                                 [Vss, Vsp, Vss, Vsp],
                                 [Wss, Wsp, -Wss, -Wsp],
@@ -369,51 +369,51 @@ class IsotropicRCWA(RCWA):
                         )
                     )
 
-                    x = S.r_[S.exp(-k * q1 * d), S.exp(-k * q2 * d)]
+                    x = np.r_[np.exp(-k * q1 * d), np.exp(-k * q2 * d)]
 
-                    # Mc1 = S.dot(Mc2bar, S.diag(S.r_[S.ones_like(x), x]))
-                    xx = S.r_[S.ones_like(x), x]
-                    Mc1 = Mc2bar * xx[S.newaxis, :]
+                    # Mc1 = np.dot(Mc2bar, np.diag(np.r_[np.ones_like(x), x]))
+                    xx = np.r_[np.ones_like(x), x]
+                    Mc1 = Mc2bar * xx[np.newaxis, :]
 
-                    X[:, :, nlayer] = S.diag(x)
+                    X[:, :, nlayer] = np.diag(x)
 
                     MTp = linsolve(Mc2bar, MT)
                     MTp1[:, :, nlayer] = MTp[0 : 2 * nood, :]
                     MTp2 = MTp[2 * nood :, :]
 
-                    MT = S.dot(
+                    MT = np.dot(
                         Mc1,
-                        S.r_[
+                        np.r_[
                             I2,
-                            S.dot(MTp2, linsolve(MTp1[:, :, nlayer], X[:, :, nlayer])),
+                            np.dot(MTp2, linsolve(MTp1[:, :, nlayer], X[:, :, nlayer])),
                         ],
                     )
 
                 else:
                     ValueError("Second Order Helmholtz Operator not implemented, yet!")
 
-            # M = S.asarray(S.bmat([-MR, MT]))
-            M = S.c_[-MR, MT]
-            b = S.r_[
-                S.sin(psi) * dlt,
-                1j * S.sin(psi) * n1 * S.cos(alpha) * dlt,
-                -1j * S.cos(psi) * n1 * dlt,
-                S.cos(psi) * S.cos(alpha) * dlt,
+            # M = np.asarray(np.bmat([-MR, MT]))
+            M = np.c_[-MR, MT]
+            b = np.r_[
+                np.sin(psi) * dlt,
+                1j * np.sin(psi) * n1 * np.cos(alpha) * dlt,
+                -1j * np.cos(psi) * n1 * dlt,
+                np.cos(psi) * np.cos(alpha) * dlt,
             ]
 
             x = linsolve(M, b)
-            R, T = S.split(x, 2)
-            Rs, Rp = S.split(R, 2)
+            R, T = np.split(x, 2)
+            Rs, Rp = np.split(R, 2)
             for ii in range(1, nlayers - 1):
-                T = S.dot(linsolve(MTp1[:, :, ii], X[:, :, ii]), T)
-            Ts, Tp = S.split(T, 2)
+                T = np.dot(linsolve(MTp1[:, :, ii], X[:, :, ii]), T)
+            Ts, Tp = np.split(T, 2)
 
-            DE1[:, iwl] = (k1i[2, :] / (k1[2])).real * S.absolute(Rs) ** 2 + (
+            DE1[:, iwl] = (k1i[2, :] / (k1[2])).real * np.absolute(Rs) ** 2 + (
                 k1i[2, :] / (k1[2] * n1**2)
-            ).real * S.absolute(Rp) ** 2
-            DE3[:, iwl] = (k3i[2, :] / (k1[2])).real * S.absolute(Ts) ** 2 + (
+            ).real * np.absolute(Rp) ** 2
+            DE3[:, iwl] = (k3i[2, :] / (k1[2])).real * np.absolute(Ts) ** 2 + (
                 k3i[2, :] / (k1[2] * n3**2)
-            ).real * S.absolute(Tp) ** 2
+            ).real * np.absolute(Tp) ** 2
 
         # save the results
         self.DE1 = DE1
@@ -462,7 +462,7 @@ class AnisotropicRCWA(RCWA):
         and transmitted.
         """
 
-        self.wls = S.atleast_1d(wls)
+        self.wls = np.atleast_1d(wls)
 
         LAMBDA = self.LAMBDA
         n = self.n
@@ -473,39 +473,39 @@ class AnisotropicRCWA(RCWA):
         phi = self.phi
 
         nlayers = len(multilayer)
-        i = S.arange(-n, n + 1)
+        i = np.arange(-n, n + 1)
         nood = 2 * n + 1
         hmax = nood - 1
 
-        DEO1 = S.zeros((nood, self.wls.size))
-        DEO3 = S.zeros_like(DEO1)
-        DEE1 = S.zeros_like(DEO1)
-        DEE3 = S.zeros_like(DEO1)
+        DEO1 = np.zeros((nood, self.wls.size))
+        DEO3 = np.zeros_like(DEO1)
+        DEE1 = np.zeros_like(DEO1)
+        DEE3 = np.zeros_like(DEO1)
 
-        c1 = S.array([1.0, 0.0, 0.0])
-        c3 = S.array([1.0, 0.0, 0.0])
+        c1 = np.array([1.0, 0.0, 0.0])
+        c3 = np.array([1.0, 0.0, 0.0])
         # grating on the xy plane
-        K = 2 * pi / LAMBDA * S.array([S.sin(phi), 0.0, S.cos(phi)], dtype=complex)
-        dirk1 = S.array(
-            [S.sin(alpha) * S.cos(delta), S.sin(alpha) * S.sin(delta), S.cos(alpha)]
+        K = 2 * pi / LAMBDA * np.array([np.sin(phi), 0.0, np.cos(phi)], dtype=complex)
+        dirk1 = np.array(
+            [np.sin(alpha) * np.cos(delta), np.sin(alpha) * np.sin(delta), np.cos(alpha)]
         )
 
         # D polarization vector
-        u = S.array(
+        u = np.array(
             [
-                S.cos(psi) * S.cos(alpha) * S.cos(delta) - S.sin(psi) * S.sin(delta),
-                S.cos(psi) * S.cos(alpha) * S.sin(delta) + S.sin(psi) * S.cos(delta),
-                -S.cos(psi) * S.sin(alpha),
+                np.cos(psi) * np.cos(alpha) * np.cos(delta) - np.sin(psi) * np.sin(delta),
+                np.cos(psi) * np.cos(alpha) * np.sin(delta) + np.sin(psi) * np.cos(delta),
+                -np.cos(psi) * np.sin(alpha),
             ]
         )
 
-        kO1i = S.zeros((3, i.size), dtype=complex)
-        kE1i = S.zeros_like(kO1i)
-        kO3i = S.zeros_like(kO1i)
-        kE3i = S.zeros_like(kO1i)
+        kO1i = np.zeros((3, i.size), dtype=complex)
+        kE1i = np.zeros_like(kO1i)
+        kO3i = np.zeros_like(kO1i)
+        kE3i = np.zeros_like(kO1i)
 
-        Mp = S.zeros((4 * nood, 4 * nood, nlayers), dtype=complex)
-        M = S.zeros((4 * nood, 4 * nood, nlayers), dtype=complex)
+        Mp = np.zeros((4 * nood, 4 * nood, nlayers), dtype=complex)
+        M = np.zeros((4 * nood, 4 * nood, nlayers), dtype=complex)
 
         dlt = (i == 0).astype(int)
 
@@ -516,20 +516,20 @@ class AnisotropicRCWA(RCWA):
             # wavevectors
             k = 2 * pi / wl
 
-            eps1 = S.diag(S.asarray([nE1, nO1, nO1]) ** 2)
-            eps3 = S.diag(S.asarray([nE3, nO3, nO3]) ** 2)
+            eps1 = np.diag(np.asarray([nE1, nO1, nO1]) ** 2)
+            eps3 = np.diag(np.asarray([nE3, nO3, nO3]) ** 2)
 
             # ordinary wave
             abskO1 = k * nO1
             # abskO3 = k * nO3
             # extraordinary wave
-            # abskE1 = k * nO1 *nE1 / S.sqrt(nO1**2 + (nE1**2 - nO1**2) * S.dot(-c1, dirk1)**2)
-            # abskE3 = k * nO3 *nE3 / S.sqrt(nO3**2 + (nE3**2 - nO3**2) * S.dot(-c3, dirk1)**2)
+            # abskE1 = k * nO1 *nE1 / np.sqrt(nO1**2 + (nE1**2 - nO1**2) * np.dot(-c1, dirk1)**2)
+            # abskE3 = k * nO3 *nE3 / np.sqrt(nO3**2 + (nE3**2 - nO3**2) * np.dot(-c3, dirk1)**2)
 
             k1 = abskO1 * dirk1
 
             kO1i[0, :] = k1[0] - i * K[0]
-            kO1i[1, :] = k1[1] * S.ones_like(i)
+            kO1i[1, :] = k1[1] * np.ones_like(i)
             kO1i[2, :] = -dispersion_relation_ordinary(kO1i[0, :], kO1i[1, :], k, nO1)
 
             kE1i[0, :] = kO1i[0, :]
@@ -548,23 +548,23 @@ class AnisotropicRCWA(RCWA):
                 kE3i[0, :], kE3i[1, :], k, nO3, nE3, c3
             )
 
-            # k2i = S.r_[[k1[0] - i * K[0]], [k1[1] - i * K[1]], [k1[2] - i * K[2]]]
-            k2i = S.r_[[k1[0] - i * K[0]], [k1[1] - i * K[1]], [-i * K[2]]]
+            # k2i = np.r_[[k1[0] - i * K[0]], [k1[1] - i * K[1]], [k1[2] - i * K[2]]]
+            k2i = np.r_[[k1[0] - i * K[0]], [k1[1] - i * K[1]], [-i * K[2]]]
 
             # aliases for constant wavevectors
             kx = kO1i[0, :]  # o kE1i(1,;), tanto e' lo stesso
             ky = k1[1]
 
             # matrices
-            I = S.eye(nood, dtype=complex)
-            ZERO = S.zeros((nood, nood), dtype=complex)
-            Kx = S.diag(kx / k)
+            I = np.eye(nood, dtype=complex)
+            ZERO = np.zeros((nood, nood), dtype=complex)
+            Kx = np.diag(kx / k)
             Ky = ky / k * I
-            Kz = S.diag(k2i[2, :] / k)
-            KO1z = S.diag(kO1i[2, :] / k)
-            KE1z = S.diag(kE1i[2, :] / k)
-            KO3z = S.diag(kO3i[2, :] / k)
-            KE3z = S.diag(kE3i[2, :] / k)
+            Kz = np.diag(k2i[2, :] / k)
+            KO1z = np.diag(kO1i[2, :] / k)
+            KE1z = np.diag(kE1i[2, :] / k)
+            KO3z = np.diag(kO3i[2, :] / k)
+            KE3z = np.diag(kE3i[2, :] / k)
 
             ARO = Kx * eps1[0, 0] + Ky * eps1[1, 0] + KO1z * eps1[2, 0]
             BRO = Kx * eps1[0, 1] + Ky * eps1[1, 1] + KO1z * eps1[2, 1]
@@ -590,7 +590,7 @@ class AnisotropicRCWA(RCWA):
             ETE = c3[2] * Kx - c3[0] * KE3z
             FTE = c3[0] * Ky - c3[1] * Kx
 
-            b = S.r_[
+            b = np.r_[
                 u[0] * dlt,
                 u[1] * dlt,
                 (k1[1] / k * u[2] - k1[2] / k * u[1]) * dlt,
@@ -598,18 +598,18 @@ class AnisotropicRCWA(RCWA):
             ]
             Ky_CRO_1 = ky / k * CRO_1
             Ky_CRE_1 = ky / k * CRE_1
-            Kx_CRO_1 = kx[:, S.newaxis] / k * CRO_1
-            Kx_CRE_1 = kx[:, S.newaxis] / k * CRE_1
-            MR31 = -S.dot(Ky_CRO_1, ARO)
-            MR32 = -S.dot(Ky_CRO_1, BRO) - KO1z
-            MR33 = -S.dot(Ky_CRE_1, ARE)
-            MR34 = -S.dot(Ky_CRE_1, BRE) - KE1z
-            MR41 = S.dot(Kx_CRO_1, ARO) + KO1z
-            MR42 = S.dot(Kx_CRO_1, BRO)
-            MR43 = S.dot(Kx_CRE_1, ARE) + KE1z
-            MR44 = S.dot(Kx_CRE_1, BRE)
-            MR = S.asarray(
-                S.bmat(
+            Kx_CRO_1 = kx[:, np.newaxis] / k * CRO_1
+            Kx_CRE_1 = kx[:, np.newaxis] / k * CRE_1
+            MR31 = -np.dot(Ky_CRO_1, ARO)
+            MR32 = -np.dot(Ky_CRO_1, BRO) - KO1z
+            MR33 = -np.dot(Ky_CRE_1, ARE)
+            MR34 = -np.dot(Ky_CRE_1, BRE) - KE1z
+            MR41 = np.dot(Kx_CRO_1, ARO) + KO1z
+            MR42 = np.dot(Kx_CRO_1, BRO)
+            MR43 = np.dot(Kx_CRE_1, ARE) + KE1z
+            MR44 = np.dot(Kx_CRE_1, BRE)
+            MR = np.asarray(
+                np.bmat(
                     [
                         [I, ZERO, I, ZERO],
                         [ZERO, I, ZERO, I],
@@ -621,18 +621,18 @@ class AnisotropicRCWA(RCWA):
 
             Ky_CTO_1 = ky / k * CTO_1
             Ky_CTE_1 = ky / k * CTE_1
-            Kx_CTO_1 = kx[:, S.newaxis] / k * CTO_1
-            Kx_CTE_1 = kx[:, S.newaxis] / k * CTE_1
-            MT31 = -S.dot(Ky_CTO_1, ATO)
-            MT32 = -S.dot(Ky_CTO_1, BTO) - KO3z
-            MT33 = -S.dot(Ky_CTE_1, ATE)
-            MT34 = -S.dot(Ky_CTE_1, BTE) - KE3z
-            MT41 = S.dot(Kx_CTO_1, ATO) + KO3z
-            MT42 = S.dot(Kx_CTO_1, BTO)
-            MT43 = S.dot(Kx_CTE_1, ATE) + KE3z
-            MT44 = S.dot(Kx_CTE_1, BTE)
-            MT = S.asarray(
-                S.bmat(
+            Kx_CTO_1 = kx[:, np.newaxis] / k * CTO_1
+            Kx_CTE_1 = kx[:, np.newaxis] / k * CTE_1
+            MT31 = -np.dot(Ky_CTO_1, ATO)
+            MT32 = -np.dot(Ky_CTO_1, BTO) - KO3z
+            MT33 = -np.dot(Ky_CTE_1, ATE)
+            MT34 = -np.dot(Ky_CTE_1, BTE) - KE3z
+            MT41 = np.dot(Kx_CTO_1, ATO) + KO3z
+            MT42 = np.dot(Kx_CTO_1, BTO)
+            MT43 = np.dot(Kx_CTE_1, ATE) + KE3z
+            MT44 = np.dot(Kx_CTE_1, BTE)
+            MT = np.asarray(
+                np.bmat(
                     [
                         [I, ZERO, I, ZERO],
                         [ZERO, I, ZERO, I],
@@ -651,55 +651,55 @@ class AnisotropicRCWA(RCWA):
 
                 EPS2, EPS21 = layer.getEPSFourierCoeffs(wl, n, anisotropic=True)
 
-                # Exx = S.squeeze(EPS2[0, 0, :])
-                # Exx = toeplitz(S.flipud(Exx[0:hmax + 1]), Exx[hmax:])
-                Exy = S.squeeze(EPS2[0, 1, :])
-                Exy = toeplitz(S.flipud(Exy[0 : hmax + 1]), Exy[hmax:])
-                Exz = S.squeeze(EPS2[0, 2, :])
-                Exz = toeplitz(S.flipud(Exz[0 : hmax + 1]), Exz[hmax:])
-
-                Eyx = S.squeeze(EPS2[1, 0, :])
-                Eyx = toeplitz(S.flipud(Eyx[0 : hmax + 1]), Eyx[hmax:])
-                Eyy = S.squeeze(EPS2[1, 1, :])
-                Eyy = toeplitz(S.flipud(Eyy[0 : hmax + 1]), Eyy[hmax:])
-                Eyz = S.squeeze(EPS2[1, 2, :])
-                Eyz = toeplitz(S.flipud(Eyz[0 : hmax + 1]), Eyz[hmax:])
-
-                Ezx = S.squeeze(EPS2[2, 0, :])
-                Ezx = toeplitz(S.flipud(Ezx[0 : hmax + 1]), Ezx[hmax:])
-                Ezy = S.squeeze(EPS2[2, 1, :])
-                Ezy = toeplitz(S.flipud(Ezy[0 : hmax + 1]), Ezy[hmax:])
-                Ezz = S.squeeze(EPS2[2, 2, :])
-                Ezz = toeplitz(S.flipud(Ezz[0 : hmax + 1]), Ezz[hmax:])
-
-                Exx_1 = S.squeeze(EPS21[0, 0, :])
-                Exx_1 = toeplitz(S.flipud(Exx_1[0 : hmax + 1]), Exx_1[hmax:])
+                # Exx = np.squeeze(EPS2[0, 0, :])
+                # Exx = toeplitz(np.flipud(Exx[0:hmax + 1]), Exx[hmax:])
+                Exy = np.squeeze(EPS2[0, 1, :])
+                Exy = toeplitz(np.flipud(Exy[0 : hmax + 1]), Exy[hmax:])
+                Exz = np.squeeze(EPS2[0, 2, :])
+                Exz = toeplitz(np.flipud(Exz[0 : hmax + 1]), Exz[hmax:])
+
+                Eyx = np.squeeze(EPS2[1, 0, :])
+                Eyx = toeplitz(np.flipud(Eyx[0 : hmax + 1]), Eyx[hmax:])
+                Eyy = np.squeeze(EPS2[1, 1, :])
+                Eyy = toeplitz(np.flipud(Eyy[0 : hmax + 1]), Eyy[hmax:])
+                Eyz = np.squeeze(EPS2[1, 2, :])
+                Eyz = toeplitz(np.flipud(Eyz[0 : hmax + 1]), Eyz[hmax:])
+
+                Ezx = np.squeeze(EPS2[2, 0, :])
+                Ezx = toeplitz(np.flipud(Ezx[0 : hmax + 1]), Ezx[hmax:])
+                Ezy = np.squeeze(EPS2[2, 1, :])
+                Ezy = toeplitz(np.flipud(Ezy[0 : hmax + 1]), Ezy[hmax:])
+                Ezz = np.squeeze(EPS2[2, 2, :])
+                Ezz = toeplitz(np.flipud(Ezz[0 : hmax + 1]), Ezz[hmax:])
+
+                Exx_1 = np.squeeze(EPS21[0, 0, :])
+                Exx_1 = toeplitz(np.flipud(Exx_1[0 : hmax + 1]), Exx_1[hmax:])
                 Exx_1_1 = inv(Exx_1)
 
                 # lalanne
                 Ezz_1 = inv(Ezz)
                 Ky_Ezz_1 = ky / k * Ezz_1
-                Kx_Ezz_1 = kx[:, S.newaxis] / k * Ezz_1
-                Exz_Ezz_1 = S.dot(Exz, Ezz_1)
-                Eyz_Ezz_1 = S.dot(Eyz, Ezz_1)
-                H11 = 1j * S.dot(Ky_Ezz_1, Ezy)
-                H12 = 1j * S.dot(Ky_Ezz_1, Ezx)
-                H13 = S.dot(Ky_Ezz_1, Kx)
-                H14 = I - S.dot(Ky_Ezz_1, Ky)
-                H21 = 1j * S.dot(Kx_Ezz_1, Ezy)
-                H22 = 1j * S.dot(Kx_Ezz_1, Ezx)
-                H23 = S.dot(Kx_Ezz_1, Kx) - I
-                H24 = -S.dot(Kx_Ezz_1, Ky)
-                H31 = S.dot(Kx, Ky) + Exy - S.dot(Exz_Ezz_1, Ezy)
-                H32 = Exx_1_1 - S.dot(Ky, Ky) - S.dot(Exz_Ezz_1, Ezx)
-                H33 = 1j * S.dot(Exz_Ezz_1, Kx)
-                H34 = -1j * S.dot(Exz_Ezz_1, Ky)
-                H41 = S.dot(Kx, Kx) - Eyy + S.dot(Eyz_Ezz_1, Ezy)
-                H42 = -S.dot(Kx, Ky) - Eyx + S.dot(Eyz_Ezz_1, Ezx)
-                H43 = -1j * S.dot(Eyz_Ezz_1, Kx)
-                H44 = 1j * S.dot(Eyz_Ezz_1, Ky)
-                H = 1j * S.diag(S.repeat(S.diag(Kz), 4)) + S.asarray(
-                    S.bmat(
+                Kx_Ezz_1 = kx[:, np.newaxis] / k * Ezz_1
+                Exz_Ezz_1 = np.dot(Exz, Ezz_1)
+                Eyz_Ezz_1 = np.dot(Eyz, Ezz_1)
+                H11 = 1j * np.dot(Ky_Ezz_1, Ezy)
+                H12 = 1j * np.dot(Ky_Ezz_1, Ezx)
+                H13 = np.dot(Ky_Ezz_1, Kx)
+                H14 = I - np.dot(Ky_Ezz_1, Ky)
+                H21 = 1j * np.dot(Kx_Ezz_1, Ezy)
+                H22 = 1j * np.dot(Kx_Ezz_1, Ezx)
+                H23 = np.dot(Kx_Ezz_1, Kx) - I
+                H24 = -np.dot(Kx_Ezz_1, Ky)
+                H31 = np.dot(Kx, Ky) + Exy - np.dot(Exz_Ezz_1, Ezy)
+                H32 = Exx_1_1 - np.dot(Ky, Ky) - np.dot(Exz_Ezz_1, Ezx)
+                H33 = 1j * np.dot(Exz_Ezz_1, Kx)
+                H34 = -1j * np.dot(Exz_Ezz_1, Ky)
+                H41 = np.dot(Kx, Kx) - Eyy + np.dot(Eyz_Ezz_1, Ezy)
+                H42 = -np.dot(Kx, Ky) - Eyx + np.dot(Eyz_Ezz_1, Ezx)
+                H43 = -1j * np.dot(Eyz_Ezz_1, Kx)
+                H44 = 1j * np.dot(Eyz_Ezz_1, Ky)
+                H = 1j * np.diag(np.repeat(np.diag(Kz), 4)) + np.asarray(
+                    np.bmat(
                         [
                             [H11, H12, H13, H14],
                             [H21, H22, H23, H24],
@@ -710,7 +710,7 @@ class AnisotropicRCWA(RCWA):
                 )
 
                 q, W = eig(H)
-                W1, W2, W3, W4 = S.split(W, 4)
+                W1, W2, W3, W4 = np.split(W, 4)
 
                 #
                 # boundary conditions
@@ -727,38 +727,38 @@ class AnisotropicRCWA(RCWA):
                 # [b] = [-MR Mtot.MT] [R]
                 # [0]   [...........] [T]
 
-                z = S.zeros_like(q)
-                z[S.where(q.real > 0)] = -thickness
-                D = S.exp(k * q * z)
-                Sy0 = W1 * D[S.newaxis, :]
-                Sx0 = W2 * D[S.newaxis, :]
-                Uy0 = W3 * D[S.newaxis, :]
-                Ux0 = W4 * D[S.newaxis, :]
-
-                z = thickness * S.ones_like(q)
-                z[S.where(q.real > 0)] = 0
-                D = S.exp(k * q * z)
-                D1 = S.exp(-1j * k2i[2, :] * thickness)
-                Syd = D1[:, S.newaxis] * W1 * D[S.newaxis, :]
-                Sxd = D1[:, S.newaxis] * W2 * D[S.newaxis, :]
-                Uyd = D1[:, S.newaxis] * W3 * D[S.newaxis, :]
-                Uxd = D1[:, S.newaxis] * W4 * D[S.newaxis, :]
-
-                Mp[:, :, nlayer] = S.r_[Sx0, Sy0, -1j * Ux0, -1j * Uy0]
-                M[:, :, nlayer] = S.r_[Sxd, Syd, -1j * Uxd, -1j * Uyd]
-
-            Mtot = S.eye(4 * nood, dtype=complex)
+                z = np.zeros_like(q)
+                z[np.where(q.real > 0)] = -thickness
+                D = np.exp(k * q * z)
+                Sy0 = W1 * D[np.newaxis, :]
+                Sx0 = W2 * D[np.newaxis, :]
+                Uy0 = W3 * D[np.newaxis, :]
+                Ux0 = W4 * D[np.newaxis, :]
+
+                z = thickness * np.ones_like(q)
+                z[np.where(q.real > 0)] = 0
+                D = np.exp(k * q * z)
+                D1 = np.exp(-1j * k2i[2, :] * thickness)
+                Syd = D1[:, np.newaxis] * W1 * D[np.newaxis, :]
+                Sxd = D1[:, np.newaxis] * W2 * D[np.newaxis, :]
+                Uyd = D1[:, np.newaxis] * W3 * D[np.newaxis, :]
+                Uxd = D1[:, np.newaxis] * W4 * D[np.newaxis, :]
+
+                Mp[:, :, nlayer] = np.r_[Sx0, Sy0, -1j * Ux0, -1j * Uy0]
+                M[:, :, nlayer] = np.r_[Sxd, Syd, -1j * Uxd, -1j * Uyd]
+
+            Mtot = np.eye(4 * nood, dtype=complex)
             for nlayer in range(1, nlayers - 1):
-                Mtot = S.dot(S.dot(Mtot, Mp[:, :, nlayer]), inv(M[:, :, nlayer]))
+                Mtot = np.dot(np.dot(Mtot, Mp[:, :, nlayer]), inv(M[:, :, nlayer]))
 
-            BC_b = S.r_[b, S.zeros_like(b)]
-            BC_A1 = S.c_[-MR, S.dot(Mtot, MT)]
-            BC_A2 = S.asarray(
-                S.bmat(
+            BC_b = np.r_[b, np.zeros_like(b)]
+            BC_A1 = np.c_[-MR, np.dot(Mtot, MT)]
+            BC_A2 = np.asarray(
+                np.bmat(
                     [
                         [
-                            (c1[0] * I - c1[2] * S.dot(CRO_1, ARO)),
-                            (c1[1] * I - c1[2] * S.dot(CRO_1, BRO)),
+                            (c1[0] * I - c1[2] * np.dot(CRO_1, ARO)),
+                            (c1[1] * I - c1[2] * np.dot(CRO_1, BRO)),
                             ZERO,
                             ZERO,
                             ZERO,
@@ -769,8 +769,8 @@ class AnisotropicRCWA(RCWA):
                         [
                             ZERO,
                             ZERO,
-                            (DRE - S.dot(S.dot(FRE, CRE_1), ARE)),
-                            (ERE - S.dot(S.dot(FRE, CRE_1), BRE)),
+                            (DRE - np.dot(np.dot(FRE, CRE_1), ARE)),
+                            (ERE - np.dot(np.dot(FRE, CRE_1), BRE)),
                             ZERO,
                             ZERO,
                             ZERO,
@@ -781,8 +781,8 @@ class AnisotropicRCWA(RCWA):
                             ZERO,
                             ZERO,
                             ZERO,
-                            (c3[0] * I - c3[2] * S.dot(CTO_1, ATO)),
-                            (c3[1] * I - c3[2] * S.dot(CTO_1, BTO)),
+                            (c3[0] * I - c3[2] * np.dot(CTO_1, ATO)),
+                            (c3[1] * I - c3[2] * np.dot(CTO_1, BTO)),
                             ZERO,
                             ZERO,
                         ],
@@ -793,52 +793,52 @@ class AnisotropicRCWA(RCWA):
                             ZERO,
                             ZERO,
                             ZERO,
-                            (DTE - S.dot(S.dot(FTE, CTE_1), ATE)),
-                            (ETE - S.dot(S.dot(FTE, CTE_1), BTE)),
+                            (DTE - np.dot(np.dot(FTE, CTE_1), ATE)),
+                            (ETE - np.dot(np.dot(FTE, CTE_1), BTE)),
                         ],
                     ]
                 )
             )
 
-            BC_A = S.r_[BC_A1, BC_A2]
+            BC_A = np.r_[BC_A1, BC_A2]
 
             x = linsolve(BC_A, BC_b)
 
-            ROx, ROy, REx, REy, TOx, TOy, TEx, TEy = S.split(x, 8)
+            ROx, ROy, REx, REy, TOx, TOy, TEx, TEy = np.split(x, 8)
 
-            ROz = -S.dot(CRO_1, (S.dot(ARO, ROx) + S.dot(BRO, ROy)))
-            REz = -S.dot(CRE_1, (S.dot(ARE, REx) + S.dot(BRE, REy)))
-            TOz = -S.dot(CTO_1, (S.dot(ATO, TOx) + S.dot(BTO, TOy)))
-            TEz = -S.dot(CTE_1, (S.dot(ATE, TEx) + S.dot(BTE, TEy)))
+            ROz = -np.dot(CRO_1, (np.dot(ARO, ROx) + np.dot(BRO, ROy)))
+            REz = -np.dot(CRE_1, (np.dot(ARE, REx) + np.dot(BRE, REy)))
+            TOz = -np.dot(CTO_1, (np.dot(ATO, TOx) + np.dot(BTO, TOy)))
+            TEz = -np.dot(CTE_1, (np.dot(ATE, TEx) + np.dot(BTE, TEy)))
 
-            denom = (k1[2] - S.dot(u, k1) * u[2]).real
+            denom = (k1[2] - np.dot(u, k1) * u[2]).real
             DEO1[:, iwl] = (
                 -(
-                    (S.absolute(ROx) ** 2 + S.absolute(ROy) ** 2 + S.absolute(ROz) ** 2)
-                    * S.conj(kO1i[2, :])
+                    (np.absolute(ROx) ** 2 + np.absolute(ROy) ** 2 + np.absolute(ROz) ** 2)
+                    * np.conj(kO1i[2, :])
                     - (ROx * kO1i[0, :] + ROy * kO1i[1, :] + ROz * kO1i[2, :])
-                    * S.conj(ROz)
+                    * np.conj(ROz)
                 ).real
                 / denom
             )
             DEE1[:, iwl] = (
                 -(
-                    (S.absolute(REx) ** 2 + S.absolute(REy) ** 2 + S.absolute(REz) ** 2)
-                    * S.conj(kE1i[2, :])
+                    (np.absolute(REx) ** 2 + np.absolute(REy) ** 2 + np.absolute(REz) ** 2)
+                    * np.conj(kE1i[2, :])
                     - (REx * kE1i[0, :] + REy * kE1i[1, :] + REz * kE1i[2, :])
-                    * S.conj(REz)
+                    * np.conj(REz)
                 ).real
                 / denom
             )
             DEO3[:, iwl] = (
-                (S.absolute(TOx) ** 2 + S.absolute(TOy) ** 2 + S.absolute(TOz) ** 2)
-                * S.conj(kO3i[2, :])
-                - (TOx * kO3i[0, :] + TOy * kO3i[1, :] + TOz * kO3i[2, :]) * S.conj(TOz)
+                (np.absolute(TOx) ** 2 + np.absolute(TOy) ** 2 + np.absolute(TOz) ** 2)
+                * np.conj(kO3i[2, :])
+                - (TOx * kO3i[0, :] + TOy * kO3i[1, :] + TOz * kO3i[2, :]) * np.conj(TOz)
             ).real / denom
             DEE3[:, iwl] = (
-                (S.absolute(TEx) ** 2 + S.absolute(TEy) ** 2 + S.absolute(TEz) ** 2)
-                * S.conj(kE3i[2, :])
-                - (TEx * kE3i[0, :] + TEy * kE3i[1, :] + TEz * kE3i[2, :]) * S.conj(TEz)
+                (np.absolute(TEx) ** 2 + np.absolute(TEy) ** 2 + np.absolute(TEz) ** 2)
+                * np.conj(kE3i[2, :])
+                - (TEx * kE3i[0, :] + TEy * kE3i[1, :] + TEz * kE3i[2, :]) * np.conj(TEz)
             ).real / denom
 
         # save the results

EMpy/devices.py

@@ -619,8 +619,8 @@ class MZ(Device):
         self.coupler2.sanity_check()
         self.line.sanity_check()
         if not (
-            numpy.alltrue(self.coupler1.wl == self.line.wl)
-            and numpy.alltrue(self.coupler1.wl == self.coupler2.wl)
+            numpy.all(self.coupler1.wl == self.line.wl)
+            and numpy.all(self.coupler1.wl == self.coupler2.wl)
         ):
             raise ValueError("incompatible wl")
 
@@ -808,9 +808,9 @@ class SRR(Device):
         self.line1.sanity_check()
         self.line2.sanity_check()
         if not (
-            numpy.alltrue(self.coupler1.wl == self.coupler2.wl)
-            and numpy.alltrue(self.coupler1.wl == self.line1.wl)
-            and numpy.alltrue(self.coupler1.wl == self.line2.wl)
+            numpy.all(self.coupler1.wl == self.coupler2.wl)
+            and numpy.all(self.coupler1.wl == self.line1.wl)
+            and numpy.all(self.coupler1.wl == self.line2.wl)
         ):
             raise ValueError("incompatible wl")
 
@@ -926,7 +926,7 @@ class NRR(Device):
 
         for K in self.Ks:
             K.sanity_check()
-            if not (numpy.alltrue(self.wl == K.wl)):
+            if not (numpy.all(self.wl == K.wl)):
                 raise ValueError("incompatible wl")
         if not (len(self.Ks) - 1 == len(self.neffs) == len(self.l1s) == len(self.l2s)):
             raise ValueError("number of couplers and number of rings do not match.")

EMpy/transfer_matrix.py

@@ -9,7 +9,7 @@ anisotropic one.
 """
 __author__ = "Lorenzo Bolla"
 
-import scipy as S
+import numpy as np
 from scipy.linalg import inv
 from EMpy.utils import snell, norm
 from EMpy.constants import c, mu0
@@ -60,27 +60,27 @@ class IsotropicTransferMatrix(TransferMatrix):
         transmitted on s and p polarizations.
         """
 
-        self.wls = S.asarray(wls)
+        self.wls = np.asarray(wls)
 
         multilayer = self.multilayer
         theta_inc = self.theta_inc
 
         nlayers = len(multilayer)
-        d = S.array([l.thickness for l in multilayer]).ravel()
+        d = np.array([l.thickness for l in multilayer]).ravel()
 
-        Rs = S.zeros_like(self.wls, dtype=float)
-        Ts = S.zeros_like(self.wls, dtype=float)
-        Rp = S.zeros_like(self.wls, dtype=float)
-        Tp = S.zeros_like(self.wls, dtype=float)
+        Rs = np.zeros_like(self.wls, dtype=float)
+        Ts = np.zeros_like(self.wls, dtype=float)
+        Rp = np.zeros_like(self.wls, dtype=float)
+        Tp = np.zeros_like(self.wls, dtype=float)
 
-        Dp = S.zeros((2, 2), dtype=complex)
-        Ds = S.zeros((2, 2), dtype=complex)
-        P = S.zeros((2, 2), dtype=complex)
-        Ms = S.zeros((2, 2), dtype=complex)
-        Mp = S.zeros((2, 2), dtype=complex)
-        k = S.zeros((nlayers, 2), dtype=complex)
+        Dp = np.zeros((2, 2), dtype=complex)
+        Ds = np.zeros((2, 2), dtype=complex)
+        P = np.zeros((2, 2), dtype=complex)
+        Ms = np.zeros((2, 2), dtype=complex)
+        Mp = np.zeros((2, 2), dtype=complex)
+        k = np.zeros((nlayers, 2), dtype=complex)
 
-        ntot = S.zeros((self.wls.size, nlayers), dtype=complex)
+        ntot = np.zeros((self.wls.size, nlayers), dtype=complex)
         for i, l in enumerate(multilayer):
             #            ntot[:,i] = l.mat.n(self.wls,l.mat.T0)
             ntot[:, i] = l.mat.n(self.wls, l.mat.toc.T0)
@@ -89,26 +89,26 @@ class IsotropicTransferMatrix(TransferMatrix):
             n = ntot[iwl, :]
             theta = snell(theta_inc, n)
 
-            k[:, 0] = 2 * S.pi * n / wl * S.cos(theta)
-            k[:, 1] = 2 * S.pi * n / wl * S.sin(theta)
+            k[:, 0] = 2 * np.pi * n / wl * np.cos(theta)
+            k[:, 1] = 2 * np.pi * n / wl * np.sin(theta)
 
-            Ds = [[1.0, 1.0], [n[0] * S.cos(theta[0]), -n[0] * S.cos(theta[0])]]
-            Dp = [[S.cos(theta[0]), S.cos(theta[0])], [n[0], -n[0]]]
+            Ds = [[1.0, 1.0], [n[0] * np.cos(theta[0]), -n[0] * np.cos(theta[0])]]
+            Dp = [[np.cos(theta[0]), np.cos(theta[0])], [n[0], -n[0]]]
             Ms = inv(Ds)
             Mp = inv(Dp)
 
             for nn, dd, tt, kk in zip(n[1:-1], d[1:-1], theta[1:-1], k[1:-1, 0]):
-                Ds = [[1.0, 1.0], [nn * S.cos(tt), -nn * S.cos(tt)]]
-                Dp = [[S.cos(tt), S.cos(tt)], [nn, -nn]]
+                Ds = [[1.0, 1.0], [nn * np.cos(tt), -nn * np.cos(tt)]]
+                Dp = [[np.cos(tt), np.cos(tt)], [nn, -nn]]
                 phi = kk * dd
-                P = [[S.exp(1j * phi), 0], [0, S.exp(-1j * phi)]]
-                Ms = S.dot(Ms, S.dot(Ds, S.dot(P, inv(Ds))))
-                Mp = S.dot(Mp, S.dot(Dp, S.dot(P, inv(Dp))))
+                P = [[np.exp(1j * phi), 0], [0, np.exp(-1j * phi)]]
+                Ms = np.dot(Ms, np.dot(Ds, np.dot(P, inv(Ds))))
+                Mp = np.dot(Mp, np.dot(Dp, np.dot(P, inv(Dp))))
 
-            Ds = [[1.0, 1.0], [n[-1] * S.cos(theta[-1]), -n[-1] * S.cos(theta[-1])]]
-            Dp = [[S.cos(theta[-1]), S.cos(theta[-1])], [n[-1], -n[-1]]]
-            Ms = S.dot(Ms, Ds)
-            Mp = S.dot(Mp, Dp)
+            Ds = [[1.0, 1.0], [n[-1] * np.cos(theta[-1]), -n[-1] * np.cos(theta[-1])]]
+            Dp = [[np.cos(theta[-1]), np.cos(theta[-1])], [n[-1], -n[-1]]]
+            Ms = np.dot(Ms, Ds)
+            Mp = np.dot(Mp, Dp)
 
             rs = Ms[1, 0] / Ms[0, 0]
             ts = 1.0 / Ms[0, 0]
@@ -116,15 +116,15 @@ class IsotropicTransferMatrix(TransferMatrix):
             rp = Mp[1, 0] / Mp[0, 0]
             tp = 1.0 / Mp[0, 0]
 
-            Rs[iwl] = S.absolute(rs) ** 2
+            Rs[iwl] = np.absolute(rs) ** 2
             Ts[iwl] = (
-                S.absolute((n[-1] * S.cos(theta[-1])) / (n[0] * S.cos(theta[0])))
-                * S.absolute(ts) ** 2
+                np.absolute((n[-1] * np.cos(theta[-1])) / (n[0] * np.cos(theta[0])))
+                * np.absolute(ts) ** 2
             )
-            Rp[iwl] = S.absolute(rp) ** 2
+            Rp[iwl] = np.absolute(rp) ** 2
             Tp[iwl] = (
-                S.absolute((n[-1] * S.cos(theta[-1])) / (n[0] * S.cos(theta[0])))
-                * S.absolute(tp) ** 2
+                np.absolute((n[-1] * np.cos(theta[-1])) / (n[0] * np.cos(theta[0])))
+                * np.absolute(tp) ** 2
             )
 
         self.Rs = Rs
@@ -176,7 +176,7 @@ class AnisotropicTransferMatrix(TransferMatrix):
         self.R, self.T = power reflected and transmitted.
         """
 
-        self.wls = S.asarray(wls)
+        self.wls = np.asarray(wls)
 
         multilayer = self.multilayer
         theta_inc_x = self.theta_inc_x
@@ -190,10 +190,10 @@ class AnisotropicTransferMatrix(TransferMatrix):
             gamma_i, i = 1,2,3,4 that satisfy the boundary conditions.
             """
 
-            omega = 2.0 * S.pi * c / wl
+            omega = 2.0 * np.pi * c / wl
             K = omega**2 * mu0 * epsilon
 
-            k0 = 2.0 * S.pi / wl
+            k0 = 2.0 * np.pi / wl
             K /= k0**2
             alpha /= k0
             beta /= k0
@@ -270,17 +270,17 @@ class AnisotropicTransferMatrix(TransferMatrix):
                 - K[2, 0] * K[0, 2] * K[1, 1],
             ]
 
-            gamma = S.roots(coeff)
-            tmp = S.sort_complex(gamma)
+            gamma = np.roots(coeff)
+            tmp = np.sort_complex(gamma)
             gamma = tmp[[3, 0, 2, 1]]  # convention
 
             k = (
                 k0
-                * S.array(
-                    [alpha * S.ones(gamma.shape), beta * S.ones(gamma.shape), gamma]
+                * np.array(
+                    [alpha * np.ones(gamma.shape), beta * np.ones(gamma.shape), gamma]
                 ).T
             )
-            v = S.zeros((4, 3), dtype=complex)
+            v = np.zeros((4, 3), dtype=complex)
 
             for i, g in enumerate(gamma):
                 # H = K + [
@@ -301,41 +301,41 @@ class AnisotropicTransferMatrix(TransferMatrix):
             p3 /= norm(p3)
             p4 = v[1, :]
             p4 /= norm(p4)
-            p1 = S.cross(p3, k[0, :])
+            p1 = np.cross(p3, k[0, :])
             p1 /= norm(p1)
-            p2 = S.cross(p4, k[1, :])
+            p2 = np.cross(p4, k[1, :])
             p2 /= norm(p2)
 
-            p = S.array([p1, p2, p3, p4])
-            q = wl / (2.0 * S.pi * mu0 * c) * S.cross(k, p)
+            p = np.array([p1, p2, p3, p4])
+            q = wl / (2.0 * np.pi * mu0 * c) * np.cross(k, p)
 
             return k, p, q
 
         nlayers = len(multilayer)
-        d = S.asarray([l.thickness for l in multilayer])
+        d = np.asarray([l.thickness for l in multilayer])
 
         # R and T are real, because they are powers
         # r and t are complex!
-        R = S.zeros((2, 2, self.wls.size))
-        T = S.zeros((2, 2, self.wls.size))
+        R = np.zeros((2, 2, self.wls.size))
+        T = np.zeros((2, 2, self.wls.size))
 
-        epstot = S.zeros((3, 3, self.wls.size, nlayers), dtype=complex)
+        epstot = np.zeros((3, 3, self.wls.size, nlayers), dtype=complex)
         for i, l in enumerate(multilayer):
             epstot[:, :, :, i] = l.mat.epsilonTensor(self.wls)
 
         for iwl, wl in enumerate(self.wls):
             epsilon = epstot[:, :, iwl, :]
 
-            kx = 2 * S.pi / wl * S.sin(theta_inc_x)
-            ky = 2 * S.pi / wl * S.sin(theta_inc_y)
-            x = S.array([1, 0, 0], dtype=float)
-            y = S.array([0, 1, 0], dtype=float)
-            # z = S.array([0, 0, 1], dtype=float)
-            k = S.zeros((4, 3, nlayers), dtype=complex)
-            p = S.zeros((4, 3, nlayers), dtype=complex)
-            q = S.zeros((4, 3, nlayers), dtype=complex)
-            D = S.zeros((4, 4, nlayers), dtype=complex)
-            P = S.zeros((4, 4, nlayers), dtype=complex)
+            kx = 2 * np.pi / wl * np.sin(theta_inc_x)
+            ky = 2 * np.pi / wl * np.sin(theta_inc_y)
+            x = np.array([1, 0, 0], dtype=float)
+            y = np.array([0, 1, 0], dtype=float)
+            # z = np.array([0, 0, 1], dtype=float)
+            k = np.zeros((4, 3, nlayers), dtype=complex)
+            p = np.zeros((4, 3, nlayers), dtype=complex)
+            q = np.zeros((4, 3, nlayers), dtype=complex)
+            D = np.zeros((4, 4, nlayers), dtype=complex)
+            P = np.zeros((4, 4, nlayers), dtype=complex)
 
             for i in range(nlayers):
                 k[:, :, i], p[:, :, i], q[:, :, i] = find_roots(
@@ -343,45 +343,45 @@ class AnisotropicTransferMatrix(TransferMatrix):
                 )
                 D[:, :, i] = [
                     [
-                        S.dot(x, p[0, :, i]),
-                        S.dot(x, p[1, :, i]),
-                        S.dot(x, p[2, :, i]),
-                        S.dot(x, p[3, :, i]),
+                        np.dot(x, p[0, :, i]),
+                        np.dot(x, p[1, :, i]),
+                        np.dot(x, p[2, :, i]),
+                        np.dot(x, p[3, :, i]),
                     ],
                     [
-                        S.dot(y, q[0, :, i]),
-                        S.dot(y, q[1, :, i]),
-                        S.dot(y, q[2, :, i]),
-                        S.dot(y, q[3, :, i]),
+                        np.dot(y, q[0, :, i]),
+                        np.dot(y, q[1, :, i]),
+                        np.dot(y, q[2, :, i]),
+                        np.dot(y, q[3, :, i]),
                     ],
                     [
-                        S.dot(y, p[0, :, i]),
-                        S.dot(y, p[1, :, i]),
-                        S.dot(y, p[2, :, i]),
-                        S.dot(y, p[3, :, i]),
+                        np.dot(y, p[0, :, i]),
+                        np.dot(y, p[1, :, i]),
+                        np.dot(y, p[2, :, i]),
+                        np.dot(y, p[3, :, i]),
                     ],
                     [
-                        S.dot(x, q[0, :, i]),
-                        S.dot(x, q[1, :, i]),
-                        S.dot(x, q[2, :, i]),
-                        S.dot(x, q[3, :, i]),
+                        np.dot(x, q[0, :, i]),
+                        np.dot(x, q[1, :, i]),
+                        np.dot(x, q[2, :, i]),
+                        np.dot(x, q[3, :, i]),
                     ],
                 ]
 
             for i in range(1, nlayers - 1):
-                P[:, :, i] = S.diag(S.exp(1j * k[:, 2, i] * d[i]))
+                P[:, :, i] = np.diag(np.exp(1j * k[:, 2, i] * d[i]))
 
             M = inv(D[:, :, 0])
             for i in range(1, nlayers - 1):
-                M = S.dot(M, S.dot(D[:, :, i], S.dot(P[:, :, i], inv(D[:, :, i]))))
-            M = S.dot(M, D[:, :, -1])
+                M = np.dot(M, np.dot(D[:, :, i], np.dot(P[:, :, i], inv(D[:, :, i]))))
+            M = np.dot(M, D[:, :, -1])
 
             deltaM = M[0, 0] * M[2, 2] - M[0, 2] * M[2, 0]
 
             # reflectance matrix (from yeh_electromagnetic)
             # r = [rss rsp; rps rpp]
             r = (
-                S.array(
+                np.array(
                     [
                         [
                             M[1, 0] * M[2, 2] - M[1, 2] * M[2, 0],
@@ -399,13 +399,13 @@ class AnisotropicTransferMatrix(TransferMatrix):
 
             # transmittance matrix (from yeh_electromagnetic)
             # t = [tss tsp; tps tpp]
-            t = S.array([[M[2, 2], -M[2, 0]], [-M[0, 2], M[0, 0]]]) / deltaM
+            t = np.array([[M[2, 2], -M[2, 0]], [-M[0, 2], M[0, 0]]]) / deltaM
 
             # P_t/P_inc = |E_t|**2/|E_inc|**2 . k_t_z/k_inc_z
-            T[:, :, iwl] = (S.absolute(t) ** 2 * k[0, 2, -1] / k[0, 2, 0]).real
+            T[:, :, iwl] = (np.absolute(t) ** 2 * k[0, 2, -1] / k[0, 2, 0]).real
 
             # P_r/P_inc = |E_r|**2/|E_inc|**2
-            R[:, :, iwl] = S.absolute(r) ** 2
+            R[:, :, iwl] = np.absolute(r) ** 2
 
         self.R = R
         self.T = T

EMpy/version.py

@@ -1 +1 @@
-version = "2.1.5"
+version = "2.2.1"

{ElectroMagneticPython-2.1.5.dist-info → ElectroMagneticPython-2.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ElectroMagneticPython
-Version: 2.1.5
+Version: 2.2.1
 Summary: EMpy - ElectroMagnetic Python
 Home-page: http://lbolla.github.io/EMpy/
 Download-URL: https://github.com/lbolla/EMpy
@@ -20,9 +20,9 @@ Classifier: Operating System :: OS Independent
 Classifier: Topic :: Scientific/Engineering :: Physics
 Provides: EMpy
 License-File: LICENSE
-Requires-Dist: numpy >=1.18
-Requires-Dist: scipy >=1.7
-Requires-Dist: matplotlib >=3.1
+Requires-Dist: numpy>=1.18
+Requires-Dist: scipy>=1.7
+Requires-Dist: matplotlib>=3.1
 
 EMpy - ElectroMagnetic Python
 *****************************
@@ -57,25 +57,39 @@ Optionally, install `bvp`:
 Development
 ===========
 
-First, download the source code from https://github.com/lbolla/EMpy. Then, from inside a `virtualenv`, install with:
+First, download the source code from https://github.com/lbolla/EMpy.
+
+Create a virtualenv with, e.g:
+
+.. code-block:: bash
+
+  $> make venv
+
+Then, from inside a `virtualenv`, install dev environment with:
 
 .. code-block:: bash
 
-    $> pip install -r requirements_dev.txt
-    $> python setup.py develop
+  $> make develop
 
 Run tests with:
 
 .. code-block:: bash
 
-    $> python setup.py test
+  $> make test
+
+Upgrade dependencies with:
+
+.. code-block:: bash
+
+  $> make requirements-upgrade
+  $> make requirements-sync
+
 
 Release process
 ===============
 
 1. Edit CHANGES
-2. `bumpversion major|minor|patch`
-3. `git push && git push --tags`
+2. `make release PART=major|minor|patch`
 
 Citation
 ========

{ElectroMagneticPython-2.1.5.dist-info → ElectroMagneticPython-2.2.1.dist-info}/RECORD

@@ -1,12 +1,12 @@
-EMpy/RCWA.py,sha256=2_OUsmna-kKt9Gvxnv-1ezT0JTDFJdQhmyuyoPOmpDc,31905
+EMpy/RCWA.py,sha256=8wro-KNtnWTrYN2NlV8OGGrJGnd9DDwkK3KlVJ4TU8A,32249
 EMpy/__init__.py,sha256=PSH3TiCVO9LSBCbQIM9uyXVK0TKn0S7ngWC5dGYuaPs,1003
 EMpy/constants.py,sha256=x1N8eRXQW_gdr1557n7tvUXiM4RW_Fc_EydLd5AUC1o,723
-EMpy/devices.py,sha256=m0nNWcNF-REnV3GrxdLxIEiFpsOfyKUfF5iiTRRN0jY,37919
+EMpy/devices.py,sha256=OQLxSAKXafBgrbWd-WNcVTOkxdBhZ-UXsW7ukoIwaYA,37895
 EMpy/materials.py,sha256=r9SaTf4u3JBszGpVB-62VLhQp6SoQb78AsmrxLoTMkc,10687
 EMpy/scattering.py,sha256=1rY8_TI0kzTLYwpFSSXndaO9FzDzVPRVow55vzIDQiM,7339
-EMpy/transfer_matrix.py,sha256=c_jb7_-HjKf8y08ny7Y54ZVF4dVwdKRL0HJXUzSiwvE,14476
+EMpy/transfer_matrix.py,sha256=Z3EK4MYsV5sUGTyXWieXVLg-18Wctm_3jR5LNS04r1k,14582
 EMpy/utils.py,sha256=o-XBTXtOVOff-us4Br2zP0u2PLJFqdsq28QxvoEpZrc,42008
-EMpy/version.py,sha256=WXd58KGUT_d6EG79bOIYEuAyc75oXA0l7wQcoFl30X8,18
+EMpy/version.py,sha256=d4pHXdSvDQjlx5mLFhqVvjzHBiA0Fow5fJ7IpFZUFeI,18
 EMpy/modesolvers/FD.py,sha256=DIZGfAfGTPJfD83VsTvIO0gcMjvw1dci23F9PK3okow,80097
 EMpy/modesolvers/FMM.py,sha256=FaIvg1aOsdM8pxdVNCBiqr4eTM-6oqPZPTxLanG3tXo,78366
 EMpy/modesolvers/__init__.py,sha256=bAFq4_6rPDV4RgFx6rct9ywRDLCt_pGhiVtgC6L9A_Y,221
@@ -15,8 +15,8 @@ EMpy/modesolvers/interface.py,sha256=spMy30TFedYXJHcoV3yUdGkycGt5cplJUCeZui6a5MY
 tests/__init__.py,sha256=XNMyfmlHhqih2xHEklXlmQ8GVUAdiiWrkT3trIOMpRQ,29
 tests/materials_test.py,sha256=v_UlUvPkiKqkkPNFywbTGTTO4eNnuk-itZPr5YIEUWw,1875
 tests/utils_test.py,sha256=Voe_Ph9LDDf47Vnt04hHLXoTPFGYXeRqzQDVkvPUVy8,597
-ElectroMagneticPython-2.1.5.dist-info/LICENSE,sha256=NlQFsrkwMvQ2aD8531IDm6Rk01KzlI42HVzK5M1Hpw8,1065
-ElectroMagneticPython-2.1.5.dist-info/METADATA,sha256=afskqb8wzLXUgJMlRb8ON8PVD5YEpGVZuacNbwNTEOk,2377
-ElectroMagneticPython-2.1.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-ElectroMagneticPython-2.1.5.dist-info/top_level.txt,sha256=JCRI2zyREl3Lql3CyAFrqXFLGqMV0LqdsqQisk907AI,11
-ElectroMagneticPython-2.1.5.dist-info/RECORD,,
+ElectroMagneticPython-2.2.1.dist-info/LICENSE,sha256=NlQFsrkwMvQ2aD8531IDm6Rk01KzlI42HVzK5M1Hpw8,1065
+ElectroMagneticPython-2.2.1.dist-info/METADATA,sha256=Bk8GnVNqdRF6iuFDVIRE_5XA-YqsEG0I8hBV4jVqgE8,2476
+ElectroMagneticPython-2.2.1.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
+ElectroMagneticPython-2.2.1.dist-info/top_level.txt,sha256=JCRI2zyREl3Lql3CyAFrqXFLGqMV0LqdsqQisk907AI,11
+ElectroMagneticPython-2.2.1.dist-info/RECORD,,

{ElectroMagneticPython-2.1.5.dist-info → ElectroMagneticPython-2.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (75.7.0)
 Root-Is-Purelib: true
 Tag: py3-none-any