photonfdtd 0.12.0__py3-none-any.whl

photonfdtd/__init__.py

@@ -0,0 +1,84 @@
+"""photonfdtd - local FDTD + waveguide mode solver for integrated photonics.
+
+Capabilities:
+
+- 1D / 2D / 3D Yee-grid FDTD with CPML absorbing boundaries
+- Isotropic dielectric media, non-dispersive or dispersive (Lorentz / Drude /
+  Sellmeier poles stepped by the ADE method), with a cited material library
+  (SiO2, Si, Si3N4, LiNbO3, Au, Ag)
+- Anisotropic subpixel (sub-cell) smoothing of material interfaces for
+  second-order accuracy at boundaries (``Simulation(subpixel=True)``)
+- Axis-aligned Box and arbitrary-polygon PolySlab geometry primitives
+- Point-dipole, distributed mode, and energy-normalised single-photon sources
+- Field snapshot monitors and a flux monitor through a coordinate plane
+- Full-vectorial (FDFD) waveguide mode solver
+- :func:`from_gdsfactory` adapter that turns a gdsfactory Component into a
+  fully-built Simulation
+
+A NumPy backend is used throughout. It is correct but not fast; for production
+runs of large 3D problems a compiled or GPU backend is on the roadmap.
+"""
+from .constants import C_0, EPS_0, MU_0, ETA_0, Q_E
+from .grid import Grid
+from .materials import (
+    Medium, DispersiveMedium, Pole,
+    silica, silicon, silicon_nitride, lithium_niobate, gold, silver,
+)
+from . import materials
+from .geometry import Box, PolySlab
+from .sources import (
+    GaussianPulse, PointDipole, ModeSource, UniModeSource, SinglePhotonSource,
+    ChargedParticle, single_photon_field_amplitude, PLANCK_H,
+)
+from .monitors import FieldMonitor, FluxMonitor, DFTMonitor
+from .storage import CompressedFieldSeries
+from .simulation import Simulation
+# Differentiable JAX entry point (import is lazy - jax is an optional dep;
+# accessing the name only fails if jax is missing when actually called).
+from .jaxbackend import value_and_grad_eps as jax_value_and_grad_eps
+from .reversible import (
+    value_and_grad_eps_reversible as jax_value_and_grad_eps_reversible,
+)
+from .reversible_pml import (
+    value_and_grad_eps_reversible_pml as jax_value_and_grad_eps_reversible_pml,
+)
+from .mode import ModeSolver
+from .smatrix import mode_amplitudes, port_fields, s_parameters
+from .eim import (
+    Layer, SlabModes, slab_modes, effective_index, EffectiveIndex2D,
+)
+from .eme import Section, EMEResult, eme_2d, sections_from_eps
+from .adi import ADISimulation2D, ADISource, ADIResult
+from .design import (
+    EtchedCore, value_and_grad_density, conic_filter, tanh_projection,
+)
+from .memory import (
+    estimate_memory, recommend_mode, format_report, available_memory,
+)
+from . import adapters
+from .adapters import from_gdsfactory
+
+__all__ = [
+    "C_0", "EPS_0", "MU_0", "ETA_0", "Q_E", "PLANCK_H",
+    "Grid", "Medium", "DispersiveMedium", "Pole", "materials",
+    "silica", "silicon", "silicon_nitride", "lithium_niobate", "gold", "silver",
+    "Box", "PolySlab",
+    "GaussianPulse", "PointDipole", "ModeSource", "UniModeSource",
+    "SinglePhotonSource",
+    "ChargedParticle", "single_photon_field_amplitude",
+    "FieldMonitor", "FluxMonitor", "DFTMonitor",
+    "CompressedFieldSeries",
+    "Simulation", "ModeSolver", "jax_value_and_grad_eps",
+    "jax_value_and_grad_eps_reversible",
+    "jax_value_and_grad_eps_reversible_pml",
+    "mode_amplitudes", "port_fields", "s_parameters",
+    # 2.5-D effective-index reduction, eigenmode expansion, ADI-FDTD
+    "Layer", "SlabModes", "slab_modes", "effective_index", "EffectiveIndex2D",
+    "Section", "EMEResult", "eme_2d", "sections_from_eps",
+    "ADISimulation2D", "ADISource", "ADIResult",
+    "EtchedCore", "value_and_grad_density", "conic_filter", "tanh_projection",
+    "estimate_memory", "recommend_mode", "format_report", "available_memory",
+    "adapters", "from_gdsfactory",
+]
+
+__version__ = "0.12.0"

