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

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()

examples/ex_laser_etch_monitor.py

@@ -0,0 +1,241 @@
+# -*- coding: utf-8 -*-
+"""
+Transfer matrix example: Laser Etch Monitor/End-point detection.
+Built for Electromagnetic Python by Lorenzo Bolla:
+http://lbolla.github.io/EMpy/
+
+Simulate a laser etch monitor (aka. laser endpoint detection):
+    Calculate the reflectivity of a thin-film stack as the stack is
+    progressively thinned by etching from one side. Finally, plot
+    reflectivity vs. etch depth at a single wavelength, as is often
+    used to determine end-points during reactive ion/plasma etching.
+    For more info, see Oxford Plasma's page on the technique:
+        http://www.oxfordplasma.de/technols/li.htm
+
+    Requires file `nk.py` for wavelength-dependent refractive index/loss models.
+
+    Author: Demis D. John, March 2017 (demis.john@gmail.com)
+"""
+
+from copy import copy, deepcopy
+import sys
+
+from matplotlib import pyplot as plt
+import numpy
+
+import EMpy
+
+# file of refractive indices, takes wavelengths in Microns!!
+import nk
+
+# Simulation Parameters
+# laser monitor wavelength
+wl_lasermon = 670e-9
+# how much to etch before acquiring new laser monitor reflectivity
+EtchStep = 10e-9
+
+wls = numpy.array([wl_lasermon - 1e-9, wl_lasermon, wl_lasermon + 1e-9])
+theta_inc = EMpy.utils.deg2rad(0)  # incidence angle
+
+
+# Define some helper functions
+
+
+def find_nearest(a, a0):
+    """Return element in ndArray `a` that has value closest to the
+    scalar value `a0`."""
+    idx = numpy.abs(a - a0).argmin()
+    return a.flat[idx]
+
+
+def arg_find_nearest(a, a0):
+    """Return index to element in ndArray `a` that has value closest
+    to the scalar value `a0`."""
+    idx = numpy.abs(a - a0).argmin()
+    return idx
+
+
+def count_noninf(multilayer):
+    """Return number of non-infinite layers in an EMpy Multilayer
+    object."""
+    out = 0
+    for x in multilayer:
+        out = out + 0 if numpy.isinf(x.thickness) else out + 1
+    return out
+
+
+def arg_inf(multilayer):
+    """Return index to layers with infinite-thickness in an EMpy Multilayer object."""
+    out = []
+    for ix, x in enumerate(multilayer):
+        if numpy.isinf(x.thickness):
+            out.append(ix)
+    return out
+
+
+# Define some materials
+
+# Define RefractiveIndex functions, then Material objects.
+n_air = 1.0  # constant vs. wavelength
+mat_air = EMpy.materials.IsotropicMaterial(
+    "air", EMpy.materials.RefractiveIndex(n0_const=n_air)
+)
+
+n_SiN = 1.997  # Silicon Nitride (Si3N4)
+mat_SiN = EMpy.materials.IsotropicMaterial(
+    "Si3N4", EMpy.materials.RefractiveIndex(n0_const=n_SiN)
+)
+
+
+# RIX functions from file, taking wavelength in microns:
+# Covert to microns, request loss as complex refractive index
+def n_GaAs(w):
+    return nk.GaAs_interp(w * 1e6, k=True)
+
+
+mat_GaAs = EMpy.materials.IsotropicMaterial(
+    "GaAs", EMpy.materials.RefractiveIndex(n0_func=n_GaAs)
+)
+
+
+# Function from file, AlGaAs with 95% Aluminum
+def n_AlGaAs95(w):
+    return nk.AlGaAs_interp(0.95, w * 1e6, k=True)
+
+
+mat_AlGaAs95 = EMpy.materials.IsotropicMaterial(
+    "Al95Ga05As", EMpy.materials.RefractiveIndex(n0_func=n_AlGaAs95)
+)
+
+
+# DBR mirror periods, at 1/4-wavelength thicknesses
+wl_center = 1100e-9
+d_GaAs_DBR = wl_center / n_GaAs(wl_center)[0].real / 4
+d_AlGaAs_DBR = wl_center / n_AlGaAs95(wl_center)[0].real / 4
+
+
+# Build the Multilayer stack
+# Build from top to bottom - ie. topmost layer (closest to laser
+# monitor) first, substrate last.  Must include infinite-thickness
+# layers on top & bottom for air & substrate, respectively.
+
+Layer = EMpy.utils.Layer  # shortcut
+
+# define the layers (material, thickness) we will use in the stack:
+air = Layer(mat_air, numpy.inf)
+SiN = Layer(mat_SiN, 300e-9)
+GaAs_DBR = Layer(mat_GaAs, d_GaAs_DBR)
+AlGaAs_DBR = Layer(mat_AlGaAs95, d_AlGaAs_DBR)
+GaAs_core = Layer(mat_GaAs, 551.75e-9)
+AlGaAs_spacer = Layer(mat_AlGaAs95, 500e-9)
+GaAs_spacer = Layer(mat_GaAs, 300e-9)
+GaAs_substrate = Layer(mat_GaAs, numpy.inf)
+
+# Use lists to enable periodic structures etc.
+#   Make sure to include infinite-thickness layers on ends
+layers_ = (
+    [air]
+    + [SiN]
+    + 5 * [GaAs_DBR, AlGaAs_DBR]
+    + [GaAs_core]
+    + 5 * [AlGaAs_DBR, GaAs_DBR]
+    + [AlGaAs_spacer]
+    + [GaAs_spacer]
+    + [GaAs_substrate]
+)
+
+# Create EMpy MultiLayer stack.
+#   Must dereference the lists from each other via copy(), otherwise altering
+#   one layer during etching also affects other repeated Layers
+layers = EMpy.utils.Multilayer([copy(l) for l in layers_])
+
+
+# setup etching loop
+EtchStep_current = EtchStep  # how much left to etch in current loop iteration
+go = True  # while loop switch
+i = -1  # while loop counter
+etchedlayers = []  # save stacks of etched layers
+solutions = []  # IsotropicTransferMatrix object storing R/T solutions
+EtchSteps = []  # x-axis data
+Rlaser = []  # y-axis data - reflectivity
+RefrIdx = []  # y-axis data - refractive index
+# get index to laser-monitor wavelength in `wls` array
+wlidx = arg_find_nearest(wls, wl_lasermon)
+# 0 if etching away from first layer in list, -1 if etching from last
+# layer appended
+idxtemp = 0
+
+print("Etching...")
+while go is True:
+    # keep reducing thickness/removing layers until last layer is too thin
+    i = i + 1
+
+    # print a small progress bar
+    sys.stdout.write(".")
+    sys.stdout.flush()
+
+    if count_noninf(layers) > 0:
+        # at least one infinite-thickness layer should still be left
+
+        if i <= 0:
+            # first iteration: analyze unetched structure
+            EtchStep_current = 0.0
+            indexno = idxtemp
+        else:
+            # point to non-infinite layers for etching:
+            while numpy.isinf(layers[idxtemp].thickness):
+                idxtemp = idxtemp + 1  # assumes etching from 1st layer in list
+            indexno = idxtemp
+
+        if layers[indexno].thickness <= EtchStep_current:
+            # next layer is thinner than etch step
+            # Reduce etch step + remove this layer:
+            EtchStep_current = EtchStep_current - layers[indexno].thickness
+            layers.pop(indexno)
+
+        elif layers[indexno].thickness > EtchStep_current:
+            # etch increment ends within next layer
+            # reduce layer thickness & solve & save data points:
+            layers[indexno].thickness = layers[indexno].thickness - EtchStep_current
+            # add this layer stack to the list
+            etchedlayers.append(deepcopy(layers))
+            # get RefrIndex in this layer
+            RefrIdx.append(etchedlayers[-1][idxtemp].mat.n(wl_lasermon).real)
+            if i <= 0:
+                # for 1st iteration: unetched layer
+                EtchSteps.append(0.0)
+            else:
+                EtchSteps.append(EtchSteps[-1] + EtchStep)  # Add x-axis point
+                EtchStep_current = EtchStep  # reset EtchStep_current
+
+            # solve for reflectivity at laser monitor wavelength
+            solutions.append(
+                EMpy.transfer_matrix.IsotropicTransferMatrix(
+                    etchedlayers[-1], theta_inc
+                ).solve(wls)
+            )
+            Rlaser.append(solutions[-1].Rs[wlidx])
+    else:
+        # No non-infinte layers left, end the loop
+        go = False
+
+print("\n")
+
+
+# Plots:
+fig1, [ax1, ax2] = plt.subplots(nrows=2, ncols=1, sharex=True)
+ax1.set_title(r"Reflectivity at $\lambda = %0.1fnm$" % (wls[wlidx] * 1e9))
+
+# plot refractive index vs. depth
+ax1.plot(numpy.array(EtchSteps) * 1e9, RefrIdx, "-g")
+ax1.set_ylabel("Refractive Index")
+ax1.grid(True)
+
+# plot reflectivity vs. depth
+ax2.plot(numpy.array(EtchSteps) * 1e9, numpy.array(Rlaser) * 100, "-")
+ax2.set_ylabel("Laser Reflectivity (%)")
+ax2.set_xlabel("Etch Depth (nm)")
+ax2.grid(True)
+
+fig1.show()
+plt.show()

