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

EMpy/modesolvers/geometries.py

@@ -1,8 +1,7 @@
-"""Geometries.
+"""Geometries."""
 
-"""
+from matplotlib import pyplot as plt
 import numpy
-import pylab
 
 from EMpy.modesolvers.interface import interface_matrix
 
@@ -89,8 +88,8 @@ class SWG:
                 numpy.abs(coeffLHS) ** 2 * tmp[:, numpy.newaxis] * const_z
                 + numpy.abs(coeffRHS) ** 2 * tmp[:, numpy.newaxis] * const_z
             )
-        pylab.hot()
-        pylab.contourf(x, z0 + z, numpy.abs(f).T, 16)
+        plt.hot()
+        plt.contourf(x, z0 + z, numpy.abs(f).T, 16)
 
 
 class SimpleJoint:
@@ -221,9 +220,9 @@ class GenericDevice:
         for d in self.devlist:
             d.plot(sumx, nxy, nz, z0=z)
             z += d.length
-        pylab.ylabel("z")
+        plt.ylabel("z")
         if sumx is None:
-            pylab.xlabel("y")
+            plt.xlabel("y")
         else:
-            pylab.xlabel("x")
-        pylab.axis("tight")
+            plt.xlabel("x")
+        plt.axis("tight")

EMpy/transfer_matrix.py

