ElectroMagneticPython 2.2.1__py3-none-any.whl → 2.2.3__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,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '2.2.3'
+__version_tuple__ = version_tuple = (2, 2, 3)
+
+__commit_id__ = commit_id = None

EMpy/devices.py

@@ -31,6 +31,7 @@ devices, new ones can be studied.
     isnumber=8367>}
 
 """
+
 __author__ = "Lorenzo Bolla"
 
 import numpy
@@ -39,7 +40,6 @@ from functools import reduce
 
 
 class DeviceMatrix:
-
     """Device Matrix.
 
     Base class for TransferMatrix and ChainMatrix.
@@ -83,7 +83,6 @@ class DeviceMatrix:
 
 
 class TransferMatrix(DeviceMatrix):
-
     """Transfer Matrix.
 
     Notation::
@@ -158,7 +157,6 @@ class TransferMatrix(DeviceMatrix):
 
 
 class ChainMatrix(DeviceMatrix):
-
     """Chain Matrix.
 
     Notation::
@@ -289,7 +287,6 @@ def composeCMlist(CMlist):
 
 
 class Device:
-
     """Generic device.
 
     Notes
@@ -307,7 +304,6 @@ class Device:
 
 
 class Coupler(Device):
-
     """Coupler.
 
     Examples
@@ -436,7 +432,6 @@ class Coupler(Device):
 
 
 class Line(Device):
-
     """Line.
 
     Notes
@@ -570,7 +565,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 +673,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 +739,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 +864,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 +987,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 +1046,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 +1060,6 @@ class T_TCRR(Device):
 
 
 class T_CRTCRR(Device):
-
     """Tunable Coupled Ring Triple-Coupled Ring Resonator.
 
     NOTE
@@ -1129,16 +1117,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 +1135,6 @@ class T_CRTCRR(Device):
 
 
 class T_CTCRR(Device):
-
     """Tunable Coupled Triple Coupled Ring Resonator.
 
     NOTE
@@ -1363,7 +1341,6 @@ class SWG(Device):
 
 
 class Etalon(Device):
-
     """Etalon.
 
     @ivar R: Reflectivity.
@@ -1402,7 +1379,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

@@ -5,6 +5,7 @@
 A material is an object with a refractive index function.
 
 """
+
 from functools import partial
 
 import numpy
@@ -15,7 +16,6 @@ __author__ = "Lorenzo Bolla"
 
 
 class Material:
-
     """Generic class to handle materials.
 
     This class is intended to be subclassed to obtain isotropic and
@@ -28,7 +28,6 @@ class Material:
 
 
 class RefractiveIndex:
-
     """Refractive Index.
 
     Unaware of temperature.
@@ -146,7 +145,6 @@ class RefractiveIndex:
 
 
 class ThermalOpticCoefficient:
-
     """Thermal Optic Coefficient."""
 
     def __init__(self, data=None, T0=300):
@@ -168,7 +166,6 @@ class ThermalOpticCoefficient:
 
 
 class IsotropicMaterial(Material):
-
     """Subclasses Material to describe isotropic materials.
 
     Frequency dispersion and thermic aware.
@@ -232,7 +229,6 @@ class EpsilonTensor:
 
 
 class AnisotropicMaterial(Material):
-
     """Subclass Material to describe anisotropic materials.
 
     No frequency dispersion nor thermic aware.
@@ -292,7 +288,6 @@ BK7 = IsotropicMaterial(
 
 
 class LiquidCrystal(Material):
-
     """Liquid Crystal.
 
     A liquid crystal is determined by it ordinary and extraordinary

EMpy/modesolvers/FD.py

@@ -10,6 +10,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 +21,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 +143,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 +152,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 +166,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 +175,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 +248,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 +289,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 +1127,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 +1177,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 +1499,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 +1549,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 +2038,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 +2053,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 +2292,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 +2352,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"):

EMpy/modesolvers/FMM.py

@@ -13,15 +13,16 @@ Examples
     See L{FMM1d} and L{FMM2d}.
 
 """
-import copy
-from functools import reduce
 
 __author__ = "Luca Gamberale & Lorenzo Bolla"
 
+import copy
+from functools import reduce
+
+from matplotlib import pyplot as plt
 import numpy
 import scipy
 import scipy.optimize
-import pylab
 
 import EMpy.utils
 from EMpy.modesolvers.interface import Mode, ModeSolver
@@ -247,11 +248,11 @@ class FMMMode1dy(FMMMode1d):
 
     def plot(self, y):
         f = self.eval(y)
-        pylab.plot(y, numpy.real(f), y, numpy.imag(y))
-        pylab.legend(("real", "imag"))
-        pylab.xlabel("y")
-        pylab.ylabel("mode1d")
-        pylab.show()
+        plt.plot(y, numpy.real(f), y, numpy.imag(y))
+        plt.legend(("real", "imag"))
+        plt.xlabel("y")
+        plt.ylabel("mode1d")
+        plt.show()
 
     def __str__(self):
         return (
@@ -845,26 +846,26 @@ class FMMMode2d(Mode):
         f = self.fields(x, y)
 
         # fields
-        pylab.figure()
+        plt.figure()
         titles = ["Ex", "Ey", "Ez", "cBx", "cBy", "cBz"]
         for i in range(6):
             subplot_id = 231 + i
-            pylab.subplot(subplot_id)
-            pylab.contour(x, y, numpy.abs(f[i]))
-            pylab.xlabel("x")
-            pylab.ylabel("y")
-            pylab.title(titles[i])
-            pylab.axis("image")
-        pylab.show()
+            plt.subplot(subplot_id)
+            plt.contour(x, y, numpy.abs(f[i]))
+            plt.xlabel("x")
+            plt.ylabel("y")
+            plt.title(titles[i])
+            plt.axis("image")
+        plt.show()
 
         # power
-        pylab.figure()
-        pylab.contour(x, y, numpy.abs(f[-1]))
-        pylab.xlabel("x")
-        pylab.ylabel("y")
-        pylab.title("cSz")
-        pylab.axis("image")
-        pylab.show()
+        plt.figure()
+        plt.contour(x, y, numpy.abs(f[-1]))
+        plt.xlabel("x")
+        plt.ylabel("y")
+        plt.title("cSz")
+        plt.axis("image")
+        plt.show()
 
     def __str__(self):
         return "neff = %s" % (self.keff / (2 * numpy.pi / self.slicesx[0].wl))

EMpy/modesolvers/__init__.py

@@ -7,6 +7,7 @@ Modesolvers:
 
 
 """
+
 __all__ = ["FD", "FMM", "geometries"]
 __author__ = "Lorenzo Bolla"