photonfdtd/adapters.py

@@ -0,0 +1,190 @@
+"""Adapters from third-party layout tools into a photonfdtd Simulation.
+
+The single public function is :func:`from_gdsfactory`, which turns a
+:class:`gdsfactory.Component` into a fully-built :class:`Simulation` (with
+the grid sized to the layout bounding box plus a configurable padding,
+polygons rasterised onto the Yee grid, and CPML on every transverse axis).
+
+gdsfactory itself is an optional dependency: this module imports it lazily,
+so a user who never touches the adapter will not pay an import cost.
+"""
+from __future__ import annotations
+from typing import Dict, Iterable, Optional, Sequence, Tuple
+import numpy as np
+
+from .grid import Grid
+from .materials import Medium
+from .geometry import Box, PolySlab
+from .simulation import Simulation
+
+
+LayerSpec = int  # gdsfactory layer index, e.g. 1 for WG core
+LayerMap = Dict[LayerSpec, Tuple[Medium, Tuple[float, float]]]
+BackgroundSlabs = Iterable[Tuple[Medium, Tuple[float, float]]]
+
+
+def _component_polygons_um(component) -> Dict[int, list]:
+    """Return {layer_index: [Nx2 numpy arrays of (x, y) in microns, ...]}.
+
+    Works against gdsfactory >=9.x (kfactory-based) Components.
+    """
+    raw = component.get_polygons()
+    dbu = float(component.kcl.dbu)   # microns per database unit
+    out: Dict[int, list] = {}
+    for layer_key, plist in raw.items():
+        polys_um = []
+        for p in plist:
+            pts = np.array([(pt.x * dbu, pt.y * dbu) for pt in p.each_point_hull()],
+                           dtype=float)
+            if pts.shape[0] >= 3:
+                polys_um.append(pts)
+        if polys_um:
+            out[layer_key] = polys_um
+    return out
+
+
+def from_gdsfactory(
+    component,
+    *,
+    layers: LayerMap,
+    background_slabs: BackgroundSlabs = (),
+    cell_size: float,
+    padding: Tuple[float, float, float] = (2e-6, 2e-6, 1e-6),
+    pml_layers: Tuple[int, int, int] = (12, 12, 0),
+    z_size: Optional[float] = None,
+    run_time: float = 1e-12,
+    extra_structures: Sequence = (),
+    courant: float = 0.99,
+    use_gpu: bool = False,
+    use_numba: bool = False,
+    precision="float64",
+    xy_bounds: Optional[Tuple[float, float, float, float]] = None,
+) -> Simulation:
+    """Build a 3D photonfdtd Simulation from a gdsfactory Component.
+
+    Parameters
+    ----------
+    component : gdsfactory.Component
+        Layout source. Polygons are read via ``component.get_polygons()`` and
+        scaled from database units to microns via ``component.kcl.dbu``.
+    layers : dict
+        ``{layer_index: (Medium, (z_min_m, z_max_m))}``. Each gdsfactory
+        layer is rasterised as a :class:`PolySlab` filled with ``Medium``
+        between ``z_min`` and ``z_max`` (both in metres). Layers not in this
+        dict are ignored.
+    background_slabs : iterable, optional
+        ``[(Medium, (z_min_m, z_max_m)), ...]`` of unpatterned z-slabs that
+        span the whole xy-extent (e.g. buried oxide, substrate, top
+        cladding). Stamped before the layer polygons so the polygons win in
+        regions of overlap.
+    cell_size : float
+        Yee cell size in metres. The same value is used on every axis.
+    padding : (px, py, pz), in metres
+        Extra extent added to the component bounding box on each axis. The
+        z padding is symmetric around the z extent inferred from the layers.
+    pml_layers : (nx, ny, nz)
+        CPML thickness in cells per axis.
+    z_size : float, optional
+        Override the auto-computed z extent. If ``None``, z extent equals
+        ``max_z - min_z + 2*padding[2]`` where ``min_z`` and ``max_z`` are
+        taken from ``layers`` and ``background_slabs``.
+    run_time : float
+        FDTD run time in seconds. Passed through to the Simulation.
+    extra_structures : sequence
+        Additional Box/PolySlab structures stamped after the layer polygons
+        (highest priority).
+    courant : float
+        Courant safety factor on the FDTD timestep.
+
+    Returns
+    -------
+    Simulation
+        Built but not yet run. Add sources and monitors before calling
+        ``sim.run()``.
+    """
+    polys_by_layer = _component_polygons_um(component)
+
+    # XY domain in microns -> centre and extent in metres. Normally the whole
+    # component bounding box (the kfactory-era DBox exposes .left/.right/
+    # .bottom/.top in microns); xy_bounds (x_lo, x_hi, y_lo, y_hi in metres)
+    # restricts it to a sub-region instead, so only that window is gridded.
+    # Polygons outside the grid simply don't rasterise, so the structure is
+    # clipped to the region automatically.
+    if xy_bounds is not None:
+        x_lo_um, x_hi_um = xy_bounds[0] * 1e6, xy_bounds[1] * 1e6
+        y_lo_um, y_hi_um = xy_bounds[2] * 1e6, xy_bounds[3] * 1e6
+    else:
+        bb = component.bbox()
+        x_lo_um, x_hi_um = float(bb.left), float(bb.right)
+        y_lo_um, y_hi_um = float(bb.bottom), float(bb.top)
+    x_center = 0.5 * (x_lo_um + x_hi_um) * 1e-6
+    y_center = 0.5 * (y_lo_um + y_hi_um) * 1e-6
+    x_extent = (x_hi_um - x_lo_um) * 1e-6 + 2.0 * padding[0]
+    y_extent = (y_hi_um - y_lo_um) * 1e-6 + 2.0 * padding[1]
+
+    # z extent
+    z_mins, z_maxs = [], []
+    for _med, (z0, z1) in layers.values():
+        z_mins.append(min(z0, z1)); z_maxs.append(max(z0, z1))
+    for _med, (z0, z1) in background_slabs:
+        z_mins.append(min(z0, z1)); z_maxs.append(max(z0, z1))
+    if z_mins:
+        z_lo, z_hi = min(z_mins), max(z_maxs)
+        z_extent_inner = z_hi - z_lo
+        z_center = 0.5 * (z_lo + z_hi)
+    else:
+        z_extent_inner = 0.0
+        z_center = 0.0
+    z_extent_full = z_extent_inner + 2.0 * padding[2] if z_size is None else float(z_size)
+
+    grid = Grid(
+        size=(x_extent, y_extent, z_extent_full),
+        cell_size=cell_size,
+        pml_layers=pml_layers,
+    )
+
+    # Build structures: background slabs first, then per-layer polygons,
+    # then any user extras. The Simulation rasteriser respects insertion
+    # order (later overrides earlier).
+    structures = []
+
+    # Background slabs: stamped as Boxes spanning the entire xy domain. The
+    # photonfdtd Grid coordinates are centred at the origin, so we shift the
+    # slab centre by -z_center to land in grid space.
+    for med, (z0, z1) in background_slabs:
+        thickness = abs(z1 - z0)
+        c_z = 0.5 * (z0 + z1) - z_center
+        structures.append(Box(
+            center=(0.0, 0.0, c_z),
+            size=(1e9, 1e9, thickness),   # effectively infinite in xy
+            medium=med,
+        ))
+
+    # gdsfactory polygons: shift vertices to metres and recentre on the
+    # component bbox so the grid's origin lines up with the layout's.
+    for layer_idx, (med, (z0, z1)) in layers.items():
+        if layer_idx not in polys_by_layer:
+            continue
+        for poly_um in polys_by_layer[layer_idx]:
+            verts_m = poly_um * 1e-6
+            verts_m = [(float(x - x_center), float(y - y_center)) for x, y in verts_m]
+            structures.append(PolySlab(
+                vertices=tuple(verts_m),
+                z_bounds=(float(z0) - z_center, float(z1) - z_center),
+                medium=med,
+            ))
+
+    for s in extra_structures:
+        structures.append(s)
+
+    return Simulation(
+        grid=grid,
+        structures=structures,
+        sources=[],
+        monitors=[],
+        run_time=run_time,
+        courant=courant,
+        use_gpu=use_gpu,
+        use_numba=use_numba,
+        precision=precision,
+    )