examples/ex_modesolver.py

@@ -0,0 +1,68 @@
+"""Fully vectorial finite-difference mode solver example."""
+
+from matplotlib import pyplot as plt
+import numpy
+
+import EMpy
+
+
+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,
+    )
+
+
+wl = 1.55e-6
+x = numpy.linspace(0, 2.48e-6, 125)
+y = numpy.linspace(0, 2.22e-6, 112)
+
+neigs = 2
+tol = 1e-8
+boundary = "0000"
+
+solver = EMpy.modesolvers.FD.VFDModeSolver(wl, x, y, epsfunc, boundary).solve(
+    neigs, tol
+)
+
+fig = plt.figure()
+
+fig.add_subplot(1, 3, 1)
+Ex = numpy.transpose(solver.modes[0].get_field("Ex", x, y))
+plt.contourf(x, y, abs(Ex), 50)
+plt.title("Ex")
+
+fig.add_subplot(1, 3, 2)
+Ey = numpy.transpose(solver.modes[0].get_field("Ey", x, y))
+plt.contourf(x, y, abs(Ey), 50)
+plt.title("Ey")
+
+fig.add_subplot(1, 3, 3)
+Ez = numpy.transpose(solver.modes[0].get_field("Ez", x, y))
+plt.contourf(x, y, abs(Ez), 50)
+plt.title("Ez")
+
+fig.add_subplot(1, 3, 1)
+Hx = numpy.transpose(solver.modes[0].get_field("Hx", x, y))
+plt.contourf(x, y, abs(Hx), 50)
+plt.title("Hx")
+
+fig.add_subplot(1, 3, 2)
+Hy = numpy.transpose(solver.modes[0].get_field("Hy", x, y))
+plt.contourf(x, y, abs(Hy), 50)
+plt.title("Hy")
+
+fig.add_subplot(1, 3, 3)
+Hz = numpy.transpose(solver.modes[0].get_field("Hz", x, y))
+plt.contourf(x, y, abs(Hz), 50)
+plt.title("Hz")
+
+plt.show()