@@ -7,6 +7,7 @@ any thickness.
 Two versions of the algorithm are present: an isotropic one and an
 anisotropic one.
 """
+
 __author__ = "Lorenzo Bolla"
 
 import numpy as np
@@ -18,7 +19,6 @@ from EMpy.constants import c, mu0
 
 
 class TransferMatrix:
-
     """Class to handle the transfer matrix solvers."""
 
     def __init__(self, multilayer):

EMpy/utils.py

@@ -4,18 +4,20 @@
 
 __author__ = "Lorenzo Bolla"
 
+import time
+import sys
+
+from matplotlib import pyplot as plt
 import numpy
-import EMpy.constants
-import EMpy.materials
 import scipy.linalg
 import scipy.interpolate
 import scipy.optimize
-import time
-import sys
 
+import EMpy.constants
+import EMpy.materials
 
-class Layer:
 
+class Layer:
     """A layer is defined by a material (iso or aniso) and a thickness."""
 
     def __init__(self, mat, thickness):
@@ -96,9 +98,7 @@ class BinaryGrating:
             f = self.dc
             h = numpy.arange(-hmax, hmax + 1)
             EPS = (rix1**2 - rix2**2) * f * numpy.sinc(h * f) + rix2**2 * (h == 0)
-            EPS1 = (rix1**-2 - rix2**-2) * f * numpy.sinc(h * f) + rix2**-2 * (
-                h == 0
-            )
+            EPS1 = (rix1**-2 - rix2**-2) * f * numpy.sinc(h * f) + rix2**-2 * (h == 0)
             return EPS, EPS1
         else:
             # anisotropic
@@ -694,7 +694,6 @@ class LiquidCrystalCell:
 
 
 class Multilayer:
-
     """A Multilayer is a list of layers with some more methods."""
 
     def __init__(self, data=None):
@@ -816,22 +815,17 @@ class Slice(Multilayer):
             return self[0]
 
     def plot(self, x0, x1, nmin, nmax, wl=1.55e-6):
-        try:
-            import pylab
-        except ImportError:
-            warning("no pylab installed")
-            return
         y0 = 0
         # ytot = sum([l.thickness for l in self])
         for l in self:
             y1 = y0 + l.thickness
             n = l.mat.n(wl)
             r = 1.0 - (1.0 * (n - nmin) / (nmax - nmin))
-            pylab.fill(
+            plt.fill(
                 [x0, x1, x1, x0], [y0, y0, y1, y1], ec="yellow", fc=(r, r, r), alpha=0.5
             )
             y0 = y1
-        pylab.axis("image")
+        plt.axis("image")
 
     def __str__(self):
         return "width = %e\n%s" % (self.width, Multilayer.__str__(self))
@@ -916,11 +910,6 @@ class CrossSection(list):
         return eps
 
     def plot(self, wl=1.55e-6):
-        try:
-            import pylab
-        except ImportError:
-            warning("no pylab installed")
-            return
         x0 = 0
         ns = [[l.mat.n(wl) for l in s] for s in self]
         nmax = max(max(ns))
@@ -929,7 +918,7 @@ class CrossSection(list):
             x1 = x0 + s.width
             s.plot(x0, x1, nmin, nmax, wl=wl)
             x0 = x1
-        pylab.axis("image")
+        plt.axis("image")
 
 
 class Peak:
@@ -1218,7 +1207,7 @@ def interp2(x, y, xp, yp, fp):
 
 def trapz2(f, x=None, y=None, dx=1.0, dy=1.0):
     """Double integrate."""
-    return numpy.trapz(numpy.trapz(f, x=y, dx=dy), x=x, dx=dx)
+    return numpy.trapezoid(numpy.trapezoid(f, x=y, dx=dy), x=x, dx=dx)
 
 
 def centered1d(x):
@@ -1251,7 +1240,6 @@ def warning(s):
 
 
 class ProgressBar:
-
     """Creates a text-based progress bar. Call the object with the `print'
     command to see the progress bar, which looks something like this:
 

electromagneticpython-2.2.3.dist-info/METADATA

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: ElectroMagneticPython
+Version: 2.2.3
+Summary: EMpy - ElectroMagnetic Python
+Author-email: Lorenzo Bolla <code@lbolla.info>
+License-Expression: MIT
+Project-URL: Homepage, http://lbolla.github.io/EMpy/
+Project-URL: Repository, https://github.com/lbolla/EMpy
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.18
+Requires-Dist: scipy>=1.7
+Requires-Dist: matplotlib>=3.1
+Dynamic: license-file
+
+# EMpy - ElectroMagnetic Python
+
+[![CI](https://github.com/lbolla/EMpy/actions/workflows/python-app.yml/badge.svg)](https://github.com/lbolla/EMpy/actions/workflows/python-app.yml) [![PyPI](https://badge.fury.io/py/ElectroMagneticPython.svg)](https://badge.fury.io/py/ElectroMagneticPython)
+
+`EMpy - ElectroMagnetic Python` is a suite of algorithms widely known and used in electromagnetic problems and optics: the transfer matrix algorithm, the rigorous coupled wave analysis algorithm and more.
+
+Run the examples in `examples/*` to have an idea how EMpy works.
+
+Visit https://lbolla.github.io/EMpy/ for more information.
+
+## Installation
+
+```bash
+pip install ElectromagneticPython
+```
+
+Optionally, install `bvp`:
+
+```bash
+pip install scikits.bvp1lg
+```
+
+## Development
+
+First, download the source code from https://github.com/lbolla/EMpy.
+
+EMpy is managed with `uv` (https://docs.astral.sh/uv/):
+
+Install dev environment with:
+
+```bash
+make develop
+```
+
+Run tests with:
+
+```bash
+make test
+```
+
+Run examples with, e.g.:
+```bash
+uv run examples/ex_APRR.py
+```
+
+Upgrade dependencies with `uv`:
+
+```bash
+make upgrade
+```
+
+## Release process
+
+Package version is handled by `setuptools_scm`/`uv`:
+
+```bash
+make release PART=...
+```
+
+GitHub actions will build and upload the package to PyPI.
+
+## Citation
+
+If you find EMpy useful in your job, please consider adding a citation.
+
+As reference:
+
+```
+Bolla, L. (2017). EMpy [Computer software]. https://github.com/lbolla/EMpy/
+```
+
+As text:
+
+```
+We used EMpy (version x.y.z) to complete our work.
+```

electromagneticpython-2.2.3.dist-info/RECORD

@@ -0,0 +1,44 @@
+EMpy/RCWA.py,sha256=ORsYHvt1p7TIR3vKYQfhigRH1RnHyAX98kkGMkmxIi0,32673
+EMpy/__init__.py,sha256=aAaHG0VlGltUrWWZ4JMlVms2HDGj7RZ3CYNKqpZVYtM,1285
+EMpy/_version.py,sha256=KPjL9Q7mJ1mOq60evnMRyAe7ifMMp2BfVmDRydV9x98,704
+EMpy/constants.py,sha256=x1N8eRXQW_gdr1557n7tvUXiM4RW_Fc_EydLd5AUC1o,723
+EMpy/devices.py,sha256=Tu7CVvrhqfHBSf1EiDNPnUG4Dn6MDb6qgg2VpafmdHs,37760
+EMpy/materials.py,sha256=pgEM4Izy6HTA87Rl_GtNiiq5AKzc3M54fVFPFRnA8_I,10682
+EMpy/scattering.py,sha256=1rY8_TI0kzTLYwpFSSXndaO9FzDzVPRVow55vzIDQiM,7339
+EMpy/transfer_matrix.py,sha256=wSFqcEQYNUV4oM5SlZkglwRVyU5_w5dvRENXHfRXQpQ,14582
+EMpy/utils.py,sha256=hIZ07CqM1lhRTIujbReGldlBkUjzI3iXAyAReEATBqA,41762
+EMpy/modesolvers/FD.py,sha256=vKQOTgXY3-KzODAX0IOAfLbcFHUbpRt0MgteRLU3vjk,79281
+EMpy/modesolvers/FMM.py,sha256=Z0HL_QGeJoQC9vyY2obBomcey0ZzVT5YZmD2-hABqZ8,78351
+EMpy/modesolvers/__init__.py,sha256=rg8pzFcZd7cihqfXYj0sQamogjtMV3ObNXCNbFD3bu0,222
+EMpy/modesolvers/geometries.py,sha256=X8Jd1iNoPRl5ibZiaKG13lHDIzejQ6PfrB6Zbe_c5lg,7906
+EMpy/modesolvers/interface.py,sha256=spMy30TFedYXJHcoV3yUdGkycGt5cplJUCeZui6a5MY,2397
+electromagneticpython-2.2.3.dist-info/licenses/LICENSE,sha256=NlQFsrkwMvQ2aD8531IDm6Rk01KzlI42HVzK5M1Hpw8,1065
+examples/ex_APRR.py,sha256=f3-LOPoLNSxjqfwAJJNjVSnKYB88CIULhbjzkzdavXA,459
+examples/ex_NRR.py,sha256=NVs4UASVdwiogZDSOfGAoSnbBByhB8EBLu4x3CDOnyE,900
+examples/ex_RCWA.py,sha256=05Cvv3BqFgSDn_u2iZsV65HdmvVbNljgJfISaPsqd1o,2733
+examples/ex_RCWA_2.py,sha256=Iwb75g2OYWayBpGn2P5BlPBh_50ZeM354eJ3kjj8pgg,1455
+examples/ex_RCWA_3.py,sha256=unROedjRchAnLmyqPdhkl2-qekmddtWw6d8i6oo5VQU,1329
+examples/ex_SRR.py,sha256=ciRDjn0IlpThYVLpSkn2dW6oOnJwt7_c7JJzMydl444,612
+examples/ex_laser_etch_monitor.py,sha256=n6Ov8BvStKw-2veSNvX2nmR2VQJyWfsyOSh1ggvZ2qM,7589
+examples/ex_modesolver.py,sha256=gD06Z2DXrxVCfakAIkqNR5k7ynSz5e1hfEYvt8ZyO0w,1529
+examples/ex_modesolver_2.py,sha256=nWohSs9eftfY06wsg13M3UHBMcmM0QdPrOEWNta28mo,1264
+examples/ex_modesolver_3.py,sha256=RA6LvitShITChg4DWFleI8FUUOnSUwIOCsxfW4VByGg,1209
+examples/ex_modesolver_4.py,sha256=9JUjg6NK7IjwSgQvg3D_n6l_Cr0ev6hEoJGS0xffrFo,901
+examples/ex_modesolver_dch.py,sha256=ha38QB7rLklEnTNfF_C0b8u7gTGKIk_T3FB0TMib5eM,7314
+examples/ex_modesolver_dch_anis.py,sha256=Ye4nV5FXVxjT-FtJ3CyjzjXh9pmx9A0mbv-CkZxIN3Y,8184
+examples/ex_transfer_matrix.py,sha256=JyC_MPrrfpNItYmMQjm5RbMWXe7CSd96RplJrntdOaI,1789
+examples/ex_transfer_matrix_2.py,sha256=i1YMmrOSWDK0YS9aGF2thFD4_suNZsRJvs7Ei62sHAI,1058
+examples/ex_transfer_matrix_2.py.png,sha256=-cgjAE1t_6UPJyOZbAagaaBs-odr59A1RYldSpMOo0M,34886
+examples/ex_transfer_matrix_3.py,sha256=J8GePd3b45TmGJWL_Df7GFg-4FN8846WS9j7l9TmvRs,1501
+examples/lc_data.dat,sha256=MrT57K7PZV0YT2GPU9LjO6WlC-xCd6n841P57tQW5_s,4151
+examples/nk.py,sha256=hjUhwu4QzXCR0_PSKAnQ0RTD4mfe7xCYW6AbrSu4d3U,43161
+scripts/FDTD.py,sha256=eK3Ra8GqkgWGP_oAPrM5pXlxERWgrwl2jwJIwoYGDfE,25308
+tests/__init__.py,sha256=XNMyfmlHhqih2xHEklXlmQ8GVUAdiiWrkT3trIOMpRQ,29
+tests/devices_test.py,sha256=UbmJgHp7kNVQyBYwxgaAierUVMvC7Pq5Jv7BKdFQPSw,890
+tests/materials_test.py,sha256=-Z8ZmqwgSCg2AJwF_4j-RH8Ct7AOOWhV67lyMm5dcO8,1846
+tests/modesolvers_test.py,sha256=v_nRDbKlda4w7A5mbZZl5fKYa2GlgLzHZaKDJZzGyrM,984
+tests/utils_test.py,sha256=QnG4O_FHrX6tXH1MuocFXxptOuOtoU-dR-crCtADzQw,721
+electromagneticpython-2.2.3.dist-info/METADATA,sha256=XB6uQFtMcIOL-56FDLYMqR1_i_Cne79NZP4UApAC8os,2351
+electromagneticpython-2.2.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+electromagneticpython-2.2.3.dist-info/top_level.txt,sha256=CosMJsXjoaa3iZmCrZf7E0eorTFxpEFfrtfUx1YWIHA,28
+electromagneticpython-2.2.3.dist-info/RECORD,,

{ElectroMagneticPython-2.2.1.dist-info → electromagneticpython-2.2.3.dist-info}/WHEEL

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

electromagneticpython-2.2.3.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+EMpy
+examples
+scripts
+tests

examples/ex_APRR.py

@@ -0,0 +1,18 @@
+"""All-pass ring resonator example."""
+
+from matplotlib import pyplot as plt
+import numpy
+
+import EMpy
+
+wls = numpy.linspace(1.5e-6, 1.6e-6, 1000)
+K = EMpy.devices.Coupler(wls, numpy.sqrt(0.08), 1.0)
+l = 2 * numpy.pi * 5e-6
+SWG = EMpy.devices.SWG(400, 220, 125).solve(wls)
+APRR = EMpy.devices.APRR(K, SWG.neff, l).solve()
+
+plt.plot(wls, numpy.unwrap(numpy.angle(APRR.THRU)), "r.-")
+plt.axis("tight")
+plt.xlabel("wavelength /m")
+plt.ylabel("phase")
+plt.show()

examples/ex_NRR.py

@@ -0,0 +1,40 @@
+"""N-Ring resonators example."""
+
+
+from matplotlib import pyplot as plt
+import numpy
+
+import EMpy
+
+wls = numpy.linspace(1.53e-6, 1.57e-6, 1000)
+
+Ks = [
+    EMpy.devices.Coupler(wls, numpy.sqrt(0.08), 1.0),
+    EMpy.devices.Coupler(wls, numpy.sqrt(0.008), 1.0),
+    EMpy.devices.Coupler(wls, numpy.sqrt(0.006), 1.0),
+    EMpy.devices.Coupler(wls, numpy.sqrt(0.09), 1.0),
+]
+
+R = 5e-6
+l1s = [numpy.pi * R, numpy.pi * R, numpy.pi * R]
+l2s = [numpy.pi * R, numpy.pi * R, numpy.pi * R]
+
+SWG = EMpy.devices.SWG(400, 220, 125).solve(wls)
+neffs = [SWG.neff, SWG.neff, SWG.neff]
+
+NRR = EMpy.devices.NRR(Ks, neffs, l1s, l2s).solve()
+
+plt.plot(
+    wls,
+    20 * numpy.log10(numpy.absolute(NRR.THRU)),
+    "r.-",
+    wls,
+    20 * numpy.log10(numpy.absolute(NRR.DROP)),
+    "g.-",
+)
+plt.axis("tight")
+plt.ylim([-30, 0])
+plt.xlabel("wavelength /m")
+plt.ylabel("power /dB")
+plt.legend(("THRU", "DROP"))
+plt.show()

examples/ex_RCWA.py

@@ -0,0 +1,95 @@
+"""Rigorous Coupled Wave Analysis example."""
+
+from matplotlib import pyplot as plt
+import numpy
+
+import EMpy
+from EMpy.materials import (
+    IsotropicMaterial,
+    AnisotropicMaterial,
+    RefractiveIndex,
+    EpsilonTensor,
+)
+
+alpha = 0.0
+delta = 0.0
+# psi = EMpy.utils.deg2rad(0.)  # TM
+# psi = EMpy.utils.deg2rad(90.)  # TE
+psi = EMpy.utils.deg2rad(70.0)  # hybrid
+phi = EMpy.utils.deg2rad(90.0)
+
+LAMBDA = 1016e-9  # grating periodicity
+n = 2  # orders of diffraction
+
+UV6 = IsotropicMaterial("UV6", n0=RefractiveIndex(n0_const=1.560))
+SiN = AnisotropicMaterial(
+    "SiN",
+    epsilon_tensor=EpsilonTensor(
+        epsilon_tensor_const=EMpy.constants.eps0
+        * EMpy.utils.euler_rotate(
+            numpy.diag(numpy.asarray([1.8550, 1.8750, 1.9130]) ** 2),
+            EMpy.utils.deg2rad(14),
+            EMpy.utils.deg2rad(25),
+            EMpy.utils.deg2rad(32),
+        )
+    ),
+)
+BPTEOS = IsotropicMaterial("BPTEOS", n0=RefractiveIndex(n0_const=1.448))
+ARC1 = IsotropicMaterial("ARC1", n0=RefractiveIndex(n0_const=1.448))
+
+EFF = IsotropicMaterial("EFF", n0=RefractiveIndex(n0_const=1.6))
+
+multilayer1 = EMpy.utils.Multilayer(
+    [
+        EMpy.utils.Layer(EMpy.materials.Air, numpy.inf),
+        EMpy.utils.Layer(SiN, 226e-9),
+        EMpy.utils.Layer(BPTEOS, 226e-9),
+        EMpy.utils.BinaryGrating(SiN, BPTEOS, 0.659, LAMBDA, 123e-9),
+        EMpy.utils.Layer(SiN, 219e-9),
+        EMpy.utils.Layer(EMpy.materials.SiO2, 2188e-9),
+        EMpy.utils.Layer(EMpy.materials.Si, numpy.inf),
+    ]
+)
+
+multilayer2 = EMpy.utils.Multilayer(
+    [
+        EMpy.utils.Layer(EMpy.materials.Air, numpy.inf),
+        EMpy.utils.Layer(SiN, 226e-9),
+        EMpy.utils.Layer(BPTEOS, 226e-9),
+        EMpy.utils.Layer(IsotropicMaterial(n0=RefractiveIndex(n0_const=1.6)), 123e-9),
+        EMpy.utils.Layer(SiN, 219e-9),
+        EMpy.utils.Layer(EMpy.materials.SiO2, 2188e-9),
+        EMpy.utils.Layer(EMpy.materials.Si, numpy.inf),
+    ]
+)
+
+wls = numpy.linspace(1.45e-6, 1.75e-6, 301)
+
+solution1 = EMpy.RCWA.AnisotropicRCWA(multilayer1, alpha, delta, psi, phi, n).solve(wls)
+solution2 = EMpy.RCWA.AnisotropicRCWA(multilayer2, alpha, delta, psi, phi, n).solve(wls)
+
+um = 1e-6
+plt.plot(
+    # wls / um, solution1.DEO1[n, :], 'k.-',
+    # wls / um, solution1.DEO3[n, :], 'r.-',
+    wls / um,
+    solution1.DEE1[n, :],
+    "b.-",
+    wls / um,
+    solution1.DEE3[n, :],
+    "g.-",
+    # wls / um, solution2.DEO1[n, :], 'k--',
+    # wls / um, solution2.DEO3[n, :], 'r--',
+    wls / um,
+    solution2.DEE1[n, :],
+    "b--",
+    wls / um,
+    solution2.DEE3[n, :],
+    "g--",
+)
+plt.xlabel("wavelength [um]")
+plt.ylabel("diffraction efficiency")
+plt.legend(("DEO1", "DEO3", "DEE1", "DEE3"))
+plt.axis("tight")
+plt.ylim([0, 0.15])
+plt.show()

examples/ex_RCWA_2.py

@@ -0,0 +1,52 @@
+"""Rigorous Coupled Wave Analysis example.
+
+Inspired by Moharam, "Formulation for stable and efficient implementation of the rigorous coupled-wave analysis of
+binary gratings", JOSA A, 12(5), 1995
+"""
+
+from matplotlib import pyplot as plt
+import numpy
+
+import EMpy
+from EMpy.materials import IsotropicMaterial, RefractiveIndex
+
+alpha = EMpy.utils.deg2rad(10.0)
+delta = EMpy.utils.deg2rad(0.0)
+psi = EMpy.utils.deg2rad(0.0)  # TE
+phi = EMpy.utils.deg2rad(90.0)
+
+wl = numpy.array([1.55e-6])
+ds = numpy.linspace(0.0, 5.0, 100) * wl
+LAMBDA = 10 * wl
+
+n = 3  # orders of diffraction
+
+Top = IsotropicMaterial("Top", n0=RefractiveIndex(n0_const=1.0))
+Bottom = IsotropicMaterial("Bottom", n0=RefractiveIndex(n0_const=2.04))
+
+solutions = []
+for d in ds:
+    multilayer = EMpy.utils.Multilayer(
+        [
+            EMpy.utils.Layer(Top, numpy.inf),
+            EMpy.utils.BinaryGrating(Top, Bottom, 0.3, LAMBDA, d),
+            EMpy.utils.Layer(Bottom, numpy.inf),
+        ]
+    )
+
+    solution = EMpy.RCWA.IsotropicRCWA(multilayer, alpha, delta, psi, phi, n).solve(wl)
+    solutions.append(solution)
+
+DE1 = numpy.zeros(len(solutions))
+DE3 = numpy.zeros(len(solutions))
+for ss, s in enumerate(solutions):
+    DE1[ss] = s.DE1[n, 0]
+    DE3[ss] = s.DE3[n, 0]
+
+plt.plot(ds / wl, DE1[:], "k.-", ds / wl, DE3[:], "r.-")
+plt.xlabel("normalized groove depth")
+plt.ylabel("diffraction efficiency")
+plt.legend(("DE1", "DE3"))
+plt.axis("tight")
+plt.ylim([0, 1])
+plt.show()

examples/ex_RCWA_3.py

@@ -0,0 +1,58 @@
+"""Rigorous Coupled Wave Analysis example."""
+
+
+from matplotlib import pyplot as plt
+import numpy
+
+import EMpy
+from EMpy.materials import IsotropicMaterial, RefractiveIndex
+
+alpha = EMpy.utils.deg2rad(30.0)
+delta = EMpy.utils.deg2rad(45.0)
+psi = EMpy.utils.deg2rad(0.0)  # TE
+phi = EMpy.utils.deg2rad(90.0)
+
+wls = numpy.linspace(1.5495e-6, 1.550e-6, 101)
+
+LAMBDA = 1.0e-6  # grating periodicity
+n = 3  # orders of diffraction
+
+Top = IsotropicMaterial("Top", n0=RefractiveIndex(n0_const=1.0))
+Bottom = IsotropicMaterial("Bottom", n0=RefractiveIndex(n0_const=3.47))
+
+multilayer = EMpy.utils.Multilayer(
+    [
+        EMpy.utils.Layer(Top, numpy.inf),
+        EMpy.utils.BinaryGrating(Top, Bottom, 0.4, LAMBDA, 0.01),
+        EMpy.utils.Layer(Bottom, numpy.inf),
+    ]
+)
+
+solution = EMpy.RCWA.IsotropicRCWA(multilayer, alpha, delta, psi, phi, n).solve(wls)
+
+plt.plot(
+    wls,
+    solution.DE1[n, :],
+    "ko-",
+    wls,
+    solution.DE3[n, :],
+    "ro-",
+    wls,
+    solution.DE1[n - 1, :],
+    "kx-",
+    wls,
+    solution.DE3[n - 1, :],
+    "rx-",
+    wls,
+    solution.DE1[n + 1, :],
+    "k.-",
+    wls,
+    solution.DE3[n + 1, :],
+    "r.-",
+)
+plt.xlabel("wavelength /m")
+plt.ylabel("diffraction efficiency")
+plt.legend(("DE1:0", "DE3:0", "DE1:-1", "DE3:-1", "DE1:+1", "DE3:+1"))
+plt.axis("tight")
+plt.ylim([0, 1])
+plt.show()

examples/ex_SRR.py

@@ -0,0 +1,23 @@
+"""Single ring resonator example."""
+
+
+from matplotlib import pyplot as plt
+import numpy
+
+import EMpy
+
+wls = numpy.linspace(1.53e-6, 1.56e-6, 1000)
+K1 = EMpy.devices.Coupler(wls, numpy.sqrt(0.08), 1.0)
+K2 = EMpy.devices.Coupler(wls, numpy.sqrt(0.08), 1.0)
+l1 = numpy.pi * 5e-6
+l2 = numpy.pi * 5e-6
+SWG = EMpy.devices.SWG(488, 220, 25).solve(wls)
+SRR = EMpy.devices.SRR(K1, K2, SWG.neff, l1, l2).solve()
+
+plt.plot(wls, numpy.absolute(SRR.THRU), "r.-", wls, numpy.absolute(SRR.DROP), "g.-")
+plt.axis("tight")
+plt.ylim([0, 1])
+plt.xlabel("wavelength /m")
+plt.ylabel("power")
+plt.legend(("THRU", "DROP"))
+plt.show()