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

EMpy/RCWA.py

@@ -12,6 +12,7 @@ for every diffraction order and layer thickness, and an anisotropic
 one, only stable for low diffraction orders and thin layers.
 
 """
+
 __author__ = "Lorenzo Bolla"
 
 import numpy as np
@@ -95,7 +96,6 @@ def dispersion_relation_extraordinary(kx, ky, k, nO, nE, c):
 
 
 class RCWA:
-
     """Class to handle the RCWA solvers.
 
     NOTE
@@ -168,7 +168,6 @@ class RCWA:
 
 
 class IsotropicRCWA(RCWA):
-
     """Isotropic RCWA solver."""
 
     def solve(self, wls):
@@ -215,7 +214,11 @@ class IsotropicRCWA(RCWA):
         DE3 = np.zeros_like(DE1)
 
         dirk1 = np.array(
-            [np.sin(alpha) * np.cos(delta), np.sin(alpha) * np.sin(delta), np.cos(alpha)]
+            [
+                np.sin(alpha) * np.cos(delta),
+                np.sin(alpha) * np.sin(delta),
+                np.cos(alpha),
+            ]
         )
 
         # usefull matrices
@@ -323,7 +326,9 @@ class IsotropicRCWA(RCWA):
                     # 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[:, np.newaxis] / k * linsolve(E, kx[:, np.newaxis] / k * E11)
+                        + kx[:, np.newaxis]
+                        / k
+                        * linsolve(E, kx[:, np.newaxis] / k * E11)
                         - E11
                     )
 
@@ -448,7 +453,6 @@ class IsotropicRCWA(RCWA):
 
 
 class AnisotropicRCWA(RCWA):
-
     """Anisotropic RCWA solver."""
 
     def solve(self, wls):
@@ -487,14 +491,20 @@ class AnisotropicRCWA(RCWA):
         # grating on the xy plane
         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)]
+            [
+                np.sin(alpha) * np.cos(delta),
+                np.sin(alpha) * np.sin(delta),
+                np.cos(alpha),
+            ]
         )
 
         # D polarization vector
         u = np.array(
             [
-                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.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),
             ]
         )
