gplugins 2.1.0__tar.gz → 2.1.2__tar.gz

{gplugins-2.1.0 → gplugins-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: gplugins
-Version: 2.1.0
+Version: 2.1.2
 Summary: gdsfactory plugins
 Keywords: python
 Author-email: gdsfactory <contact@gdsfactory.com>
@@ -17,23 +17,28 @@ Requires-Dist: tqdm
 Requires-Dist: numpy>=2.0,<3
 Requires-Dist: xarray==2026.4.0
 Requires-Dist: hypothesis ; extra == "dev"
-Requires-Dist: numba ; extra == "dev"
+Requires-Dist: numba>=0.60 ; extra == "dev"
 Requires-Dist: pre-commit ; extra == "dev"
 Requires-Dist: pyswarms ; extra == "dev"
 Requires-Dist: pytest ; extra == "dev"
 Requires-Dist: pytest-cov ; extra == "dev"
 Requires-Dist: pytest_regressions ; extra == "dev"
 Requires-Dist: devsim ; extra == "devsim"
-Requires-Dist: pyvista<=0.48.2 ; extra == "devsim"
+Requires-Dist: pyvista<=0.48.4 ; extra == "devsim"
 Requires-Dist: tidy3d~=2.11.1 ; extra == "devsim"
+Requires-Dist: jupyter ; extra == "docs"
 Requires-Dist: jupytext ; extra == "docs"
 Requires-Dist: matplotlib ; extra == "docs"
-Requires-Dist: jupyter-book>=1,<3 ; extra == "docs"
-Requires-Dist: pyvista[all]<=0.48.2 ; extra == "docs"
+Requires-Dist: nbconvert ; extra == "docs"
+Requires-Dist: mkdocstrings[python] ; extra == "docs"
+Requires-Dist: mkdocs-bibtex ; extra == "docs"
+Requires-Dist: pyvista[all]<=0.48.4 ; extra == "docs"
 Requires-Dist: bokeh ; extra == "docs"
 Requires-Dist: scikit-learn ; extra == "docs"
+Requires-Dist: zensical>=0.0.46,<0.1.0 ; extra == "docs"
+Requires-Dist: emodeconnection>=1.1.11 ; extra == "emode"
 Requires-Dist: femwell~=0.1.11 ; extra == "femwell"
-Requires-Dist: meshwell~=2.1.1 ; extra == "femwell"
+Requires-Dist: meshwell~=2.1.2 ; extra == "femwell"
 Requires-Dist: jinja2 ; extra == "gfviz"
 Requires-Dist: fastapi ; extra == "gfviz"
 Requires-Dist: shapely ; extra == "gfviz"
@@ -49,14 +54,14 @@ Requires-Dist: mypy ; extra == "maintainer"
 Requires-Dist: tbump ; extra == "maintainer"
 Requires-Dist: towncrier ; extra == "maintainer"
 Requires-Dist: meow-sim>=0.15 ; extra == "meow"
-Requires-Dist: sax~=0.17.0 ; extra == "meow"
+Requires-Dist: sax>=0.17,<0.19 ; extra == "meow"
 Requires-Dist: tidy3d~=2.11.1 ; extra == "meow"
 Requires-Dist: shapely ; extra == "meshwell"
-Requires-Dist: meshwell~=2.1.1 ; extra == "meshwell"
+Requires-Dist: meshwell~=2.1.2 ; extra == "meshwell"
 Requires-Dist: bokeh ; extra == "path-length-analysis"
-Requires-Dist: numba ; extra == "path-length-analysis"
+Requires-Dist: numba>=0.60 ; extra == "path-length-analysis"
 Requires-Dist: shapely ; extra == "path-length-analysis"
-Requires-Dist: sax~=0.17.0 ; extra == "sax"
+Requires-Dist: sax>=0.17,<0.19 ; extra == "sax"
 Requires-Dist: bokeh ; extra == "schematic"
 Requires-Dist: ipywidgets ; extra == "schematic"
 Requires-Dist: natsort ; extra == "schematic"
@@ -68,6 +73,7 @@ Requires-Dist: vlsirtools ; extra == "vlsir"
 Provides-Extra: dev
 Provides-Extra: devsim
 Provides-Extra: docs
+Provides-Extra: emode
 Provides-Extra: femwell
 Provides-Extra: gfviz
 Provides-Extra: klayout
@@ -80,8 +86,9 @@ Provides-Extra: sax
 Provides-Extra: schematic
 Provides-Extra: tidy3d
 Provides-Extra: vlsir
+Import-Name: gplugins
 
-# gplugins 2.1.0
+# gplugins 2.1.2
 
 [![docs](https://github.com/gdsfactory/gplugins/actions/workflows/pages.yml/badge.svg)](https://gdsfactory.github.io/gplugins/)
 [![PyPI](https://img.shields.io/pypi/v/gplugins)](https://pypi.org/project/gplugins/)
@@ -111,6 +118,7 @@ Run simulations with GDSFactory by installing plugins.
         - Tidy3d
         - Femwell
         - MPB
+        - `EMode` Finite Difference Method (FDM) mode solver with EME propagation (commercial).
     - TCAD
         - `devsim` TCAD device simulator.
 - Circuit simulations

{gplugins-2.1.0 → gplugins-2.1.2}/README.md

@@ -1,4 +1,4 @@
-# gplugins 2.1.0
+# gplugins 2.1.2
 
 [![docs](https://github.com/gdsfactory/gplugins/actions/workflows/pages.yml/badge.svg)](https://gdsfactory.github.io/gplugins/)
 [![PyPI](https://img.shields.io/pypi/v/gplugins)](https://pypi.org/project/gplugins/)
@@ -28,6 +28,7 @@ Run simulations with GDSFactory by installing plugins.
         - Tidy3d
         - Femwell
         - MPB
+        - `EMode` Finite Difference Method (FDM) mode solver with EME propagation (commercial).
     - TCAD
         - `devsim` TCAD device simulator.
 - Circuit simulations

{gplugins-2.1.0 → gplugins-2.1.2}/gplugins/__init__.py

@@ -1,6 +1,6 @@
 """gplugins - gdsfactory plugins."""
 
-__version__ = "2.1.0"
+__version__ = "2.1.2"
 
 import pathlib
 

{gplugins-2.1.0 → gplugins-2.1.2}/gplugins/common/utils/tests/test_get_component_with_new_port_layers.py

@@ -1,5 +1,5 @@
 from gdsfactory.components import straight_heater_metal
-from gdsfactory.generic_tech import LAYER_STACK
+from gdsfactory.gpdk import LAYER_STACK
 
 from gplugins.common.utils.get_component_with_net_layers import (
     get_component_layer_stack,

{gplugins-2.1.0 → gplugins-2.1.2}/gplugins/devsim/doping.py

@@ -1,7 +1,7 @@
 from collections.abc import Callable
 
 import numpy as np
-from gdsfactory.generic_tech import LAYER
+from gdsfactory.gpdk import LAYER
 from gdsfactory.typings import Layer
 from pydantic import BaseModel, ConfigDict
 

{gplugins-2.1.0 → gplugins-2.1.2}/gplugins/devsim/get_simulation.py

@@ -230,7 +230,7 @@ def create_2Duz_simulation(
 
 if __name__ == "__main__":
     import gdsfactory as gf
-    from gdsfactory.generic_tech import LAYER, LAYER_STACK
+    from gdsfactory.gpdk import LAYER, LAYER_STACK
 
     # We choose a representative subdomain of the component
     waveguide = gf.Component()

{gplugins-2.1.0 → gplugins-2.1.2}/gplugins/elmer/get_capacitance.py

@@ -11,7 +11,7 @@ from typing import Any
 
 import gdsfactory as gf
 import gmsh
-from gdsfactory.generic_tech import LAYER_STACK
+from gdsfactory.gpdk import LAYER_STACK
 from gdsfactory.technology import LayerStack
 from jinja2 import Environment, FileSystemLoader
 from numpy import isfinite

{gplugins-2.1.0 → gplugins-2.1.2}/gplugins/elmer/tests/test_elmer.py

@@ -4,7 +4,7 @@ import gdsfactory as gf
 import pytest
 from gdsfactory.component import Component
 from gdsfactory.components import interdigital_capacitor_enclosed
-from gdsfactory.generic_tech import LAYER
+from gdsfactory.gpdk import LAYER
 from gdsfactory.technology import LayerStack
 from gdsfactory.technology.layer_stack import LayerLevel
 

gplugins-2.1.2/gplugins/emode/__init__.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from gplugins.emode.emode import (
+    EMode,
+    get_emode_settings,
+    get_shapes_from_layer_stack,
+)
+
+__all__ = [
+    "EMode",
+    "get_emode_settings",
+    "get_shapes_from_layer_stack",
+]

gplugins-2.1.2/gplugins/emode/emode.py

@@ -0,0 +1,244 @@
+"""gdsfactory interface to EMode Photonix.
+
+EMode is a commercial photonic simulation package with an electromagnetic
+waveguide mode solver (FDM), eigenmode expansion propagation (EME), nonlinear
+photonics, and thermal/electrical FEM solvers.
+See https://docs.emodephotonix.com for the full API.
+
+This module translates gdsfactory objects (:class:`~gdsfactory.CrossSection`,
+:class:`~gdsfactory.technology.LayerStack`) into EMode geometry. The
+translation itself is implemented as pure functions
+(:func:`get_emode_settings`, :func:`get_shapes_from_layer_stack`) that only
+require the pip-installable ``emodeconnection`` client. Creating an
+:class:`EMode` session and running solvers requires a local EMode installation
+and license.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+import emodeconnection as emc
+import gdsfactory as gf
+from gdsfactory.technology import LayerLevel, LayerStack
+from gdsfactory.typings import CrossSectionSpec, LayerSpec
+
+UM_TO_NM = 1e3
+
+DIMENSIONAL_SETTINGS = frozenset(
+    {
+        "wavelength",
+        "x_resolution",
+        "y_resolution",
+        "window_width",
+        "window_height",
+        "bend_radius",
+        "expansion_resolution",
+        "expansion_size",
+        "propagation_resolution",
+    }
+)
+
+
+def get_emode_settings(**settings: Any) -> dict[str, Any]:
+    """Convert gdsfactory-style settings to EMode units.
+
+    gdsfactory uses microns for all dimensions while EMode defaults to
+    nanometers. Settings named in ``DIMENSIONAL_SETTINGS`` are converted from
+    um to nm; all other settings pass through unchanged.
+
+    Args:
+        settings: keyword arguments for EMode's ``settings()`` function,
+            with dimensional values in um.
+
+    Returns:
+        The same settings with dimensional values converted to nm.
+    """
+    return {
+        key: value * UM_TO_NM
+        if key in DIMENSIONAL_SETTINGS and value is not None
+        else value
+        for key, value in settings.items()
+    }
+
+
+def get_emode_material(material: str, materials: Sequence[str]) -> str:
+    """Match a gdsfactory material name to the EMode material database.
+
+    Matching is case-insensitive (e.g. gdsfactory's ``si`` matches EMode's
+    ``Si``). If no match is found the name is returned unchanged so EMode can
+    report an informative error for genuinely unknown materials.
+
+    Args:
+        material: gdsfactory material name.
+        materials: available EMode material names, from ``EMode.get('materials')``.
+    """
+    return next((m for m in materials if m.lower() == material.lower()), material)
+
+
+def _layer_tuple(layer: LayerSpec) -> tuple[int, int] | None:
+    """Resolve a layer spec to a (layer, datatype) tuple via the active PDK.
+
+    Returns None for layers that cannot be resolved to a single GDS layer
+    (e.g. unresolved DerivedLayer expressions).
+    """
+    # LogicalLayer and DerivedLayer wrap the underlying spec in .layer.
+    layer = getattr(layer, "layer", layer)
+    try:
+        return gf.get_layer_tuple(layer)
+    except (KeyError, TypeError, ValueError):
+        return None
+
+
+def _level_layer_tuple(level: LayerLevel) -> tuple[int, int] | None:
+    """Resolve a layer level to a (layer, datatype) tuple.
+
+    The derived layer takes precedence over the source layer, since it is the
+    physically meaningful output of a derived-layer boolean operation.
+    """
+    return _layer_tuple(level.derived_layer or level.layer)
+
+
+def get_shapes_from_layer_stack(
+    cross_section: CrossSectionSpec,
+    layer_stack: LayerStack,
+    materials: Sequence[str] = (),
+) -> list[dict[str, Any]]:
+    """Translate a gdsfactory layer stack and cross-section into EMode shapes.
+
+    Each :class:`~gdsfactory.technology.LayerLevel` becomes one EMode shape.
+    A layer whose ``layer`` (or ``derived_layer``) matches a section of the
+    cross-section is patterned: it takes its mask width and offset from that
+    section and is etched through its full thickness. Layers without a
+    matching section become blanket layers (no mask or etch, following the
+    defaults of EMode's ``shape()`` function). Vertical positions are
+    referenced to the bottom of the layer stack, and gdsfactory mesh order
+    (lower = higher priority) is converted to EMode shape priority (higher =
+    higher priority).
+
+    Args:
+        cross_section: gdsfactory cross-section (or spec) defining mask
+            widths and offsets.
+        layer_stack: gdsfactory LayerStack defining layer materials,
+            thicknesses, and vertical placement.
+        materials: available EMode material names used to match gdsfactory
+            material names case-insensitively, typically from
+            ``EMode.get('materials')``.
+
+    Returns:
+        One dict of keyword arguments for EMode's ``shape()`` function per
+        layer, in layer-stack order, with dimensions in nm.
+    """
+    if not layer_stack.layers:
+        raise ValueError("layer_stack must contain at least one layer.")
+
+    xs = gf.get_cross_section(cross_section)
+
+    max_order = max(level.mesh_order for level in layer_stack.layers.values())
+    min_zmin = min(level.zmin for level in layer_stack.layers.values())
+
+    shapes: list[dict[str, Any]] = []
+    for name, level in layer_stack.layers.items():
+        if level.material is None:
+            raise ValueError(
+                f"Layer {name!r} has no material defined in the layer stack."
+            )
+
+        shape: dict[str, Any] = {
+            "name": name,
+            "material": get_emode_material(level.material, materials),
+            "height": level.thickness * UM_TO_NM,
+            "sidewall_angle": level.sidewall_angle,
+            "position": [0.0, (level.zmin - min_zmin + level.thickness / 2) * UM_TO_NM],
+            "priority": max_order - level.mesh_order + 1,
+        }
+
+        level_layer = _level_layer_tuple(level)
+        section = next(
+            (
+                s
+                for s in xs.sections
+                if level_layer is not None and _layer_tuple(s.layer) == level_layer
+            ),
+            None,
+        )
+        if section is not None:
+            shape["mask"] = section.width * UM_TO_NM
+            shape["mask_offset"] = section.offset * UM_TO_NM
+            shape["etch_depth"] = level.thickness * UM_TO_NM
+
+        shapes.append(shape)
+
+    return shapes
+
+
+class EMode(emc.EMode):
+    """EMode session with gdsfactory geometry helpers.
+
+    Creating an instance launches the EMode application and connects to it,
+    so it requires a local EMode installation and license (the
+    ``emodeconnection`` client alone is not enough). Any EMode function can
+    be called as a method, e.g. ``FDM()``, ``EME()``, ``report()``,
+    ``plot()``; see https://docs.emodephotonix.com for the full API.
+    """
+
+    def build_waveguide(
+        self,
+        cross_section: CrossSectionSpec,
+        layer_stack: LayerStack,
+        **settings: Any,
+    ) -> None:
+        """Build a waveguide in this EMode session from gdsfactory geometry.
+
+        Args:
+            cross_section: gdsfactory cross-section (or spec) defining mask
+                widths and offsets.
+            layer_stack: gdsfactory LayerStack defining layer materials,
+                thicknesses, and vertical placement.
+            settings: forwarded to EMode's ``settings()`` function, with
+                dimensional values in um (see :func:`get_emode_settings`).
+        """
+        self.settings(**get_emode_settings(**settings))
+        materials = self.get("materials")
+        for shape in get_shapes_from_layer_stack(cross_section, layer_stack, materials):
+            self.shape(**shape)
+
+
+if __name__ == "__main__":
+    # Silicon-on-insulator rib waveguide example.
+    # Requires a local EMode installation and license.
+    from gdsfactory.gpdk import LAYER_STACK
+
+    layer_stack = LayerStack(
+        layers={
+            k: LAYER_STACK.layers[k].model_copy()
+            for k in ("core", "clad", "slab90", "box")
+        }
+    )
+    layer_stack.layers["core"].thickness = 0.22
+    layer_stack.layers["core"].zmin = 0.0
+    layer_stack.layers["slab90"].thickness = 0.09
+    layer_stack.layers["slab90"].zmin = 0.0
+    layer_stack.layers["box"].thickness = 1.5
+    layer_stack.layers["box"].zmin = -1.5
+    layer_stack.layers["clad"].thickness = 1.5
+    layer_stack.layers["clad"].zmin = 0.0
+
+    em = EMode()
+    em.build_waveguide(
+        cross_section=gf.cross_section.rib(width=0.6),
+        layer_stack=layer_stack,
+        wavelength=1.55,
+        num_modes=1,
+        x_resolution=0.010,
+        y_resolution=0.010,
+        window_width=3.0,
+        window_height=3.0,
+        background_material="Air",
+        max_effective_index=2.631,
+    )
+    em.FDM()
+    em.report()
+    em.plot()
+    em.close()

gplugins-2.1.2/gplugins/emode/tests/test_emode.py

@@ -0,0 +1,218 @@
+"""CI-safe tests for the EMode plugin.
+
+These tests only require the pip-installable ``emodeconnection`` client. They
+exercise the pure gdsfactory-to-EMode translation functions and use a stub
+session to test ``EMode.build_waveguide`` without launching the EMode
+application (which requires a separate installation and license).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+
+pytest.importorskip("emodeconnection")
+
+import gdsfactory as gf
+from gdsfactory.gpdk import LAYER_STACK
+from gdsfactory.technology import LayerStack
+
+from gplugins.emode import (
+    EMode,
+    get_emode_settings,
+    get_shapes_from_layer_stack,
+)
+from gplugins.emode.emode import DIMENSIONAL_SETTINGS, get_emode_material
+
+EMODE_MATERIALS = ["Air", "Si", "SiO2", "Si3N4"]
+
+
+@pytest.fixture
+def layer_stack() -> LayerStack:
+    """Silicon-on-insulator rib stack with pinned dimensions and mesh orders."""
+    updates = {
+        "core": {"thickness": 0.22, "zmin": 0.0, "mesh_order": 1},
+        "slab90": {"thickness": 0.09, "zmin": 0.0, "mesh_order": 2},
+        "clad": {"thickness": 1.5, "zmin": 0.0, "mesh_order": 9},
+        "box": {"thickness": 1.5, "zmin": -1.5, "mesh_order": 8},
+    }
+    return LayerStack(
+        layers={
+            name: LAYER_STACK.layers[name].model_copy(update=update)
+            for name, update in updates.items()
+        }
+    )
+
+
+class FakeEMode(EMode):
+    """EMode session that records calls instead of launching the application."""
+
+    def __init__(self) -> None:
+        """Initialize without calling super().__init__, which launches the app."""
+        self.recorded_settings: list[dict[str, Any]] = []
+        self.recorded_shapes: list[dict[str, Any]] = []
+
+    def settings(self, **kwargs: Any) -> None:
+        self.recorded_settings.append(kwargs)
+
+    def shape(self, **kwargs: Any) -> None:
+        self.recorded_shapes.append(kwargs)
+
+    def get(self, key: str) -> list[str]:
+        assert key == "materials"
+        return list(EMODE_MATERIALS)
+
+
+def test_get_emode_settings_converts_dimensional_values() -> None:
+    settings = get_emode_settings(
+        wavelength=1.55,
+        window_width=3.0,
+        num_modes=2,
+        background_material="Air",
+    )
+    assert settings["wavelength"] == pytest.approx(1550.0)
+    assert settings["window_width"] == pytest.approx(3000.0)
+    assert settings["num_modes"] == 2
+    assert settings["background_material"] == "Air"
+
+
+def test_get_emode_settings_passes_none_through() -> None:
+    settings = get_emode_settings(wavelength=1.55, bend_radius=None)
+    assert settings["wavelength"] == pytest.approx(1550.0)
+    assert settings["bend_radius"] is None
+
+
+@pytest.mark.parametrize("key", sorted(DIMENSIONAL_SETTINGS))
+def test_get_emode_settings_converts_every_dimensional_key(key: str) -> None:
+    settings = get_emode_settings(**{key: 1.0})
+    assert settings[key] == pytest.approx(1000.0)
+
+
+def test_get_emode_material_matches_case_insensitively() -> None:
+    assert get_emode_material("si", EMODE_MATERIALS) == "Si"
+    assert get_emode_material("SIO2", EMODE_MATERIALS) == "SiO2"
+    assert get_emode_material("unknown_material", EMODE_MATERIALS) == "unknown_material"
+    assert get_emode_material("si", ()) == "si"
+
+
+def test_shapes_one_per_layer_in_order(layer_stack: LayerStack) -> None:
+    shapes = get_shapes_from_layer_stack("rib", layer_stack)
+    assert [shape["name"] for shape in shapes] == list(layer_stack.layers)
+
+
+def test_shapes_mask_from_cross_section(layer_stack: LayerStack) -> None:
+    shapes = {
+        shape["name"]: shape
+        for shape in get_shapes_from_layer_stack(
+            gf.cross_section.rib(width=0.6), layer_stack
+        )
+    }
+    # The core layer matches the WG section of the rib cross-section, so it
+    # is patterned: masked and etched through its full thickness.
+    assert shapes["core"]["mask"] == pytest.approx(600.0)
+    assert shapes["core"]["mask_offset"] == pytest.approx(0.0)
+    assert shapes["core"]["etch_depth"] == pytest.approx(220.0)
+    # Layers without a matching section are blanket layers with no mask/etch.
+    assert "mask" not in shapes["box"]
+    assert "mask_offset" not in shapes["box"]
+    assert "etch_depth" not in shapes["box"]
+
+
+def test_shapes_mask_offset_from_cross_section(layer_stack: LayerStack) -> None:
+    xs = gf.CrossSection(sections=(gf.Section(width=0.5, offset=0.1, layer="WG"),))
+    shapes = {
+        shape["name"]: shape for shape in get_shapes_from_layer_stack(xs, layer_stack)
+    }
+    assert shapes["core"]["mask"] == pytest.approx(500.0)
+    assert shapes["core"]["mask_offset"] == pytest.approx(100.0)
+
+
+def test_shapes_match_section_by_layer_tuple(layer_stack: LayerStack) -> None:
+    # Layer specs are normalized through the PDK, so a section defined with a
+    # (layer, datatype) tuple matches a layer stack that uses layer names.
+    wg_tuple = gf.get_layer_tuple("WG")
+    xs = gf.CrossSection(sections=(gf.Section(width=0.5, layer=wg_tuple),))
+    shapes = {
+        shape["name"]: shape for shape in get_shapes_from_layer_stack(xs, layer_stack)
+    }
+    assert shapes["core"]["mask"] == pytest.approx(500.0)
+    assert "mask" not in shapes["clad"]
+
+
+def test_shapes_positions_relative_to_stack_bottom(layer_stack: LayerStack) -> None:
+    shapes = {
+        shape["name"]: shape
+        for shape in get_shapes_from_layer_stack("rib", layer_stack)
+    }
+    # min zmin is -1.5 (box), so the box spans 0..1500 nm with center at 750 nm.
+    assert shapes["box"]["position"] == pytest.approx([0.0, 750.0])
+    assert shapes["core"]["position"] == pytest.approx([0.0, 1610.0])
+    assert shapes["slab90"]["position"] == pytest.approx([0.0, 1545.0])
+    assert shapes["clad"]["position"] == pytest.approx([0.0, 2250.0])
+    assert shapes["core"]["height"] == pytest.approx(220.0)
+
+
+def test_shapes_priority_from_mesh_order(layer_stack: LayerStack) -> None:
+    shapes = {
+        shape["name"]: shape
+        for shape in get_shapes_from_layer_stack("rib", layer_stack)
+    }
+    # gdsfactory mesh order (lower = higher priority) maps to EMode priority
+    # (higher = higher priority): priority = max_order - mesh_order + 1.
+    assert shapes["core"]["priority"] == 9
+    assert shapes["slab90"]["priority"] == 8
+    assert shapes["box"]["priority"] == 2
+    assert shapes["clad"]["priority"] == 1
+
+
+def test_shapes_match_materials(layer_stack: LayerStack) -> None:
+    shapes = {
+        shape["name"]: shape
+        for shape in get_shapes_from_layer_stack("rib", layer_stack, EMODE_MATERIALS)
+    }
+    assert shapes["core"]["material"] == "Si"
+    assert shapes["box"]["material"] == "SiO2"
+
+    # Without a material list, gdsfactory names pass through unchanged.
+    shapes = {
+        shape["name"]: shape
+        for shape in get_shapes_from_layer_stack("rib", layer_stack)
+    }
+    assert shapes["core"]["material"] == "si"
+
+
+def test_empty_layer_stack_raises() -> None:
+    with pytest.raises(ValueError, match="at least one layer"):
+        get_shapes_from_layer_stack("rib", LayerStack(layers={}))
+
+
+def test_layer_without_material_raises(layer_stack: LayerStack) -> None:
+    layer_stack.layers["core"] = layer_stack.layers["core"].model_copy(
+        update={"material": None}
+    )
+    with pytest.raises(ValueError, match="core"):
+        get_shapes_from_layer_stack("rib", layer_stack)
+
+
+def test_build_waveguide_forwards_to_session(layer_stack: LayerStack) -> None:
+    em = FakeEMode()
+    em.build_waveguide(
+        cross_section="rib",
+        layer_stack=layer_stack,
+        wavelength=1.55,
+        num_modes=2,
+    )
+
+    assert len(em.recorded_settings) == 1
+    assert em.recorded_settings[0]["wavelength"] == pytest.approx(1550.0)
+    assert em.recorded_settings[0]["num_modes"] == 2
+
+    shapes = {shape["name"]: shape for shape in em.recorded_shapes}
+    assert set(shapes) == set(layer_stack.layers)
+    # Materials from the session are used to match gdsfactory material names.
+    assert shapes["core"]["material"] == "Si"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

{gplugins-2.1.0 → gplugins-2.1.2}/gplugins/fdtdz/get_epsilon_fdtdz.py

@@ -215,7 +215,7 @@ def add_plot_labels(arg0, arg1, arg2, arg3) -> None:
 
 if __name__ == "__main__":
     import gdsfactory as gf
-    from gdsfactory.generic_tech import LAYER, LAYER_STACK
+    from gdsfactory.gpdk import LAYER, LAYER_STACK
 
     length = 5
 

{gplugins-2.1.0 → gplugins-2.1.2}/gplugins/fdtdz/get_ports_fdtdz.py

@@ -190,7 +190,7 @@ def plot_mode(
 
 if __name__ == "__main__":
     import gdsfactory as gf
-    from gdsfactory.generic_tech import LAYER, LAYER_STACK
+    from gdsfactory.gpdk import LAYER, LAYER_STACK
 
     from gplugins.fdtdz.get_epsilon_fdtdz import component_to_epsilon_pjz
 

{gplugins-2.1.0 → gplugins-2.1.2}/gplugins/fdtdz/get_sparameters_fdtdz.py

@@ -147,7 +147,7 @@ def get_sparameters_fdtdz(
 
 
 if __name__ == "__main__":
-    from gdsfactory.generic_tech import LAYER, LAYER_STACK
+    from gdsfactory.gpdk import LAYER, LAYER_STACK
 
     length = 5
 

{gplugins-2.1.0 → gplugins-2.1.2}/gplugins/femwell/mode_solver.py

@@ -92,6 +92,9 @@ def compute_cross_section_modes(
 
 
 _material_name_to_index = {
+    "Si": 3.48,
+    "SiO2": 1.44,
+    "SiN": 2.0,
     "si": 3.48,
     "sio2": 1.44,
     "sin": 2.0,