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

tests/devices_test.py

@@ -0,0 +1,31 @@
+from unittest import TestCase
+
+import numpy
+
+import EMpy.devices
+
+
+class NRRTest(TestCase):
+
+    def test_solve(self):
+        N = 1000
+        wls = numpy.linspace(1.53e-6, 1.57e-6, N)
+
+        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()
+
+        self.assertEqual(NRR.THRU.shape, (N,))
+        self.assertAlmostEqual(numpy.absolute(NRR.THRU).min(), 0.3868920546379094)

tests/materials_test.py

@@ -1,4 +1,3 @@
-# pylint: disable=no-self-use
 from unittest import TestCase
 
 from numpy import array
@@ -8,6 +7,7 @@ import EMpy.materials as mat
 
 
 class RefractiveIndexTest(TestCase):
+
     def test_all_nones(self):
         with assert_raises(ValueError):
             mat.RefractiveIndex()

tests/modesolvers_test.py

@@ -0,0 +1,36 @@
+from unittest import TestCase
+
+import numpy
+
+import EMpy.modesolvers
+
+
+class VFDModeSolverTest(TestCase):
+
+    def test_solve(self):
+
+        def epsfunc(x_, y_):
+            """Return a matrix describing a 2d material.
+
+            :param x_: x values
+            :param y_: y values
+            :return: 2d-matrix
+            """
+            xx, yy = numpy.meshgrid(x_, y_)
+            return numpy.where(
+                (numpy.abs(xx.T - 1.24e-6) <= 0.24e-6) * (numpy.abs(yy.T - 1.11e-6) <= 0.11e-6),
+                3.4757**2,
+                1.446**2,
+            )
+
+        neigs = 2
+        tol = 1e-8
+        boundary = "0000"
+        wl = 1.55e-6
+        x = numpy.linspace(0, 2.48e-6, 125)
+        y = numpy.linspace(0, 2.22e-6, 112)
+        solver = EMpy.modesolvers.FD.VFDModeSolver(wl, x, y, epsfunc, boundary).solve(
+            neigs, tol
+        )
+        self.assertEqual(len(solver.modes), 2)
+        self.assertAlmostEqual(solver.modes[0].neff, 2.4179643622942937)

tests/transfer_matrix_test.py