examples/ex_modesolver_2.py

@@ -0,0 +1,58 @@
+"""Fully vectorial finite-difference mode solver example."""
+
+from matplotlib import pyplot as plt
+
+import EMpy
+
+mat1 = EMpy.materials.IsotropicMaterial(
+    "SiN", n0=EMpy.materials.RefractiveIndex(n0_const=1.97)
+)
+mat2 = EMpy.materials.IsotropicMaterial(
+    "Si", n0=EMpy.materials.RefractiveIndex(n0_const=3.4757)
+)
+
+l1 = EMpy.utils.Layer(mat1, 4.1e-6)
+l21 = EMpy.utils.Layer(mat1, 2e-6)
+l22 = EMpy.utils.Layer(mat2, 0.1e-6)
+
+w = 0.5e-6
+
+d = EMpy.utils.EMpy.utils.CrossSection(
+    [
+        EMpy.utils.Slice(2e-6, [l1]),
+        EMpy.utils.Slice(w, [l21, l22, l21]),
+        EMpy.utils.Slice(2e-6, [l1]),
+    ]
+)
+
+nx_points_per_region = (20, 10, 20)
+ny_points_per_region = (20, 20, 20)
+
+X, Y = d.grid(nx_points_per_region, ny_points_per_region)
+eps = d.epsfunc(X, Y, 1.55e-6)
+
+
+def epsfunc(x, y):
+    return d.epsfunc(x, y, wl)
+
+
+wl = 1.55e-6
+
+neigs = 2
+tol = 1e-8
+boundary = "0000"
+
+solver = EMpy.modesolvers.FD.VFDModeSolver(wl, X, Y, epsfunc, boundary).solve(
+    neigs, tol
+)
+fig = plt.figure()
+fig.add_subplot(1, 3, 1)
+plt.contourf(abs(solver.modes[0].Ex), 50)
+plt.title("Ex")
+fig.add_subplot(1, 3, 2)
+plt.contourf(abs(solver.modes[0].Ey), 50)
+plt.title("Ey")
+fig.add_subplot(1, 3, 3)
+plt.contourf(abs(solver.modes[0].Ez), 50)
+plt.title("Ez")
+plt.show()

