Add tests and fix warnings

Author: lbolla

EMpy/modesolvers/FD.py

@@ -248,14 +248,14 @@ def build_matrix(self):
         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 = linag.eigs(  # type: ignore
             A, k=neigs, which="LR", tol=tol, ncv=10 * neigs, return_eigenvectors=True
         )
 
@@ -2038,7 +2038,7 @@ def solve(self, neigs=4, tol=0, guess=None):
             Ez = solver.modes[0].Ez
         """
 
-        from scipy.sparse.linalg import eigen
+        from scipy.sparse import linalg
 
         self.nmodes = neigs
         self.tol = tol
@@ -2053,7 +2053,7 @@ def solve(self, neigs=4, tol=0, guess=None):
             shift = None
 
         # Here is where the actual mode-solving takes place!
-        [eigvals, eigvecs] = eigen.eigs(
+        [eigvals, eigvecs] = linalg.eigs(
             A,
             k=neigs,
             which="LR",

EMpy/version.py

@@ -1 +1 @@
-version = "2.2.2.dev50"
+version = "2.2.2.dev54"

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 @@
 
 
 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/utils_test.py

@@ -1,26 +1,24 @@
-# 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)]