@@ -0,0 +1,134 @@
+from unittest import TestCase
+
+import numpy as np
+from numpy.testing import assert_allclose
+
+import EMpy
+
+
+def _make_iso_multilayer(n_list, d_list):
+    layers = EMpy.utils.Multilayer()
+    for n, d in zip(n_list, d_list):
+        mat = EMpy.materials.IsotropicMaterial(
+            "mat", n0=EMpy.materials.RefractiveIndex(n0_const=n)
+        )
+        layers.append(EMpy.utils.Layer(mat, d))
+    return layers
+
+
+def _make_aniso_multilayer(n_list, d_list):
+    layers = EMpy.utils.Multilayer()
+    for n, d in zip(n_list, d_list):
+        eps = EMpy.materials.EpsilonTensor(
+            epsilon_tensor_const=(n**2) * EMpy.constants.eps0 * np.eye(3)
+        )
+        mat = EMpy.materials.AnisotropicMaterial("mat", epsilon_tensor=eps)
+        layers.append(EMpy.utils.Layer(mat, d))
+    return layers
+
+
+class TransferMatrixTest(TestCase):
+
+    def test_fresnel_brewster(self):
+        n1, n2 = 1.0, 1.5
+        theta_b = np.arctan2(n2, n1)
+        layers = _make_iso_multilayer([n1, n2], [np.inf, np.inf])
+        sol = EMpy.transfer_matrix.IsotropicTransferMatrix(layers, theta_b).solve(
+            [1.55e-6]
+        )
+        assert_allclose(sol.Rp, [0.0], atol=1e-15)
+        assert_allclose(sol.Tp, [1.0], atol=1e-15)
+        assert_allclose(sol.Rs + sol.Ts, [1.0], atol=1e-15)
+
+    def test_total_internal_reflection(self):
+        layers = _make_iso_multilayer([1.5, 1.0], [np.inf, np.inf])
+        theta_inc = EMpy.utils.deg2rad(60.0)
+        sol = EMpy.transfer_matrix.IsotropicTransferMatrix(layers, theta_inc).solve(
+            [1.55e-6]
+        )
+        assert_allclose(sol.Rs, [1.0], atol=1e-15)
+        assert_allclose(sol.Ts, [0.0], atol=1e-15)
+        assert_allclose(sol.Rp, [1.0], atol=1e-15)
+        assert_allclose(sol.Tp, [0.0], atol=1e-15)
+
+    def test_frustrated_total_internal_reflection(self):
+        layers = _make_iso_multilayer([1.5, 1.0, 1.5], [np.inf, 0.2e-6, np.inf])
+        theta_inc = EMpy.utils.deg2rad(60.0)
+        sol = EMpy.transfer_matrix.IsotropicTransferMatrix(layers, theta_inc).solve(
+            [1.55e-6]
+        )
+        self.assertTrue((0.0 < sol.Ts[0] < 1.0) and (0.0 < sol.Tp[0] < 1.0))
+        assert_allclose(sol.Rs + sol.Ts, [1.0], atol=1e-15)
+        assert_allclose(sol.Rp + sol.Tp, [1.0], atol=1e-15)
+
+    def test_absorbing_exit_medium(self):
+        wls = [1.55e-6]
+        theta_inc = EMpy.utils.deg2rad(40.0)
+        n_list = [1.0, 1.5 - 0.5j]
+        d_list = [np.inf, np.inf]
+
+        iso_layers = _make_iso_multilayer(n_list, d_list)
+        aniso_layers = _make_aniso_multilayer(n_list, d_list)
+
+        sol_iso = EMpy.transfer_matrix.IsotropicTransferMatrix(
+            iso_layers, theta_inc
+        ).solve(wls)
+        sol_aniso = EMpy.transfer_matrix.AnisotropicTransferMatrix(
+            aniso_layers, theta_inc, 0.0
+        ).solve(wls)
+
+        # Single interface from lossless medium: net flux across z=0 is conserved
+        assert_allclose(sol_iso.Rs + sol_iso.Ts, [1.0], atol=1e-15)
+        assert_allclose(sol_iso.Rp + sol_iso.Tp, [1.0], atol=1e-15)
+
+        assert_allclose(sol_iso.Rs, sol_aniso.R[0, 0, :], rtol=1e-6)
+        assert_allclose(sol_iso.Ts, sol_aniso.T[0, 0, :], rtol=1e-6)
+        assert_allclose(sol_iso.Rp, sol_aniso.R[1, 1, :], rtol=1e-6)
+        assert_allclose(sol_iso.Tp, sol_aniso.T[1, 1, :], rtol=1e-6)
+
+    def test_absorbing_slab(self):
+        wls = [1.55e-6]
+        theta_inc = EMpy.utils.deg2rad(20.0)
+        n_list = [1.0, 2.0 - 0.1j, 1.0]
+        d_list = [np.inf, 0.5e-6, np.inf]
+
+        iso_layers = _make_iso_multilayer(n_list, d_list)
+        aniso_layers = _make_aniso_multilayer(n_list, d_list)
+
+        sol_iso = EMpy.transfer_matrix.IsotropicTransferMatrix(
+            iso_layers, theta_inc
+        ).solve(wls)
+        sol_aniso = EMpy.transfer_matrix.AnisotropicTransferMatrix(
+            aniso_layers, theta_inc, 0.0
+        ).solve(wls)
+
+        self.assertLess(sol_iso.Rs[0] + sol_iso.Ts[0], 1.0)
+        self.assertLess(sol_iso.Rp[0] + sol_iso.Tp[0], 1.0)
+        assert_allclose(sol_iso.Rs, sol_aniso.R[0, 0, :], rtol=1e-6)
+        assert_allclose(sol_iso.Ts, sol_aniso.T[0, 0, :], rtol=1e-6)
+        assert_allclose(sol_iso.Rp, sol_aniso.R[1, 1, :], rtol=1e-6)
+        assert_allclose(sol_iso.Tp, sol_aniso.T[1, 1, :], rtol=1e-6)
+
+    def test_iso_vs_aniso_non_unit_incident_index(self):
+        wls = np.linspace(1.4e-6, 1.7e-6, 5)
+        n_list = [1.5, 2.1, 1.0]
+        d_list = [np.inf, 0.3e-6, np.inf]
+        theta_inc = EMpy.utils.deg2rad(30.0)
+        theta_vac = np.arcsin(n_list[0] * np.sin(theta_inc))
+
+        iso_layers = _make_iso_multilayer(n_list, d_list)
+        aniso_layers = _make_aniso_multilayer(n_list, d_list)
+
+        sol_iso = EMpy.transfer_matrix.IsotropicTransferMatrix(
+            iso_layers, theta_inc
+        ).solve(wls)
+        sol_aniso = EMpy.transfer_matrix.AnisotropicTransferMatrix(
+            aniso_layers, theta_vac, 0.0
+        ).solve(wls)
+
+        assert_allclose(sol_iso.Rs + sol_iso.Ts, 1.0, atol=1e-14)
+        assert_allclose(sol_iso.Rp + sol_iso.Tp, 1.0, atol=1e-14)
+        assert_allclose(sol_iso.Rs, sol_aniso.R[0, 0, :], rtol=1e-6)
+        assert_allclose(sol_iso.Ts, sol_aniso.T[0, 0, :], rtol=1e-6)
+        assert_allclose(sol_iso.Rp, sol_aniso.R[1, 1, :], rtol=1e-6)
+        assert_allclose(sol_iso.Tp, sol_aniso.T[1, 1, :], rtol=1e-6)