examples/ex_modesolver_3.py

@@ -0,0 +1,48 @@
+"""Fully vectorial finite-difference mode solver example."""
+
+from matplotlib import pyplot as plt
+import numpy
+
+import EMpy
+
+
+def epsfunc(x_, y_):
+    """Similar to ex_modesolver.py, but using anisotropic eps."""
+    eps = numpy.zeros((len(x_), len(y_), 5))
+    for ix, xx in enumerate(x_):
+        for iy, yy in enumerate(y_):
+            if abs(xx - 1.24e-6) <= 0.24e-6 and abs(yy - 1.11e-6) <= 0.11e-6:
+                a = 3.4757**2
+                b = 1  # some xy value
+                # eps_xx, xy, yx, yy, zz
+                eps[ix, iy, :] = [a, b, b, a, a]
+            else:
+                a = 1.446**2
+                # isotropic
+                eps[ix, iy, :] = [a, 0, 0, a, a]
+    return eps
+
+
+wl = 1.55e-6
+x = numpy.linspace(0, 2.48e-6, 125)
+y = numpy.linspace(0, 2.22e-6, 112)
+
+neigs = 2
+tol = 1e-8
+boundary = "0000"
+
+solver = EMpy.modesolvers.FD.VFDModeSolver(wl, x, y, epsfunc, boundary).solve(
+    neigs, tol
+)
+
+fig = plt.figure()
+fig.add_subplot(1, 3, 1)
+plt.contourf(abs(solver.modes[0].Ex), 50)
+plt.title("Ex")
+fig.add_subplot(1, 3, 2)
+plt.contourf(abs(solver.modes[0].Ey), 50)
+plt.title("Ey")
+fig.add_subplot(1, 3, 3)
+plt.contourf(abs(solver.modes[0].Ez), 50)
+plt.title("Ez")
+plt.show()

examples/ex_modesolver_4.py

@@ -0,0 +1,43 @@
+"""Semi-vectorial finite-difference mode solver example."""
+
+from matplotlib import pyplot as plt
+import numpy
+
+import EMpy
+
+
+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,
+    )
+
+
+wl = 1.55e-6
+x = numpy.linspace(0, 2.48e-6, 125)
+y = numpy.linspace(0, 2.22e-6, 112)
+
+neigs = 2
+tol = 1e-8
+boundary = "0000"
+
+solver = EMpy.modesolvers.FD.SVFDModeSolver(wl, x, y, epsfunc, boundary).solve(
+    neigs, tol
+)
+
+fig = plt.figure()
+fig.add_subplot(1, 2, 1)
+plt.contourf(abs(solver.Ex[0]), 50)
+plt.title("Ex first mode")
+fig.add_subplot(1, 2, 2)
+plt.contourf(abs(solver.Ex[1]), 50)
+plt.title("Ex second mode")
+plt.show()