photonfdtd/adi.py

@@ -0,0 +1,337 @@
+"""Unconditionally-stable ADI-FDTD (2-D), CFL-free time stepping.
+
+Explicit Yee FDTD is bound by the Courant-Friedrichs-Lewy limit: the time step
+cannot exceed ``~dx/(c*sqrt(D))``. On a photonic-circuit grid a single small
+feature (a narrow gap, a thin sidewall) forces a small ``dx`` everywhere it
+touches, and CFL then forces a small ``dt`` over the *whole* domain and every
+timestep - even where the fields are smooth. The alternating-direction-implicit
+FDTD (Namiki 1999; Zheng, Chen & Zhang 2000) removes the stability bound
+entirely: it is **unconditionally stable**, so ``dt`` is set by accuracy alone.
+Where CFL was the binding constraint, that is a 3-10x cut in the number of
+steps.
+
+The price is two implicit sub-steps per full step, each a set of independent
+tridiagonal solves - one direction implicit, the other explicit, then swapped.
+This module implements the scheme for the 2-D ``(Ez, Hx, Hy)`` polarisation
+(the out-of-plane-E field of an ``xy`` grid - the polarisation the 2.5-D
+effective-index reduction produces). The tridiagonal solves are the natural
+unit of work for the Rust backend (each line is independent; see
+``rust/src/adi.rs``), so ``backend="rust"`` parallelises them across lines.
+
+Boundaries: ``"pec"`` (perfect electric conductor, ``Ez=0`` - a closed cavity,
+used to demonstrate that the resonant frequency is ``dt``-independent) and
+``"absorber"`` (a graded electric+magnetic conductivity layer, impedance
+matched at normal incidence; a basic open boundary, not as reflectionless as
+the explicit solver's CPML).
+
+Scheme, per full step ``n -> n+1`` (``s = dt/2``, ``c = s^2/mu0``):
+
+    sub-step 1 (x implicit):
+        [eps - c d2/dx2] Ez* = eps Ez^n + s (dHy^n/dx - dHx^n/dy)
+        Hy* = Hy^n + (s/mu0) dEz*/dx ,  Hx* = Hx^n - (s/mu0) dEz^n/dy
+    sub-step 2 (y implicit):
+        [eps - c d2/dy2] Ez^{n+1} = eps Ez* + s (dHy*/dx - dHx*/dy)
+        Hy^{n+1} = Hy* + (s/mu0) dEz*/dx ,  Hx^{n+1} = Hx* - (s/mu0) dEz^{n+1}/dy
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Callable, Dict, List, Optional, Sequence, Tuple
+
+import numpy as np
+
+from .constants import C_0, EPS_0, MU_0
+
+
+def _thomas(diag, lower, upper, rhs):
+    """Solve a batch of tridiagonal systems along axis 0 (Thomas algorithm).
+
+    ``diag`` is ``(n, batch)``; ``lower``/``upper`` are the (constant) sub- and
+    super-diagonals as scalars; ``rhs`` is ``(n, batch)``. Returns ``(n, batch)``.
+    Modifies copies only.
+    """
+    n = diag.shape[0]
+    cp = np.empty_like(diag)
+    dp = np.empty_like(rhs)
+    cp[0] = upper / diag[0]
+    dp[0] = rhs[0] / diag[0]
+    for i in range(1, n):
+        m = diag[i] - lower * cp[i - 1]
+        cp[i] = upper / m
+        dp[i] = (rhs[i] - lower * dp[i - 1]) / m
+    x = np.empty_like(rhs)
+    x[-1] = dp[-1]
+    for i in range(n - 2, -1, -1):
+        x[i] = dp[i] - cp[i] * x[i + 1]
+    return x
+
+
+@dataclass
+class ADIResult:
+    times: np.ndarray
+    snapshots: Dict[str, np.ndarray] = field(default_factory=dict)
+    probes: Dict[str, np.ndarray] = field(default_factory=dict)
+
+
+@dataclass
+class ADISource:
+    """Soft additive ``Ez`` point source at a grid index."""
+    i: int
+    j: int
+    waveform: Callable[[np.ndarray], np.ndarray]
+    amplitude: float = 1.0
+
+
+class ADISimulation2D:
+    """2-D unconditionally-stable ADI-FDTD for the ``(Ez, Hx, Hy)`` system.
+
+    Parameters
+    ----------
+    eps_r : (nx, ny) array
+        Relative permittivity at the ``Ez`` nodes.
+    cell_size : float or (dx, dy)
+        Grid step (m).
+    dt : float, optional
+        Time step (s). May exceed the explicit CFL limit (that is the point).
+        Defaults to ``courant_factor`` times the CFL step.
+    courant_factor : float
+        If ``dt`` is not given, ``dt = courant_factor * dt_CFL``. Values > 1 are
+        the CFL-breaking regime (unconditionally stable here).
+    boundary : {"pec", "absorber"}
+        Domain truncation (see module docstring).
+    pml_cells : int
+        Absorber thickness in cells (``boundary="absorber"``).
+    backend : {"numpy", "rust"}
+        ``"rust"`` runs the parallel tridiagonal sweeps in the compiled core.
+    """
+
+    def __init__(
+        self,
+        eps_r: np.ndarray,
+        cell_size,
+        *,
+        dt: Optional[float] = None,
+        courant_factor: float = 1.0,
+        boundary: str = "pec",
+        pml_cells: int = 12,
+        sources: Sequence[ADISource] = (),
+        backend: str = "numpy",
+        precision: str = "float64",
+    ) -> None:
+        self.eps_r = np.ascontiguousarray(eps_r, dtype=np.float64)
+        self.nx, self.ny = self.eps_r.shape
+        if isinstance(cell_size, (int, float)):
+            self.dx = self.dy = float(cell_size)
+        else:
+            self.dx, self.dy = float(cell_size[0]), float(cell_size[1])
+        if boundary not in ("pec", "absorber"):
+            raise ValueError("boundary must be 'pec' or 'absorber'")
+        self.boundary = boundary
+        self.pml_cells = int(pml_cells)
+        self.sources = list(sources)
+        if backend not in ("numpy", "rust"):
+            raise ValueError("backend must be 'numpy' or 'rust'")
+        self.backend = backend
+        self.npdt = np.float32 if precision == "float32" else np.float64
+
+        dt_cfl = 1.0 / (C_0 * np.sqrt(1.0 / self.dx ** 2 + 1.0 / self.dy ** 2))
+        self.dt = float(dt) if dt is not None else courant_factor * dt_cfl
+        self.dt_cfl = dt_cfl
+        self.courant_factor = self.dt / dt_cfl
+
+        # Electric / magnetic conductivity profiles (0 for PEC).
+        self.sigma_e, self.sigma_m = self._build_conductivity()
+
+    # ------------------------------------------------------------------ #
+    def _build_conductivity(self):
+        nx, ny = self.nx, self.ny
+        sig_e = np.zeros((nx, ny))
+        if self.boundary != "absorber":
+            return sig_e, sig_e.copy()
+        # Graded (polynomial) conductivity ramp in the boundary layers, matched
+        # magnetic conductivity sigma_m = sigma_e * mu0/eps0 for normal-incidence
+        # impedance matching. Not a CPML - a simple lossy layer.
+        m = 3
+        npml = self.pml_cells
+        eta = MU_0 / EPS_0
+        sig_max = 0.8 * (m + 1) / (np.sqrt(eta) * self.dx)
+        ramp = np.zeros(nx)
+        prof = sig_max * (np.arange(npml)[::-1] / max(npml - 1, 1)) ** m
+        ax = np.zeros(nx); ay = np.zeros(ny)
+        ax[:npml] = prof; ax[-npml:] = prof[::-1]
+        ay[:npml] = prof; ay[-npml:] = prof[::-1]
+        sig = np.maximum(ax[:, None], ay[None, :])
+        return sig, sig * (MU_0 / EPS_0)
+
+    # ------------------------------------------------------------------ #
+    def run(self, steps: int, *, snapshot_interval: int = 0,
+            probes: Sequence[Tuple[int, int]] = ()) -> ADIResult:
+        if self.backend == "rust":
+            return self._run_rust(steps, snapshot_interval, probes)
+        return self._run_numpy(steps, snapshot_interval, probes)
+
+    # ------------------------------------------------------------------ #
+    def _run_numpy(self, steps, snapshot_interval, probes) -> ADIResult:
+        nx, ny = self.nx, self.ny
+        dx, dy, dt = self.dx, self.dy, self.dt
+        eps = self.eps_r * EPS_0
+        s = dt / 2.0
+        c = s * s / MU_0
+
+        Ez = np.zeros((nx, ny))
+        Hx = np.zeros((nx, ny - 1))          # at (i, j+1/2)
+        Hy = np.zeros((nx - 1, ny))          # at (i+1/2, j)
+
+        # Tridiagonal off-diagonal (constant): -c/dx^2 (x sweep), -c/dy^2 (y).
+        offx = -c / dx ** 2
+        offy = -c / dy ** 2
+        # Interior diagonals include the eps term; PEC -> solve interior nodes.
+        snaps: List[np.ndarray] = []
+        snap_t: List[float] = []
+        probe_vals = {f"{i},{j}": [] for (i, j) in probes}
+        times = []
+
+        for n in range(steps):
+            # ---- sub-step 1: implicit in x ---- #
+            dHy_dx = np.zeros((nx, ny)); dHx_dy = np.zeros((nx, ny))
+            dHy_dx[1:-1, :] = (Hy[1:, :] - Hy[:-1, :])[:, :] / dx
+            dHx_dy[:, 1:-1] = (Hx[:, 1:] - Hx[:, :-1])[:, :] / dy
+            rhs = eps * Ez + s * (dHy_dx - dHx_dy)
+            Ez_star = self._solve_x(eps, offx, rhs, c, dx)
+            self._inject(Ez_star, (n + 0.5), eps, s)   # half-step source
+            # explicit H at the half step
+            dEz_dx = (Ez_star[1:, :] - Ez_star[:-1, :]) / dx
+            dEz_dy_star = (Ez_star[:, 1:] - Ez_star[:, :-1]) / dy
+            Hy_star = self._advance_hy(Hy, dEz_dx, s)
+            Hx_star = self._advance_hx(Hx,
+                                       (Ez[:, 1:] - Ez[:, :-1]) / dy, s)
+
+            # ---- sub-step 2: implicit in y ---- #
+            dHy_dx2 = np.zeros((nx, ny)); dHx_dy2 = np.zeros((nx, ny))
+            dHy_dx2[1:-1, :] = (Hy_star[1:, :] - Hy_star[:-1, :]) / dx
+            dHx_dy2[:, 1:-1] = (Hx_star[:, 1:] - Hx_star[:, :-1]) / dy
+            rhs2 = eps * Ez_star + s * (dHy_dx2 - dHx_dy2)
+            Ez_new = self._solve_y(eps, offy, rhs2, c, dy)
+            self._inject(Ez_new, (n + 1.0), eps, s)
+            dEz_dx2 = (Ez_star[1:, :] - Ez_star[:-1, :]) / dx
+            dEz_dy_new = (Ez_new[:, 1:] - Ez_new[:, :-1]) / dy
+            Hy_new = self._advance_hy(Hy_star, dEz_dx2, s)
+            Hx_new = self._advance_hx(Hx_star, dEz_dy_new, s)
+
+            Ez, Hx, Hy = Ez_new, Hx_new, Hy_new
+
+            t = (n + 1) * dt
+            times.append(t)
+            if snapshot_interval and (n % snapshot_interval == 0):
+                snaps.append(Ez.copy()); snap_t.append(t)
+            for (i, j) in probes:
+                probe_vals[f"{i},{j}"].append(Ez[i, j])
+
+        res = ADIResult(times=np.asarray(times))
+        if snaps:
+            res.snapshots["Ez"] = np.asarray(snaps)
+            res.snapshots["t"] = np.asarray(snap_t)
+        res.probes = {k: np.asarray(v) for k, v in probe_vals.items()}
+        return res
+
+    # ---- per-substep helpers (also the reference for the Rust core) ---- #
+    def _solve_x(self, eps, off, rhs, c, dx):
+        """Solve [eps - c d2/dx2] Ez = rhs for each row, PEC/absorber ends."""
+        nx, ny = self.nx, self.ny
+        diag = eps + 2.0 * c / dx ** 2 + self.sigma_e * (self.dt / 2.0)
+        # Interior system over i=1..nx-2 (Ez=0 on PEC ends; absorber handled by
+        # the sigma term keeping ends finite but we still pin the outermost).
+        d = diag[1:-1, :].copy()
+        r = rhs[1:-1, :].copy()
+        sol = _thomas(d, off, off, r)
+        out = np.zeros((nx, ny))
+        out[1:-1, :] = sol
+        return out
+
+    def _solve_y(self, eps, off, rhs, c, dy):
+        nx, ny = self.nx, self.ny
+        diag = eps + 2.0 * c / dy ** 2 + self.sigma_e * (self.dt / 2.0)
+        d = diag[:, 1:-1].T.copy()
+        r = rhs[:, 1:-1].T.copy()
+        sol = _thomas(d, off, off, r).T
+        out = np.zeros((nx, ny))
+        out[:, 1:-1] = sol
+        return out
+
+    def _advance_hy(self, Hy, dEz_dx, s):
+        if self.boundary == "absorber":
+            sm = 0.5 * (self.sigma_m[1:, :] + self.sigma_m[:-1, :])
+            a = 1.0 - sm * s / MU_0
+            b = 1.0 + sm * s / MU_0
+            return (a / b) * Hy + (s / MU_0 / b) * dEz_dx
+        return Hy + (s / MU_0) * dEz_dx
+
+    def _advance_hx(self, Hx, dEz_dy, s):
+        if self.boundary == "absorber":
+            sm = 0.5 * (self.sigma_m[:, 1:] + self.sigma_m[:, :-1])
+            a = 1.0 - sm * s / MU_0
+            b = 1.0 + sm * s / MU_0
+            return (a / b) * Hx - (s / MU_0 / b) * dEz_dy
+        return Hx - (s / MU_0) * dEz_dy
+
+    def _inject(self, Ez, step_frac, eps, s):
+        for src in self.sources:
+            val = src.amplitude * float(src.waveform(np.array([step_frac * self.dt]))[0])
+            Ez[src.i, src.j] += val * (self.dt / 2.0) / (eps[src.i, src.j])
+
+    # ------------------------------------------------------------------ #
+    def _run_rust(self, steps, snapshot_interval, probes) -> ADIResult:
+        from .rustbackend import _rust_module
+        rs = _rust_module()
+        if not hasattr(rs, "adi_step_range_f64"):
+            raise RuntimeError(
+                "the Rust extension was built without the ADI kernel; rebuild "
+                "with 'cargo build --release' in rust/ and reinstall the .so.")
+        return _run_adi_rust(self, rs, steps, snapshot_interval, probes)
+
+
+def _run_adi_rust(sim, rs, steps, snapshot_interval, probes) -> ADIResult:
+    """Drive the Rust ADI stepper (mirrors ``_run_numpy``)."""
+    npdt = sim.npdt
+    step_fn = rs.adi_step_range_f64 if npdt == np.float64 else rs.adi_step_range_f32
+    nx, ny = sim.nx, sim.ny
+    Ez = np.zeros((nx, ny), dtype=npdt)
+    Hx = np.zeros((nx, ny - 1), dtype=npdt)
+    Hy = np.zeros((nx - 1, ny), dtype=npdt)
+    eps = np.ascontiguousarray(sim.eps_r * EPS_0, dtype=npdt)
+    sig_e = np.ascontiguousarray(sim.sigma_e, dtype=npdt)
+    sig_m = np.ascontiguousarray(sim.sigma_m, dtype=npdt)
+
+    # Precompute source waveform tables (Ez soft source, injected at both
+    # half steps as in the NumPy path).
+    n_src = max(len(sim.sources), 1)
+    src_ij = np.zeros((n_src, 2), dtype=np.int64)
+    # Two columns per step: the (n+0.5) and (n+1.0) sample.
+    src_vals = np.zeros((n_src, 2 * max(steps, 1)), dtype=npdt)
+    for s_i, src in enumerate(sim.sources):
+        src_ij[s_i] = (src.i, src.j)
+        fr = np.empty(2 * steps)
+        for n in range(steps):
+            fr[2 * n] = src.amplitude * float(src.waveform(np.array([(n + 0.5) * sim.dt]))[0])
+            fr[2 * n + 1] = src.amplitude * float(src.waveform(np.array([(n + 1.0) * sim.dt]))[0])
+        src_vals[s_i] = fr.astype(npdt)
+
+    rec = sorted(set(range(0, steps, snapshot_interval))) if snapshot_interval else []
+    probe_arr = np.asarray(probes, dtype=np.int64).reshape(-1, 2)
+    snaps = np.zeros((len(rec), nx, ny), dtype=npdt)
+    probe_out = np.zeros((max(len(probe_arr), 1), steps), dtype=npdt)
+
+    step_fn(Ez, Hx, Hy, eps, sig_e, sig_m,
+            sim.dx, sim.dy, sim.dt,
+            src_ij, src_vals, len(sim.sources),
+            np.asarray(rec, dtype=np.int64), snaps,
+            probe_arr, probe_out, steps,
+            1 if sim.boundary == "absorber" else 0)
+
+    res = ADIResult(times=(np.arange(steps) + 1) * sim.dt)
+    if len(rec):
+        res.snapshots["Ez"] = snaps
+        res.snapshots["t"] = (np.asarray(rec) + 1) * sim.dt
+    res.probes = {f"{i},{j}": probe_out[k]
+                  for k, (i, j) in enumerate(probe_arr)}
+    return res