tests/utils_test.py

@@ -1,23 +1,27 @@
-# pylint: disable=no-self-use
 from unittest import TestCase
 
 import random
 import math
 
 from numpy import pi
-from numpy.testing import assert_almost_equal
 
 import EMpy.utils as U
 
 
 class UtilsTest(TestCase):
+
     def test_deg2rad(self):
-        # TODO use hypothesis
         x = -2 * pi + 4 * pi * random.random()
-        assert_almost_equal(x, U.deg2rad(U.rad2deg(x)))
+        self.assertAlmostEqual(x, U.deg2rad(U.rad2deg(x)))
 
     def test_norm(self):
         self.assertEqual(U.norm([1, 0, 0]), 1)
         self.assertEqual(U.norm([0, 1, 0]), 1)
         self.assertEqual(U.norm([0, 0, 1]), 1)
-        assert_almost_equal(U.norm([1, 0, 1]), math.sqrt(2))
+        self.assertAlmostEqual(U.norm([1, 0, 1]), math.sqrt(2))
+
+    def test_trapz2(self):
+        f = [[i + j for i in range(5)] for j in range(5)]
+        res = U.trapz2(f, dx=1.0, dy=1.0)
+        # integral of f = x + y over [0,4]x[0,4] = 64
+        self.assertAlmostEqual(res, 64.0)

EMpy/version.py

@@ -1 +0,0 @@
-version = "2.2.1"

ElectroMagneticPython-2.2.1.dist-info/METADATA

@@ -1,109 +0,0 @@
-Metadata-Version: 2.1
-Name: ElectroMagneticPython
-Version: 2.2.1
-Summary: EMpy - ElectroMagnetic Python
-Home-page: http://lbolla.github.io/EMpy/
-Download-URL: https://github.com/lbolla/EMpy
-Author: Lorenzo Bolla
-Author-email: code@lbolla.info
-License: BSD
-Platform: Windows
-Platform: Linux
-Platform: Mac OS-X
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Natural Language :: English
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Classifier: Topic :: Scientific/Engineering :: Physics
-Provides: EMpy
-License-File: LICENSE
-Requires-Dist: numpy>=1.18
-Requires-Dist: scipy>=1.7
-Requires-Dist: matplotlib>=3.1
-
-EMpy - ElectroMagnetic Python
-*****************************
-
-.. image:: https://github.com/lbolla/EMpy/actions/workflows/python-app.yml/badge.svg
-    :target: https://github.com/lbolla/EMpy/actions/workflows/python-app.yml
-
-.. image:: https://badge.fury.io/py/ElectroMagneticPython.svg
-    :target: 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 http://lbolla.github.io/EMpy/ for more information.
-
-Installation
-============
-
-.. code-block:: bash
-
-  $> pip install ElectromagneticPython
-
-Optionally, install `bvp`:
-
-.. code-block:: bash
-
-  $> pip install scikits.bvp1lg
-
-Development
-===========
-
-First, download the source code from https://github.com/lbolla/EMpy.
-
-Create a virtualenv with, e.g:
-
-.. code-block:: bash
-
-  $> make venv
-
-Then, from inside a `virtualenv`, install dev environment with:
-
-.. code-block:: bash
-
-  $> make develop
-
-Run tests with:
-
-.. code-block:: bash
-
-  $> make test
-
-Upgrade dependencies with:
-
-.. code-block:: bash
-
-  $> make requirements-upgrade
-  $> make requirements-sync
-
-
-Release process
-===============
-
-1. Edit CHANGES
-2. `make release PART=major|minor|patch`
-
-Citation
-========
-
-If you find EMpy useful in your job, please consider adding a citation.
-
-As reference:
-
-.. code-block::
-
-   Bolla, L. (2017). EMpy [Computer software]. https://github.com/lbolla/EMpy/
-
-As text:
-
-.. code-block::
-
-   We used EMpy (version x.y.z) to complete our work.