@@ -814,7 +824,11 @@ class AnisotropicRCWA(RCWA):
             denom = (k1[2] - np.dot(u, k1) * u[2]).real
             DEO1[:, iwl] = (
                 -(
-                    (np.absolute(ROx) ** 2 + np.absolute(ROy) ** 2 + np.absolute(ROz) ** 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, :])
                     * np.conj(ROz)
@@ -823,7 +837,11 @@ class AnisotropicRCWA(RCWA):
             )
             DEE1[:, iwl] = (
                 -(
-                    (np.absolute(REx) ** 2 + np.absolute(REy) ** 2 + np.absolute(REz) ** 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, :])
                     * np.conj(REz)
@@ -833,12 +851,14 @@ class AnisotropicRCWA(RCWA):
             DEO3[:, iwl] = (
                 (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)
+                - (TOx * kO3i[0, :] + TOy * kO3i[1, :] + TOz * kO3i[2, :])
+                * np.conj(TOz)
             ).real / denom
             DEE3[:, iwl] = (
                 (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)
+                - (TEx * kE3i[0, :] + TEy * kE3i[1, :] + TEz * kE3i[2, :])
+                * np.conj(TEz)
             ).real / denom
 
         # save the results

EMpy/__init__.py

@@ -10,6 +10,7 @@ The package contains some useful routines to study electromagnetic problems with
 It is based on U{numpy<http://numpy.scipy.org>} and U{scipy<http://www.scipy.org>}.
 
 """
+
 __all__ = [
     "constants",
     "devices",
@@ -30,6 +31,13 @@ from . import RCWA
 from . import scattering
 from . import transfer_matrix
 from . import utils
-from .version import version
 
-__version__ = version
+try:
+    from ._version import version as __version__
+except ImportError:
+    # Fallback for development environments or edge cases
+    try:
+        from importlib.metadata import version, PackageNotFoundError
+        __version__ = version("electromagneticpython")
+    except PackageNotFoundError:
+        __version__ = "0.0.0.dev0"

EMpy/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '2.2.4'
+__version_tuple__ = version_tuple = (2, 2, 4)
+
+__commit_id__ = commit_id = 'gd8c276251'

EMpy/constants.py

@@ -1,5 +1,3 @@
-# pylint: disable=C0301
-
 """Useful constants.
 
 Constants used in mathematics and electromagnetism.

EMpy/devices.py

@@ -1,5 +1,3 @@
-# pylint: disable=C0302,W0622,W1001,R0902,R0903,W0201,R0913,R0914,C0325,W0221
-
 """Set of objects and functions to describe the behaviour of some
 widely known devices and build new ones.
 
@@ -31,6 +29,7 @@ devices, new ones can be studied.
     isnumber=8367>}
 
 """
+
 __author__ = "Lorenzo Bolla"
 
 import numpy
@@ -39,7 +38,6 @@ from functools import reduce
 
 
 class DeviceMatrix:
-
     """Device Matrix.
 
     Base class for TransferMatrix and ChainMatrix.
@@ -62,7 +60,7 @@ class DeviceMatrix:
         return self.__data
 
     def setdata(self, value):
-        self.__data = numpy.asmatrix(value)
+        self.__data = numpy.array(value)
 
     __data = None
     data = property(fget=getdata, fset=setdata, doc="data")
@@ -83,7 +81,6 @@ class DeviceMatrix:
 
 
 class TransferMatrix(DeviceMatrix):
-
     """Transfer Matrix.
 
     Notation::
@@ -138,6 +135,7 @@ class TransferMatrix(DeviceMatrix):
 
         Notation::
 
+
             b12 = H1 a12 and d12 = H2 c12, but b12 == c12,
 
         therefore::
@@ -154,11 +152,10 @@ class TransferMatrix(DeviceMatrix):
 
         """
 
-        return TransferMatrix(M.to_transfer().data * self.data)
+        return TransferMatrix(M.to_transfer().data @ self.data)
 
 
 class ChainMatrix(DeviceMatrix):
-
     """Chain Matrix.
 
     Notation::
@@ -229,7 +226,7 @@ class ChainMatrix(DeviceMatrix):
 
         """
 
-        return ChainMatrix(self.data * M.to_chain().data)
+        return ChainMatrix(self.data @ M.to_chain().data)
 
 
 def composeTM(A, B):
@@ -289,7 +286,6 @@ def composeCMlist(CMlist):
 
 
 class Device:
-
     """Generic device.
 
     Notes
@@ -307,7 +303,6 @@ class Device:
 
 
 class Coupler(Device):
-
     """Coupler.
 
     Examples
@@ -436,7 +431,6 @@ class Coupler(Device):
 
 
 class Line(Device):
-
     """Line.
 
     Notes
@@ -570,7 +564,6 @@ class Line(Device):
 
 
 class MZ(Device):
-
     """Mach-Zehnder Interferometer (MZI).
 
     A MZI is made of two L{Coupler}s connected by a L{Line}.
@@ -679,7 +672,6 @@ class MZ(Device):
 
 
 class APRR(Device):
-
     """All-Pass Ring Resonator.
 
     An APRR is made of a L{Coupler} with a feedback line (the ring).
@@ -746,7 +738,6 @@ class APRR(Device):
 
 
 class SRR(Device):
-
     """Single Ring Resonator.
 
     A SRR is made of the parallel of a L{Coupler} a feedback line (the
@@ -872,7 +863,6 @@ class SRR(Device):
 
 
 class NRR(Device):
-
     """N-Rings Resonator.
 
     A NRR is made of the parallel of two lines connected by N ring resonators.
@@ -996,7 +986,6 @@ class NRR(Device):
 
 
 class T_TCRR(Device):
-
     """Tunable Triple-Coupled Ring Resonator.
 
     A T_TCRR is made of a L{MZ}, with a feedback line.
@@ -1056,8 +1045,7 @@ class T_TCRR(Device):
         t4 = numpy.exp(-1j * beta * l[3])
 
         denom = (
-            q**3 * Kbar[2] * t3 * t4 * (Kbar[0] * Kbar[1] * t1 - K[0] * K[1] * t2)
-            - 1.0
+            q**3 * Kbar[2] * t3 * t4 * (Kbar[0] * Kbar[1] * t1 - K[0] * K[1] * t2) - 1.0
         )
         self.DROP = (
             q**3 * K[2] * t3 * (K[0] * Kbar[1] * t1 + Kbar[0] * K[1] * t2) / denom
@@ -1071,7 +1059,6 @@ class T_TCRR(Device):
 
 
 class T_CRTCRR(Device):
-
     """Tunable Coupled Ring Triple-Coupled Ring Resonator.
 
     NOTE
@@ -1129,16 +1116,7 @@ class T_CRTCRR(Device):
             - q**2 * Kbar[1] * t2**2 * (Kbar[2] - q**3 * t1**2 * N1)
         )
         self.DROP = (
-            1j
-            * q**4
-            * K[0]
-            * K[1]
-            * K[2]
-            * Kbar[0]
-            * t1**1.5
-            * t2
-            * (1 + t31)
-            / denom
+            1j * q**4 * K[0] * K[1] * K[2] * Kbar[0] * t1**1.5 * t2 * (1 + t31) / denom
         )
         self.THRU = (
             q**2
@@ -1156,7 +1134,6 @@ class T_CRTCRR(Device):
 
 
 class T_CTCRR(Device):
-
     """Tunable Coupled Triple Coupled Ring Resonator.
 
     NOTE
@@ -1363,7 +1340,6 @@ class SWG(Device):
 
 
 class Etalon(Device):
-
     """Etalon.
 
     @ivar R: Reflectivity.
@@ -1402,7 +1378,7 @@ class Etalon(Device):
         self.wl0 = numpy.mean(wls)
         self.FSRwl = self.wl0**2 / (2 * n * l * numpy.cos(self.theta) + self.wl0)
 
-        (self.f0, self.FSR) = EMpy.utils.wl2f(self.wl0, self.FSRwl)
+        self.f0, self.FSR = EMpy.utils.wl2f(self.wl0, self.FSRwl)
 
         self.FINESSE = numpy.pi / (2 * numpy.arcsin(1.0 / numpy.sqrt(self.F)))
         # self.FINESSE = numpy.pi * numpy.sqrt(self.F) / 2.

EMpy/materials.py

@@ -1,10 +1,9 @@
-# pylint: disable=W0622,R0903,R0902,R0913,W0633
-
 """Functions and objects to manipulate materials.
 
 A material is an object with a refractive index function.
 
 """
+
 from functools import partial
 
 import numpy
@@ -15,7 +14,6 @@ __author__ = "Lorenzo Bolla"
 
 
 class Material:
-
     """Generic class to handle materials.
 
     This class is intended to be subclassed to obtain isotropic and
@@ -28,7 +26,6 @@ class Material:
 
 
 class RefractiveIndex:
-
     """Refractive Index.
 
     Unaware of temperature.
@@ -146,7 +143,6 @@ class RefractiveIndex:
 
 
 class ThermalOpticCoefficient:
-
     """Thermal Optic Coefficient."""
 
     def __init__(self, data=None, T0=300):
@@ -168,7 +164,6 @@ class ThermalOpticCoefficient:
 
 
 class IsotropicMaterial(Material):
-
     """Subclasses Material to describe isotropic materials.
 
     Frequency dispersion and thermic aware.
@@ -232,7 +227,6 @@ class EpsilonTensor:
 
 
 class AnisotropicMaterial(Material):
-
     """Subclass Material to describe anisotropic materials.
 
     No frequency dispersion nor thermic aware.
@@ -292,7 +286,6 @@ BK7 = IsotropicMaterial(
 
 
 class LiquidCrystal(Material):
-
     """Liquid Crystal.
 
     A liquid crystal is determined by it ordinary and extraordinary

EMpy/modesolvers/FD.py

@@ -1,7 +1,3 @@
-# pylint: disable=line-too-long,too-many-locals,too-many-statements,too-many-branches
-# pylint: disable=redefined-builtin,wildcard-import,unused-wildcard-import
-# pylint: disable=attribute-defined-outside-init,too-many-instance-attributes
-# pylint: disable=arguments-differ,too-many-arguments
 """Finite Difference Modesolver.
 
 @see: Fallahkhair, "Vector Finite Difference Modesolver for Anisotropic Dielectric Waveguides",
@@ -10,6 +6,8 @@
 @see: http://www.mathworks.com/matlabcentral/fileexchange/loadFile.do?objectId=12734&objectType=FILE
 
 """
+
+from matplotlib import pyplot as plt
 import numpy
 import scipy
 import scipy.optimize
@@ -19,7 +17,6 @@ from EMpy.modesolvers.interface import Mode, ModeSolver
 
 
 class SVFDModeSolver(ModeSolver):
-
     """
     This function calculates the modes of a dielectric waveguide
     using the semivectorial finite difference method.
@@ -142,10 +139,8 @@ class SVFDModeSolver(ModeSolver):
                 * (p * (ep - ew) + 2 * w * ew)
                 * ee
                 / (
-                    (p * (ep - ee) + 2 * e * ee)
-                    * (p**2 * (ep - ew) + 4 * w**2 * ew)
-                    + (p * (ep - ew) + 2 * w * ew)
-                    * (p**2 * (ep - ee) + 4 * e**2 * ee)
+                    (p * (ep - ee) + 2 * e * ee) * (p**2 * (ep - ew) + 4 * w**2 * ew)
+                    + (p * (ep - ew) + 2 * w * ew) * (p**2 * (ep - ee) + 4 * e**2 * ee)
                 )
             )
             Aw = (
@@ -153,10 +148,8 @@ class SVFDModeSolver(ModeSolver):
                 * (p * (ep - ee) + 2 * e * ee)
                 * ew
                 / (
-                    (p * (ep - ee) + 2 * e * ee)
-                    * (p**2 * (ep - ew) + 4 * w**2 * ew)
-                    + (p * (ep - ew) + 2 * w * ew)
-                    * (p**2 * (ep - ee) + 4 * e**2 * ee)
+                    (p * (ep - ee) + 2 * e * ee) * (p**2 * (ep - ew) + 4 * w**2 * ew)
+                    + (p * (ep - ew) + 2 * w * ew) * (p**2 * (ep - ee) + 4 * e**2 * ee)
                 )
             )
             Ap = ep * k**2 - An - As - Ae * ep / ee - Aw * ep / ew
@@ -169,10 +162,8 @@ class SVFDModeSolver(ModeSolver):
                 * (q * (ep - es) + 2 * s * es)
                 * en
                 / (
-                    (q * (ep - en) + 2 * n * en)
-                    * (q**2 * (ep - es) + 4 * s**2 * es)
-                    + (q * (ep - es) + 2 * s * es)
-                    * (q**2 * (ep - en) + 4 * n**2 * en)
+                    (q * (ep - en) + 2 * n * en) * (q**2 * (ep - es) + 4 * s**2 * es)
+                    + (q * (ep - es) + 2 * s * es) * (q**2 * (ep - en) + 4 * n**2 * en)
                 )
             )
             As = (
@@ -180,10 +171,8 @@ class SVFDModeSolver(ModeSolver):
                 * (q * (ep - en) + 2 * n * en)
                 * es
                 / (
-                    (q * (ep - en) + 2 * n * en)
-                    * (q**2 * (ep - es) + 4 * s**2 * es)
-                    + (q * (ep - es) + 2 * s * es)
-                    * (q**2 * (ep - en) + 4 * n**2 * en)
+                    (q * (ep - en) + 2 * n * en) * (q**2 * (ep - es) + 4 * s**2 * es)
+                    + (q * (ep - es) + 2 * s * es) * (q**2 * (ep - en) + 4 * n**2 * en)
                 )
             )
             Ae = 2 / e / (e + w)
@@ -255,14 +244,14 @@ class SVFDModeSolver(ModeSolver):
         return A
 
     def solve(self, neigs, tol):
-        from scipy.sparse.linalg import eigen
+        from scipy.sparse import linalg
 
         self.nmodes = neigs
         self.tol = tol
 
         A = self.build_matrix()
 
-        eigvals, eigvecs = eigen.eigs(  # type: ignore
+        eigvals, eigvecs = linalg.eigs(  # type: ignore
             A, k=neigs, which="LR", tol=tol, ncv=10 * neigs, return_eigenvectors=True
         )
 
@@ -296,7 +285,6 @@ class SVFDModeSolver(ModeSolver):
 
 
 class VFDModeSolver(ModeSolver):
-
     """
     The VFDModeSolver class computes the electric and magnetic fields
     for modes of a dielectric waveguide using the "Vector Finite
@@ -1135,12 +1123,7 @@ class VFDModeSolver(ModeSolver):
                 (n * ezz1 * ezz2 / eyy1 + s * ezz2 * ezz1 / eyy2)
                 * (
                     0.5 * n * ezz4 * ezz3 / eyy4 * (2.0 / e**2 - eyx4 / ezz4 / n / e)
-                    + 0.5
-                    * s
-                    * ezz3
-                    * ezz4
-                    / eyy3
-                    * (2.0 / e**2 + eyx3 / ezz3 / s / e)
+                    + 0.5 * s * ezz3 * ezz4 / eyy3 * (2.0 / e**2 + eyx3 / ezz3 / s / e)
                 )
                 / ezz4
                 / ezz3
@@ -1190,12 +1173,7 @@ class VFDModeSolver(ModeSolver):
                 (-n * ezz4 * ezz3 / eyy4 - s * ezz3 * ezz4 / eyy3)
                 * (
                     0.5 * n * ezz1 * ezz2 / eyy1 * (2.0 / w**2 + eyx1 / ezz1 / n / w)
-                    + 0.5
-                    * s
-                    * ezz2
-                    * ezz1
-                    / eyy2
-                    * (2.0 / w**2 - eyx2 / ezz2 / s / w)
+                    + 0.5 * s * ezz2 * ezz1 / eyy2 * (2.0 / w**2 - eyx2 / ezz2 / s / w)
                 )
                 / ezz4
                 / ezz3
@@ -1517,12 +1495,7 @@ class VFDModeSolver(ModeSolver):
                 + (ezz3 / exx2 * ezz2 * w + ezz2 / exx3 * ezz3 * e)
                 * (
                     0.5 * ezz4 * (2.0 / n**2 + exy1 / ezz1 / n / w) / exx1 * ezz1 * w
-                    + 0.5
-                    * ezz1
-                    * (2.0 / n**2 - exy4 / ezz4 / n / e)
-                    / exx4
-                    * ezz4
-                    * e
+                    + 0.5 * ezz1 * (2.0 / n**2 - exy4 / ezz4 / n / e) / exx4 * ezz4 * e
                 )
                 / ezz3
                 / ezz2
@@ -1572,12 +1545,7 @@ class VFDModeSolver(ModeSolver):
                 - (ezz4 / exx1 * ezz1 * w + ezz1 / exx4 * ezz4 * e)
                 * (
                     0.5 * ezz3 * (2.0 / s**2 - exy2 / ezz2 / s / w) / exx2 * ezz2 * w
-                    + 0.5
-                    * ezz2
-                    * (2.0 / s**2 + exy3 / ezz3 / s / e)
-                    / exx3
-                    * ezz3
-                    * e
+                    + 0.5 * ezz2 * (2.0 / s**2 + exy3 / ezz3 / s / e) / exx3 * ezz3 * e
                 )
                 / ezz3
                 / ezz2
@@ -2066,7 +2034,7 @@ class VFDModeSolver(ModeSolver):
             Ez = solver.modes[0].Ez
         """
 
-        from scipy.sparse.linalg import eigen
+        from scipy.sparse import linalg
 
         self.nmodes = neigs
         self.tol = tol
@@ -2081,7 +2049,7 @@ class VFDModeSolver(ModeSolver):
             shift = None
 
         # Here is where the actual mode-solving takes place!
-        [eigvals, eigvecs] = eigen.eigs(
+        [eigvals, eigvecs] = linalg.eigs(
             A,
             k=neigs,
             which="LR",
@@ -2320,14 +2288,9 @@ class FDMode(Mode):
 
     @staticmethod
     def plot_field(x, y, field):
-        try:
-            import pylab
-        except ImportError:
-            print("no pylab installed")
-            return
-        pylab.hot()
-        pylab.contour(x, y, numpy.abs(field.T), 16)
-        pylab.axis("image")
+        plt.hot()
+        plt.contour(x, y, numpy.abs(field.T), 16)
+        plt.axis("image")
 
     def plot_Ex(self, x=None, y=None):
         if x is None:
@@ -2385,30 +2348,25 @@ class FDMode(Mode):
 
     def plot(self):
         """Plot the mode's fields."""
-        try:
-            import pylab
-        except ImportError:
-            print("no pylab installed")
-            return
-        pylab.figure()
-        pylab.subplot(2, 3, 1)
+        plt.figure()
+        plt.subplot(2, 3, 1)
         self.plot_Ex()
-        pylab.title("Ex")
-        pylab.subplot(2, 3, 2)
+        plt.title("Ex")
+        plt.subplot(2, 3, 2)
         self.plot_Ey()
-        pylab.title("Ey")
-        pylab.subplot(2, 3, 3)
+        plt.title("Ey")
+        plt.subplot(2, 3, 3)
         self.plot_Ez()
-        pylab.title("Ez")
-        pylab.subplot(2, 3, 4)
+        plt.title("Ez")
+        plt.subplot(2, 3, 4)
         self.plot_Hx()
-        pylab.title("Hx")
-        pylab.subplot(2, 3, 5)
+        plt.title("Hx")
+        plt.subplot(2, 3, 5)
         self.plot_Hy()
-        pylab.title("Hy")
-        pylab.subplot(2, 3, 6)
+        plt.title("Hy")
+        plt.subplot(2, 3, 6)
         self.plot_Hz()
-        pylab.title("Hz")
+        plt.title("Hz")
 
 
 def stretchmesh(x, y, nlayers, factor, method="PPPP"):