Finite-element mode solver

Finite-element mode solver#

You can mesh any component cross-section and solve the PDEs thanks to femwell mode - solver.

Unlike other mode solvers, this actually uses the component geometry instead of a hardcoded geometry.

You can directly compute the modes of a Gdsfactory cross-section (internally, it defines a “uz” mesh perpendicular to a straight component with the provided cross-section).

You can also downsample layers from the LayerStack, and modify both the cross-section and LayerStack prior to simulation to change the geometry. You can also define refractive indices on the active PDK.

import logging
import sys

import gdsfactory as gf
import matplotlib.pyplot as plt
import numpy as np
from gdsfactory.cross_section import rib
from gdsfactory.generic_tech import LAYER_STACK, get_generic_pdk
from gdsfactory.technology import LayerStack
from rich.logging import RichHandler
from tqdm.auto import tqdm

from gplugins.femwell.mode_solver import compute_cross_section_modes

gf.config.rich_output()
PDK = get_generic_pdk()
PDK.activate()

logger = logging.getLogger()
logger.removeHandler(sys.stderr)
logging.basicConfig(level="WARNING", datefmt="[%X]", handlers=[RichHandler()])

filtered_layer_stack = LayerStack(
    layers={
        k: LAYER_STACK.layers[k]
        for k in (
            "core",
            "clad",
            "slab90",
            "box",
            # "substrate",
        )
    }
)

filtered_layer_stack.layers["core"].thickness = (
    0.22  # Perturb the layer_stack before simulating
)

filtered_layer_stack.layers["slab90"].thickness = (
    0.09  # Perturb the layer_stack before simulating
)

resolutions = {
    "core": {"resolution": 0.02, "distance": 1, "SizeMax": 0.2},
    # "clad": {"resolution": 0.2, "distance": 1},
    # "box": {"resolution": 0.2, "distance": 1},
    # "slab90": {"resolution": 0.05, "distance": 1},
}

modes = compute_cross_section_modes(
    cross_section=rib(width=0.6),
    layer_stack=filtered_layer_stack,
    wavelength=1.55,
    num_modes=1,
    resolutions=resolutions,
    n_guess=2.630929889650573,
)

The solver returns the list of modes

mode = modes[0]
mode.show(mode.E.real, colorbar=True, direction="x")

You can use them as inputs to other femwell mode solver functions to inspect or analyze the modes:

print(modes[0].te_fraction)

print(modes[0].n_eff)

Sweep waveguide width#

widths = np.linspace(0.2, 2, 10)
num_modes = 4
all_neffs = np.zeros((widths.shape[0], num_modes))
all_te_fracs = np.zeros((widths.shape[0], num_modes))


for i, width in enumerate(tqdm(widths)):
    modes = compute_cross_section_modes(
        cross_section=gf.cross_section.strip(width=width),
        layer_stack=filtered_layer_stack,
        wavelength=1.55,
        num_modes=num_modes,
        resolutions=resolutions,
        wafer_padding=2,
        solver="scipy",
    )
    all_neffs[i] = np.real([mode.n_eff for mode in modes])
    all_te_fracs[i, :] = [mode.te_fraction for mode in modes]

all_neffs = np.real(all_neffs)
plt.xlabel("Width of waveguide  µm")
plt.ylabel("Effective refractive index")
plt.ylim(1.444, np.max(all_neffs) + 0.1 * (np.max(all_neffs) - 1.444))
for lams, te_fracs in zip(all_neffs.T, all_te_fracs.T):
    plt.plot(widths, lams, c="k")
    plt.scatter(widths, lams, c=te_fracs, cmap="cool")
plt.colorbar().set_label("TE fraction")
Contents