ElectroMagneticPython-2.2.1.dist-info/RECORD

@@ -1,22 +0,0 @@
-EMpy/RCWA.py,sha256=8wro-KNtnWTrYN2NlV8OGGrJGnd9DDwkK3KlVJ4TU8A,32249
-EMpy/__init__.py,sha256=PSH3TiCVO9LSBCbQIM9uyXVK0TKn0S7ngWC5dGYuaPs,1003
-EMpy/constants.py,sha256=x1N8eRXQW_gdr1557n7tvUXiM4RW_Fc_EydLd5AUC1o,723
-EMpy/devices.py,sha256=OQLxSAKXafBgrbWd-WNcVTOkxdBhZ-UXsW7ukoIwaYA,37895
-EMpy/materials.py,sha256=r9SaTf4u3JBszGpVB-62VLhQp6SoQb78AsmrxLoTMkc,10687
-EMpy/scattering.py,sha256=1rY8_TI0kzTLYwpFSSXndaO9FzDzVPRVow55vzIDQiM,7339
-EMpy/transfer_matrix.py,sha256=Z3EK4MYsV5sUGTyXWieXVLg-18Wctm_3jR5LNS04r1k,14582
-EMpy/utils.py,sha256=o-XBTXtOVOff-us4Br2zP0u2PLJFqdsq28QxvoEpZrc,42008
-EMpy/version.py,sha256=d4pHXdSvDQjlx5mLFhqVvjzHBiA0Fow5fJ7IpFZUFeI,18
-EMpy/modesolvers/FD.py,sha256=DIZGfAfGTPJfD83VsTvIO0gcMjvw1dci23F9PK3okow,80097
-EMpy/modesolvers/FMM.py,sha256=FaIvg1aOsdM8pxdVNCBiqr4eTM-6oqPZPTxLanG3tXo,78366
-EMpy/modesolvers/__init__.py,sha256=bAFq4_6rPDV4RgFx6rct9ywRDLCt_pGhiVtgC6L9A_Y,221
-EMpy/modesolvers/geometries.py,sha256=hdxjVCCMQqo4p6fY51FTQPkQt3lKj7g96LCqOs58wyY,7895
-EMpy/modesolvers/interface.py,sha256=spMy30TFedYXJHcoV3yUdGkycGt5cplJUCeZui6a5MY,2397
-tests/__init__.py,sha256=XNMyfmlHhqih2xHEklXlmQ8GVUAdiiWrkT3trIOMpRQ,29
-tests/materials_test.py,sha256=v_UlUvPkiKqkkPNFywbTGTTO4eNnuk-itZPr5YIEUWw,1875
-tests/utils_test.py,sha256=Voe_Ph9LDDf47Vnt04hHLXoTPFGYXeRqzQDVkvPUVy8,597
-ElectroMagneticPython-2.2.1.dist-info/LICENSE,sha256=NlQFsrkwMvQ2aD8531IDm6Rk01KzlI42HVzK5M1Hpw8,1065
-ElectroMagneticPython-2.2.1.dist-info/METADATA,sha256=Bk8GnVNqdRF6iuFDVIRE_5XA-YqsEG0I8hBV4jVqgE8,2476
-ElectroMagneticPython-2.2.1.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
-ElectroMagneticPython-2.2.1.dist-info/top_level.txt,sha256=JCRI2zyREl3Lql3CyAFrqXFLGqMV0LqdsqQisk907AI,11
-ElectroMagneticPython-2.2.1.dist-info/RECORD,,

ElectroMagneticPython-2.2.1.dist-info/top_level.txt

@@ -1,2 +0,0 @@
-EMpy
-tests