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

EMpy/RCWA.py

@@ -12,9 +12,10 @@ for every diffraction order and layer thickness, and an anisotropic
 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 +42,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 +66,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,19 +84,18 @@ 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
 
 
 class RCWA:
-
     """Class to handle the RCWA solvers.
 
     NOTE
@@ -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,15 +160,14 @@ 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]
 
 
 class IsotropicRCWA(RCWA):
-
     """Isotropic RCWA solver."""
 
     def solve(self, wls):
@@ -192,7 +191,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 +202,36 @@ 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 +247,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 +296,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 +310,61 @@ 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 +374,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
@@ -448,7 +453,6 @@ class IsotropicRCWA(RCWA):
 
 
 class AnisotropicRCWA(RCWA):
-
     """Anisotropic RCWA solver."""
 
     def solve(self, wls):
@@ -462,7 +466,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 +477,45 @@ 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 +526,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 +558,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 +600,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 +608,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 +631,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 +661,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 +720,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 +737,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 +779,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 +791,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 +803,62 @@ 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