From 1c20f5c1a0122fd2ba1fa763da1f9f9c1a47aebd Mon Sep 17 00:00:00 2001 From: vahid ansari Date: Thu, 19 Feb 2026 08:40:58 +0100 Subject: [PATCH 1/7] feat: add FiberSource for grating coupler simulation Add Gaussian beam source support to gsim.meep for simulating fiber-to-chip coupling through grating couplers. New API: - FiberSource model (beam_waist, angle_theta, z_offset, polarization) - FiberSourceConfig with discriminated union on SimConfig.source - CouplingResult with from_csv(), plot(), peak_ce - Notebook example using UBC PDK ebeam_gc_te1550 Runner changes: - build_fiber_source() creates mp.GaussianBeamSource - build_incident_flux_monitor() for normalization - extract_coupling_efficiency() with CE = |alpha|^2 / |incident_flux| - Cell z-range includes dielectrics (not just layer_stack) - Source z references core layer (highest n), not topmost metal - Use abs() on incident flux (downward beam gives negative flux) 179 meep tests passing. --- nbs/meep_grating_coupler.ipynb | 188 +++++++++++++++++++ pyproject.toml | 2 +- src/gsim/meep/ROADMAP.md | 14 ++ src/gsim/meep/__init__.py | 15 +- src/gsim/meep/models/__init__.py | 7 +- src/gsim/meep/models/api.py | 65 +++++++ src/gsim/meep/models/config.py | 42 ++++- src/gsim/meep/models/results.py | 139 ++++++++++++++ src/gsim/meep/ports.py | 11 +- src/gsim/meep/script.py | 281 +++++++++++++++++++++++++-- src/gsim/meep/simulation.py | 106 +++++++++-- tests/meep/test_meep_models.py | 313 +++++++++++++++++++++++++++++++ tests/meep/test_simulation.py | 136 ++++++++++++++ 13 files changed, 1284 insertions(+), 35 deletions(-) create mode 100644 nbs/meep_grating_coupler.ipynb create mode 100644 src/gsim/meep/ROADMAP.md diff --git a/nbs/meep_grating_coupler.ipynb b/nbs/meep_grating_coupler.ipynb new file mode 100644 index 00000000..e69e81e1 --- /dev/null +++ b/nbs/meep_grating_coupler.ipynb @@ -0,0 +1,188 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0", + "metadata": {}, + "source": [ + "# Grating Coupler Simulation with FiberSource\n", + "\n", + "[MEEP](https://meep.readthedocs.io/) is an open-source FDTD electromagnetic simulator. This notebook demonstrates using the `gsim.meep` **FiberSource** API to simulate fiber-to-chip coupling through a grating coupler.\n", + "\n", + "Unlike S-parameter simulations that use eigenmode sources at waveguide ports, grating coupler simulations launch a **Gaussian beam from above** (simulating a fiber) and measure the power coupled into the waveguide port via eigenmode decomposition.\n", + "\n", + "**Requirements:**\n", + "\n", + "- UBC PDK: `uv pip install ubcpdk`\n", + "- [GDSFactory+](https://gdsfactory.com) account for cloud simulation" + ] + }, + { + "cell_type": "markdown", + "id": "1", + "metadata": {}, + "source": [ + "### Load a grating coupler from UBC PDK" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2", + "metadata": {}, + "outputs": [], + "source": [ + "from ubcpdk import PDK, cells\n", + "\n", + "PDK.activate()\n", + "\n", + "c = cells.ebeam_gc_te1550()\n", + "c" + ] + }, + { + "cell_type": "markdown", + "id": "3", + "metadata": {}, + "source": [ + "### Configure simulation with FiberSource\n", + "\n", + "Instead of `ModeSource` (which excites a waveguide eigenmode at a port), we use `FiberSource` to launch a Gaussian beam from above the grating. Key parameters:\n", + "\n", + "- **beam_waist**: Gaussian beam waist radius (SMF-28 mode field diameter / 2 = 5.2 um)\n", + "- **angle_theta**: Fiber tilt angle from vertical (typically 8-15 degrees for grating couplers)\n", + "- **z_offset**: Distance above the chip surface to place the source plane\n", + "- **polarization**: TE or TM\n", + "\n", + "The result is a `CouplingResult` instead of `SParameterResult`, giving coupling efficiency (CE) per port." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4", + "metadata": {}, + "outputs": [], + "source": [ + "from gsim import meep\n", + "\n", + "sim = meep.Simulation()\n", + "\n", + "sim.geometry(component=c, z_crop=\"auto\")\n", + "sim.materials = {\"si\": 3.47, \"SiO2\": 1.44}\n", + "\n", + "sim.source = meep.FiberSource(\n", + " wavelength=1.55,\n", + " wavelength_span=0.1,\n", + " num_freqs=21,\n", + " beam_waist=5.2,\n", + " angle_theta=10.0,\n", + " z_offset=2.0,\n", + ")\n", + "\n", + "sim.monitors = [\"o1\"]\n", + "sim.domain(pml=1.0, margin=1.0, margin_z_above=3.0)\n", + "sim.solver(resolution=15, simplify_tol=0.01, save_animation=True, verbose_interval=5.0)\n", + "sim.solver.stop_after_sources(time=80)\n", + "\n", + "print(sim.validate_config())" + ] + }, + { + "cell_type": "markdown", + "id": "5", + "metadata": {}, + "source": [ + "### Preview geometry" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6", + "metadata": {}, + "outputs": [], + "source": [ + "sim.plot_2d(slices=\"xyz\")" + ] + }, + { + "cell_type": "markdown", + "id": "7", + "metadata": {}, + "source": [ + "### Run simulation on cloud" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8", + "metadata": {}, + "outputs": [], + "source": [ + "result = sim.run()" + ] + }, + { + "cell_type": "markdown", + "id": "9", + "metadata": {}, + "source": [ + "### Plot coupling efficiency" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "10", + "metadata": {}, + "outputs": [], + "source": [ + "result.plot(db=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "11", + "metadata": {}, + "outputs": [], + "source": [ + "print(\"Peak coupling efficiency (dB):\")\n", + "for port, ce_db in result.peak_ce.items():\n", + " print(f\" {port}: {ce_db:.2f} dB\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "12", + "metadata": {}, + "outputs": [], + "source": [ + "result.show_animation()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "gsim", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml index 8a2478e1..7303e7bb 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -83,7 +83,7 @@ src = "src/gsim/__init__.py" commit-template = "Release {new-version}" [tool.codespell] -ignore-words-list = "doubleclick" +ignore-words-list = "doubleclick,TE" [tool.interrogate] docstring-style = "google" diff --git a/src/gsim/meep/ROADMAP.md b/src/gsim/meep/ROADMAP.md new file mode 100644 index 00000000..d62b26be --- /dev/null +++ b/src/gsim/meep/ROADMAP.md @@ -0,0 +1,14 @@ +# gsim.meep Roadmap + +Features planned beyond the current S-parameter extraction workflow. + +## Planned + +- [ ] **Grating coupler simulation** — near-to-far-field transformation, fiber mode overlap, coupling efficiency vs wavelength +- [ ] **Resonator & Q-factor extraction** — Harminv-based resonance finding, Q/FSR extraction, SAX circuit model integration +- [ ] **Parameter sweep framework** — sweep any sim parameter, parallel cloud runs, result aggregation +- [ ] **Convergence testing** — automated resolution/domain sweeps, convergence metric, pass/fail report +- [ ] **Broadband flux monitors** — total transmission/reflection via `add_flux`, for filters/gratings/stacks +- [ ] **Dispersive materials** — Lorentz/Drude models, MEEP built-in material library (~20 fitted materials) +- [ ] **Band structure / photonic crystal** — Bloch-periodic boundaries, k-point sweeps, band diagram plotting +- [ ] **Adjoint optimization / inverse design** — topology optimization via `meep.adjoint`, design region, GDS export diff --git a/src/gsim/meep/__init__.py b/src/gsim/meep/__init__.py index 4bcd6055..13e6b0dc 100644 --- a/src/gsim/meep/__init__.py +++ b/src/gsim/meep/__init__.py @@ -21,8 +21,11 @@ from gsim.gcloud import RunResult, register_result_parser from gsim.meep.models import ( FDTD, + CouplingResult, Domain, DomainConfig, + FiberSource, + FiberSourceConfig, Geometry, Material, ModeSource, @@ -37,8 +40,13 @@ from gsim.meep.simulation import BuildResult, Simulation -def _parse_meep_result(run_result: RunResult) -> SParameterResult: - """Parse MEEP cloud results into an SParameterResult.""" +def _parse_meep_result(run_result: RunResult) -> SParameterResult | CouplingResult: + """Parse MEEP cloud results into SParameterResult or CouplingResult.""" + # Check for fiber source results first + ce_csv = run_result.files.get("coupling_efficiency.csv") + if ce_csv is not None: + return CouplingResult.from_csv(ce_csv) + # Standard S-parameter results csv_path = run_result.files.get("s_parameters.csv") if csv_path is not None: return SParameterResult.from_csv(csv_path) @@ -50,8 +58,11 @@ def _parse_meep_result(run_result: RunResult) -> SParameterResult: __all__ = [ "FDTD", "BuildResult", + "CouplingResult", "Domain", "DomainConfig", + "FiberSource", + "FiberSourceConfig", "Geometry", "Material", "ModeSource", diff --git a/src/gsim/meep/models/__init__.py b/src/gsim/meep/models/__init__.py index d7cd302d..f2735612 100644 --- a/src/gsim/meep/models/__init__.py +++ b/src/gsim/meep/models/__init__.py @@ -3,6 +3,7 @@ from gsim.meep.models.api import ( FDTD, Domain, + FiberSource, Geometry, Material, ModeSource, @@ -12,6 +13,7 @@ AccuracyConfig, DiagnosticsConfig, DomainConfig, + FiberSourceConfig, LayerStackEntry, MaterialData, PortData, @@ -22,7 +24,7 @@ SymmetryEntry, WavelengthConfig, ) -from gsim.meep.models.results import SParameterResult +from gsim.meep.models.results import CouplingResult, SParameterResult # Backward compatibility alias FDTDConfig = WavelengthConfig @@ -30,10 +32,13 @@ __all__ = [ "FDTD", "AccuracyConfig", + "CouplingResult", "DiagnosticsConfig", "Domain", "DomainConfig", "FDTDConfig", + "FiberSource", + "FiberSourceConfig", "Geometry", "LayerStackEntry", "Material", diff --git a/src/gsim/meep/models/api.py b/src/gsim/meep/models/api.py index 3b7ea65c..bc098173 100644 --- a/src/gsim/meep/models/api.py +++ b/src/gsim/meep/models/api.py @@ -90,6 +90,71 @@ def __call__(self, **kwargs: Any) -> ModeSource: return self +class FiberSource(BaseModel): + """Gaussian beam source simulating fiber-to-chip coupling. + + Launches a Gaussian beam from above (or below) to model grating + coupler excitation. Normalization uses an incident flux monitor + rather than eigenmode decomposition at the source. + """ + + model_config = ConfigDict(validate_assignment=True) + + wavelength: float = Field( + default=1.55, + gt=0, + description="Center wavelength in um", + ) + wavelength_span: float = Field( + default=0.1, + ge=0, + description="Wavelength span of the measurement frequency grid in um.", + ) + num_freqs: int = Field( + default=11, + ge=1, + description="Number of frequency points", + ) + beam_waist: float = Field( + default=5.2, + gt=0, + description="Gaussian beam waist radius in um (SMF-28 MFD/2 ≈ 5.2)", + ) + angle_theta: float = Field( + default=10.0, + ge=0, + lt=90, + description="Polar angle from vertical in degrees", + ) + angle_phi: float = Field( + default=0.0, + description="Azimuthal angle in degrees (0 = tilted in XZ plane)", + ) + polarization: Literal["TE", "TM"] = Field( + default="TE", + description="Beam polarization", + ) + position: list[float] | None = Field( + default=None, + description="Beam center [x, y]. None = auto (component bbox center).", + ) + z_offset: float = Field( + default=1.0, + gt=0, + description="Distance above stack top to place source plane (um)", + ) + direction: Literal["down", "up"] = Field( + default="down", + description="Beam propagation direction ('down' = into chip)", + ) + + def __call__(self, **kwargs: Any) -> FiberSource: + """Update fields in place. Returns self for chaining.""" + for k, v in kwargs.items(): + setattr(self, k, v) + return self + + # --------------------------------------------------------------------------- # Domain # --------------------------------------------------------------------------- diff --git a/src/gsim/meep/models/config.py b/src/gsim/meep/models/config.py index f7cc7073..bf178c03 100644 --- a/src/gsim/meep/models/config.py +++ b/src/gsim/meep/models/config.py @@ -8,9 +8,9 @@ import json from pathlib import Path -from typing import Any, Literal +from typing import Annotated, Any, Literal -from pydantic import BaseModel, ConfigDict, Field, PrivateAttr, computed_field +from pydantic import BaseModel, ConfigDict, Discriminator, Field, PrivateAttr, Tag, computed_field class SymmetryEntry(BaseModel): @@ -111,7 +111,7 @@ class StoppingConfig(BaseModel): class SourceConfig(BaseModel): - """Source excitation configuration. + """Eigenmode source excitation configuration. Controls the Gaussian source bandwidth and which port is excited. When ``bandwidth`` is ``None`` (auto), ``compute_fwidth`` returns a @@ -122,6 +122,10 @@ class SourceConfig(BaseModel): model_config = ConfigDict(validate_assignment=True) + source_type: Literal["mode"] = Field( + default="mode", + description="Source type discriminator.", + ) bandwidth: float | None = Field( default=None, description=( @@ -161,6 +165,32 @@ def compute_fwidth(self, fcen: float, monitor_df: float) -> float: return max(3 * monitor_df, 0.2 * fcen) +class FiberSourceConfig(BaseModel): + """Gaussian beam source config for fiber-to-chip coupling simulation. + + Sent as JSON to the cloud runner, which builds an ``mp.GaussianBeamSource``. + The ``z_position`` is the absolute z-coordinate of the source plane + (resolved from the API-level ``z_offset`` + stack top). + """ + + model_config = ConfigDict(validate_assignment=True) + + source_type: Literal["fiber"] = Field( + default="fiber", + description="Source type discriminator.", + ) + beam_waist: float = Field(gt=0, description="Gaussian beam waist radius in um") + angle_theta: float = Field( + ge=0, lt=90, description="Polar angle from vertical (deg)" + ) + angle_phi: float = Field(description="Azimuthal angle (deg)") + polarization: Literal["TE", "TM"] + direction: Literal["down", "up"] + position: list[float] = Field(description="Beam center [x, y]") + z_position: float = Field(description="Absolute z-coordinate of source plane") + fwidth: float = Field(gt=0, description="Source fwidth in frequency units") + + class WavelengthConfig(BaseModel): """Wavelength and frequency settings for MEEP FDTD simulation. @@ -322,7 +352,11 @@ class SimConfig(BaseModel): ports: list[PortData] materials: dict[str, MaterialData] wavelength: WavelengthConfig = Field(serialization_alias="fdtd") - source: SourceConfig + source: Annotated[ + Annotated[SourceConfig, Tag("mode")] + | Annotated[FiberSourceConfig, Tag("fiber")], + Discriminator("source_type"), + ] stopping: StoppingConfig resolution: ResolutionConfig domain: DomainConfig diff --git a/src/gsim/meep/models/results.py b/src/gsim/meep/models/results.py index 9a8bd6b1..7b7bec9e 100644 --- a/src/gsim/meep/models/results.py +++ b/src/gsim/meep/models/results.py @@ -366,3 +366,142 @@ def _is_reflection(name: str) -> bool: ), ) return fig + + +class CouplingResult(BaseModel): + """Coupling efficiency results from fiber-to-chip Gaussian beam simulation. + + Parses CSV output from the cloud runner and provides visualization. + """ + + model_config = ConfigDict(validate_assignment=True) + + wavelengths: list[float] = Field(default_factory=list) + coupling_efficiency: dict[str, list[float]] = Field( + default_factory=dict, + description="Port name -> CE values (linear, 0-1) per wavelength", + ) + debug_info: dict[str, Any] = Field( + default_factory=dict, + description="Debug diagnostics from meep_debug.json (if available)", + ) + diagnostic_images: dict[str, str] = Field( + default_factory=dict, + description="Diagnostic image paths: key -> filepath", + ) + + @classmethod + def from_csv(cls, path: str | Path) -> CouplingResult: + """Parse coupling efficiency results from CSV file. + + Expected CSV format: + wavelength,o1,o2,... + 1.5,0.25,0.01,... + + Values are linear coupling efficiency (0-1). + + Args: + path: Path to CSV file + + Returns: + CouplingResult instance + """ + path = Path(path) + wavelengths: list[float] = [] + ce: dict[str, list[float]] = {} + + with open(path) as f: + reader = csv.DictReader(f) + if reader.fieldnames is None: + return cls() + + port_names = [c for c in reader.fieldnames if c != "wavelength"] + for name in port_names: + ce[name] = [] + + for row in reader: + wavelengths.append(float(row["wavelength"])) + for name in port_names: + ce[name].append(float(row[name])) + + # Auto-load debug log if present alongside CSV + debug_info: dict[str, Any] = {} + debug_path = path.parent / "meep_debug.json" + if debug_path.exists(): + with contextlib.suppress(json.JSONDecodeError, OSError): + debug_info = json.loads(debug_path.read_text()) + + # Auto-detect diagnostic PNGs + diagnostic_images: dict[str, str] = {} + for key, filename in [ + ("geometry_xy", "meep_geometry_xy.png"), + ("geometry_xz", "meep_geometry_xz.png"), + ("geometry_yz", "meep_geometry_yz.png"), + ("fields_xy", "meep_fields_xy.png"), + ("animation", "meep_animation.mp4"), + ]: + img_path = path.parent / filename + if img_path.exists(): + diagnostic_images[key] = str(img_path) + + return cls( + wavelengths=wavelengths, + coupling_efficiency=ce, + debug_info=debug_info, + diagnostic_images=diagnostic_images, + ) + + @property + def peak_ce(self) -> dict[str, float]: + """Peak coupling efficiency per port in dB. + + Returns: + Dict of port_name -> peak CE in dB. + """ + import math + + result: dict[str, float] = {} + for name, values in self.coupling_efficiency.items(): + if values: + peak_linear = max(values) + result[name] = ( + 10 * math.log10(peak_linear) if peak_linear > 0 else -100.0 + ) + else: + result[name] = -100.0 + return result + + def plot(self, db: bool = True, **kwargs: Any) -> Any: + """Plot coupling efficiency vs wavelength. + + Args: + db: If True, plot in dB scale (10*log10) + **kwargs: Passed to matplotlib plot() + + Returns: + matplotlib Figure + """ + import matplotlib.pyplot as plt + + fig, ax = plt.subplots() + plt.close(fig) # prevent double display in notebooks + + ylabel = "Coupling Efficiency (dB)" if db else "Coupling Efficiency" + for name, values in self.coupling_efficiency.items(): + if db: + import math + + y_vals = [10 * math.log10(v) if v > 0 else -100 for v in values] + else: + y_vals = values + + ax.plot(self.wavelengths, y_vals, ".-", label=name, **kwargs) + + ax.set_xlabel("Wavelength (um)") + ax.set_ylabel(ylabel) + ax.legend() + ax.grid(True, alpha=0.3) + ax.set_title("Coupling Efficiency") + fig.tight_layout() + + return fig diff --git a/src/gsim/meep/ports.py b/src/gsim/meep/ports.py index 59897ddf..a66dcd4c 100644 --- a/src/gsim/meep/ports.py +++ b/src/gsim/meep/ports.py @@ -44,6 +44,8 @@ def extract_port_info( component: Component, layer_stack: LayerStack, source_port: str | None = None, + *, + mark_source: bool = True, ) -> list[PortData]: """Extract port information from a gdsfactory component. @@ -51,6 +53,8 @@ def extract_port_info( component: gdsfactory Component with ports layer_stack: LayerStack to determine z-coordinates source_port: Name of the source port. If None, first port is the source. + mark_source: If False, no port gets ``is_source=True`` (used when + the source is a FiberSource rather than a port eigenmode). Returns: List of PortData objects ready for JSON serialization @@ -62,7 +66,12 @@ def extract_port_info( for i, gf_port in enumerate(component.ports): normal_axis, direction = get_port_normal(gf_port.orientation) - is_source = gf_port.name == source_port if source_port is not None else i == 0 + if mark_source: + is_source = ( + gf_port.name == source_port if source_port is not None else i == 0 + ) + else: + is_source = False ports.append( PortData( diff --git a/src/gsim/meep/script.py b/src/gsim/meep/script.py index ab709cf4..2b211218 100644 --- a/src/gsim/meep/script.py +++ b/src/gsim/meep/script.py @@ -491,6 +491,220 @@ def build_monitors(config, sim): return monitors +# --------------------------------------------------------------------------- +# Fiber source: Gaussian beam + incident flux +# --------------------------------------------------------------------------- + +def build_fiber_source(config, cell_x=None, cell_y=None, dpml=None): + """Build a MEEP GaussianBeamSource from fiber source config. + + Creates a Gaussian beam launched from above (or below) the device + to simulate fiber-to-chip coupling (grating coupler excitation). + + Args: + config: Simulation config dict. + cell_x: Cell x dimension (if None, computed from component_bbox). + cell_y: Cell y dimension (if None, computed from component_bbox). + dpml: PML thickness (if None, read from config). + """ + fdtd = config["fdtd"] + fcen = fdtd["fcen"] + src_cfg = config["source"] + fwidth = src_cfg["fwidth"] + beam_waist = src_cfg["beam_waist"] + theta_deg = src_cfg["angle_theta"] + phi_deg = src_cfg["angle_phi"] + polarization = src_cfg["polarization"] + direction = src_cfg["direction"] + position = src_cfg["position"] + z_position = src_cfg["z_position"] + + domain = config["domain"] + if dpml is None: + dpml = domain["dpml"] + + # Compute beam k-direction from angles + theta = math.radians(theta_deg) + phi = math.radians(phi_deg) + if direction == "down": + # Beam going downward (-z), tilted by theta from vertical + kx = math.sin(theta) * math.cos(phi) + ky = math.sin(theta) * math.sin(phi) + kz = -math.cos(theta) + else: + kx = math.sin(theta) * math.cos(phi) + ky = math.sin(theta) * math.sin(phi) + kz = math.cos(theta) + + beam_kdir = mp.Vector3(kx, ky, kz) + + # Polarization: TE = E in y (for phi=0), TM = E in plane of incidence + if polarization == "TE": + beam_E0 = mp.Vector3(0, 1, 0) + else: + # TM: E in the plane of incidence (xz for phi=0) + beam_E0 = mp.Vector3(math.cos(theta), 0, math.sin(theta)) + + # Source plane: horizontal, spans cell minus PML + if cell_x is not None and cell_y is not None: + sx = cell_x - 2 * dpml + sy = cell_y - 2 * dpml + else: + # Fallback: compute from component bbox + component_bbox = config["component_bbox"] + if component_bbox is not None: + bbox_left, bbox_bottom, bbox_right, bbox_top = component_bbox + else: + bbox_left, bbox_bottom, bbox_right, bbox_top = -10, -10, 10, 10 + margin_xy = domain["margin_xy"] + sx = (bbox_right - bbox_left) + 2 * margin_xy + sy = (bbox_top - bbox_bottom) + 2 * margin_xy + + center = mp.Vector3(position[0], position[1], z_position) + size = mp.Vector3(sx, sy, 0) + + source = mp.GaussianBeamSource( + src=mp.GaussianSource(frequency=fcen, fwidth=fwidth), + center=center, + size=size, + beam_x0=mp.Vector3(position[0], position[1], z_position), + beam_kdir=beam_kdir, + beam_w0=beam_waist, + beam_E0=beam_E0, + ) + + return [source], center + + +def build_incident_flux_monitor(config, sim, source_center): + """Build a flux monitor near the source to measure incident power. + + Placed 0.5 um below (toward device) the source center for a + 'down' beam, or 0.5 um above for an 'up' beam. Spans the full + cell minus PML in XY. + """ + fdtd = config["fdtd"] + fcen = fdtd["fcen"] + df = fdtd["df"] + nfreq = fdtd["num_freqs"] + src_cfg = config["source"] + direction = src_cfg["direction"] + domain = config["domain"] + dpml = domain["dpml"] + + # Offset toward the device + offset = 0.5 + if direction == "down": + z_monitor = source_center.z - offset + else: + z_monitor = source_center.z + offset + + # Span full cell minus PML in XY + sx = sim.cell_size.x - 2 * dpml + sy = sim.cell_size.y - 2 * dpml + + center = mp.Vector3(source_center.x, source_center.y, z_monitor) + size = mp.Vector3(sx, sy, 0) + + flux = sim.add_flux( + fcen, df, nfreq, + mp.FluxRegion(center=center, size=size), + ) + return flux + + +def extract_coupling_efficiency(config, sim, monitors, incident_flux): + """Extract coupling efficiency at each port via eigenmode decomposition. + + CE = |alpha_waveguide|^2 / incident_flux for each port and frequency. + + Returns: + (ce_params, debug_data) tuple + """ + fdtd = config["fdtd"] + fcen = fdtd["fcen"] + nfreq = fdtd["num_freqs"] + df = fdtd["df"] + freqs = np.linspace(fcen - df / 2, fcen + df / 2, nfreq) + + # Get total incident flux (array of nfreq values). + # Use abs() because a downward beam produces negative flux through a + # +z-normal plane (MEEP convention: positive flux = +z direction). + inc_flux_raw = mp.get_fluxes(incident_flux) + inc_flux = [abs(f) for f in inc_flux_raw] + + debug_data = { + "incident_flux": [float(f) for f in inc_flux], + "incident_flux_raw": [float(f) for f in inc_flux_raw], + "eigenmode_info": {}, + } + + ce_params = {} + + for port in config["ports"]: + port_name = port["name"] + if port_name not in monitors: + continue + + # Eigenmode decomposition at waveguide port + port_kp = _port_kpoint(port) + ob = sim.get_eigenmode_coefficients( + monitors[port_name], [1], eig_parity=mp.NO_PARITY, + kpoint_func=lambda f, n, kp=port_kp: kp, + ) + + # Use the forward-propagating mode (outgoing from grating into waveguide) + # Port direction = direction of incoming mode from outside + # For grating coupler output ports, outgoing = into waveguide + port_dir = port["direction"] + # Outgoing mode: opposite to "incoming" direction convention + out_idx = 1 if port_dir == "+" else 0 + alpha = ob.alpha[0, :, out_idx] + + # CE = |alpha|^2 / incident_flux + ce = np.zeros(nfreq) + for fi in range(nfreq): + if inc_flux[fi] > 0: + ce[fi] = float(abs(alpha[fi]) ** 2 / inc_flux[fi]) + + ce_params[port_name] = ce + + debug_data["eigenmode_info"][port_name] = { + "alpha_mag": [float(abs(a)) for a in alpha], + "ce": [float(c) for c in ce], + } + + return ce_params, debug_data + + +def save_ce_results(config, ce_params, output_path="coupling_efficiency.csv"): + """Save coupling efficiency to CSV. Only rank 0 writes.""" + if not mp.am_master(): + return + fdtd = config["fdtd"] + fcen = fdtd["fcen"] + df = fdtd["df"] + nfreq = fdtd["num_freqs"] + + freqs = np.linspace(fcen - df / 2, fcen + df / 2, nfreq) + wavelengths = 1.0 / freqs + + port_names = sorted(ce_params.keys()) + fieldnames = ["wavelength"] + port_names + + with open(output_path, "w", newline="") as f: + writer = csv.DictWriter(f, fieldnames=fieldnames) + writer.writeheader() + + for i, wl in enumerate(wavelengths): + row = {"wavelength": f"{wl:.6f}"} + for name in port_names: + row[name] = f"{float(ce_params[name][i]):.8f}" + writer.writerow(row) + + logger.info("Coupling efficiency saved to %s", output_path) + + # --------------------------------------------------------------------------- # S-parameter extraction # --------------------------------------------------------------------------- @@ -699,6 +913,8 @@ def save_debug_log(config, s_params, debug_data, wall_seconds=0.0, "stopping_mode": stopping["mode"], }, "eigenmode_info": debug_data.get("eigenmode_info", {}), + "incident_flux": debug_data.get("incident_flux", []), + "incident_flux_raw": debug_data.get("incident_flux_raw", []), "incident_coefficients": debug_data.get("incident_coefficients", {}), "raw_coefficients": debug_data.get("raw_coefficients", {}), "power_conservation": debug_data.get("power_conservation", []), @@ -991,12 +1207,8 @@ def main(): # Background slabs first, then patterned prisms (later objects take precedence) geometry = background_slabs + geometry - logger.info("Building sources...") - sources = build_sources(config) - - if not sources: - logger.error("No source port found in config") - sys.exit(1) + source_type = config["source"].get("source_type", "mode") + logger.info("Source type: %s", source_type) resolution = config["resolution"]["pixels_per_um"] fdtd = config["fdtd"] @@ -1025,6 +1237,15 @@ def main(): dpml = domain["dpml"] margin_xy = domain["margin_xy"] + # For fiber source, ensure the cell extends to include the source z + if source_type == "fiber": + src_z = config["source"]["z_position"] + src_dir = config["source"]["direction"] + if src_dir == "down" and src_z > z_max: + z_max = src_z + 0.5 # 0.5 um margin above source + elif src_dir == "up" and src_z < z_min: + z_min = src_z - 0.5 + # XY: margin_xy is gap between geometry bbox and PML cell_x = (bbox_right - bbox_left) + 2 * (margin_xy + dpml) cell_y = (bbox_top - bbox_bottom) + 2 * (margin_xy + dpml) @@ -1037,6 +1258,21 @@ def main(): (z_max + z_min) / 2, ) + # Build sources AFTER cell dimensions are known (fiber source needs them) + fiber_source_center = None + if source_type == "fiber": + logger.info("Building Gaussian beam source...") + sources, fiber_source_center = build_fiber_source( + config, cell_x=cell_x, cell_y=cell_y, dpml=dpml, + ) + else: + logger.info("Building eigenmode sources...") + sources = build_sources(config) + + if not sources: + logger.error("No source found in config") + sys.exit(1) + logger.info("Cell size: %.2f x %.2f x %.2f um", cell_x, cell_y, cell_z) logger.info("PML: %.2f um, margin_xy: %.2f", dpml, margin_xy) logger.info("Resolution: %s pixels/um", resolution) @@ -1104,6 +1340,12 @@ def main(): logger.info("Building monitors...") monitors = build_monitors(config, sim) + # For fiber source, also build incident flux monitor + incident_flux = None + if source_type == "fiber" and fiber_source_center is not None: + logger.info("Building incident flux monitor...") + incident_flux = build_incident_flux_monitor(config, sim, fiber_source_center) + stopping = config["stopping"] run_after = stopping["run_after_sources"] @@ -1240,16 +1482,27 @@ def _capture_frame(sim_obj): render_animation_frames(eps_data, _extent) compile_animation_mp4() - logger.info("Extracting S-parameters...") - s_params, debug_data = extract_s_params(config, sim, monitors) + if source_type == "fiber" and incident_flux is not None: + logger.info("Extracting coupling efficiency...") + ce_params, debug_data = extract_coupling_efficiency( + config, sim, monitors, incident_flux + ) + debug_data["_meep_time"] = sim.meep_time() + debug_data["_timesteps"] = sim.timestep() + debug_data["_cell_size"] = [cell_x, cell_y, cell_z] + + save_ce_results(config, ce_params) + save_debug_log(config, {}, debug_data, wall_seconds=wall_seconds) + else: + logger.info("Extracting S-parameters...") + s_params, debug_data = extract_s_params(config, sim, monitors) + debug_data["_meep_time"] = sim.meep_time() + debug_data["_timesteps"] = sim.timestep() + debug_data["_cell_size"] = [cell_x, cell_y, cell_z] - # Attach simulation metadata to debug_data - debug_data["_meep_time"] = sim.meep_time() - debug_data["_timesteps"] = sim.timestep() - debug_data["_cell_size"] = [cell_x, cell_y, cell_z] + save_results(config, s_params) + save_debug_log(config, s_params, debug_data, wall_seconds=wall_seconds) - save_results(config, s_params) - save_debug_log(config, s_params, debug_data, wall_seconds=wall_seconds) logger.info("Done!") diff --git a/src/gsim/meep/simulation.py b/src/gsim/meep/simulation.py index 871cb688..4df40823 100644 --- a/src/gsim/meep/simulation.py +++ b/src/gsim/meep/simulation.py @@ -16,6 +16,7 @@ from gsim.meep.models.api import ( FDTD, Domain, + FiberSource, Geometry, Material, ModeSource, @@ -77,7 +78,7 @@ class Simulation(BaseModel): geometry: Geometry = Field(default_factory=Geometry) materials: dict[str, float | Material] = Field(default_factory=dict) - source: ModeSource = Field(default_factory=ModeSource) + source: ModeSource | FiberSource = Field(default_factory=ModeSource) monitors: list[str] = Field(default_factory=list) domain: Domain = Field(default_factory=Domain) solver: FDTD = Field(default_factory=FDTD) @@ -149,7 +150,7 @@ def validate_config(self) -> Any: ports = list(self.geometry.component.ports) if not ports: errors.append("Component has no ports.") - elif self.source.port is not None: + elif isinstance(self.source, ModeSource) and self.source.port is not None: port_names = [p.name for p in ports] if self.source.port not in port_names: errors.append( @@ -192,6 +193,18 @@ def validate_config(self) -> Any: elif s.stopping == "fixed": warnings_list.append(f"Stopping: fixed (time={s.max_time})") + # Fiber source: warn if z_offset is large relative to margin_z_above + if ( + isinstance(self.source, FiberSource) + and self.source.z_offset >= self.domain.margin_z_above + ): + warnings_list.append( + f"FiberSource z_offset ({self.source.z_offset}) >= " + f"margin_z_above ({self.domain.margin_z_above}). " + f"Consider increasing margin_z_above to ensure the " + f"source is well within the simulation cell." + ) + return ValidationResult( valid=len(errors) == 0, errors=errors, warnings=warnings_list ) @@ -313,11 +326,70 @@ def _source_config(self) -> Any: """Translate ModeSource → SourceConfig.""" from gsim.meep.models.config import SourceConfig + if not isinstance(self.source, ModeSource): + raise TypeError("_source_config() requires ModeSource") return SourceConfig( bandwidth=None, port=self.source.port, ) + def _fiber_source_config(self, stack: Any) -> Any: + """Translate FiberSource → FiberSourceConfig. + + Resolves position (auto-center on component bbox) and computes + absolute z from stack top + z_offset. + """ + from gsim.meep.models.config import FiberSourceConfig + + if not isinstance(self.source, FiberSource): + raise TypeError("_fiber_source_config() requires FiberSource") + + src = self.source + + # Resolve position: auto = component bbox center + if src.position is not None: + position = list(src.position) + else: + bbox = self.geometry.component.dbbox() + position = [ + (bbox.left + bbox.right) / 2.0, + (bbox.bottom + bbox.top) / 2.0, + ] + + # Compute absolute z from core layer top + offset. + # Use the highest-n layer (waveguide core) as reference, NOT the + # topmost layer (which could be a metal far above the grating). + from gsim.meep.ports import _find_highest_n_layer + + core_layer, _ = _find_highest_n_layer(stack) + if core_layer is not None: + z_ref_top = core_layer.zmax + z_ref_bottom = core_layer.zmin + else: + # Fallback: use full stack extent + z_ref_top = max(layer.zmax for layer in stack.layers.values()) + z_ref_bottom = min(layer.zmin for layer in stack.layers.values()) + + if src.direction == "down": + z_position = z_ref_top + src.z_offset + else: + z_position = z_ref_bottom - src.z_offset + + # Compute fwidth + wl_cfg = self._wavelength_config() + fwidth = max(3 * wl_cfg.df, 0.2 * wl_cfg.fcen) + + return FiberSourceConfig( + beam_waist=src.beam_waist, + angle_theta=src.angle_theta, + angle_phi=src.angle_phi, + polarization=src.polarization, + direction=src.direction, + position=position, + z_position=z_position, + fwidth=fwidth, + ) + def _stopping_config(self) -> Any: """Translate FDTD stopping fields → StoppingConfig.""" from gsim.meep.models.config import StoppingConfig @@ -436,7 +508,11 @@ def build_config(self) -> BuildResult: # Build config objects domain_cfg = self._domain_config() wl_cfg = self._wavelength_config() - source_cfg = self._source_config() + is_fiber = isinstance(self.source, FiberSource) + if is_fiber: + source_cfg = self._fiber_source_config(stack) + else: + source_cfg = self._source_config() stopping_cfg = self._stopping_config() resolution_cfg = self._resolution_config() accuracy_cfg = self._accuracy_config() @@ -488,18 +564,24 @@ def build_config(self) -> BuildResult: used_materials.add(diel["material"]) # Extract port info from original component - port_infos = extract_port_info( - original_component, stack, source_port=source_cfg.port - ) + if is_fiber: + port_infos = extract_port_info(original_component, stack, mark_source=False) + else: + port_infos = extract_port_info( + original_component, stack, source_port=source_cfg.port + ) # Resolve materials material_data = resolve_materials( used_materials, overrides=self._material_overrides() ) - # Compute source fwidth - fwidth = source_cfg.compute_fwidth(wl_cfg.fcen, wl_cfg.df) - source_for_config = source_cfg.model_copy(update={"fwidth": fwidth}) + # Compute source fwidth (for mode source only; fiber already has fwidth) + if is_fiber: + source_for_config = source_cfg + else: + fwidth = source_cfg.compute_fwidth(wl_cfg.fcen, wl_cfg.df) + source_for_config = source_cfg.model_copy(update={"fwidth": fwidth}) # Translate domain.symmetries → SymmetryEntry for config symmetry_entries = [ @@ -684,8 +766,8 @@ def run( If ``False``, upload + start and return the ``job_id``. Returns: - ``SParameterResult`` when ``wait=True``, or ``job_id`` string - when ``wait=False``. + ``SParameterResult`` or ``CouplingResult`` when ``wait=True``, + or ``job_id`` string when ``wait=False``. """ self.upload(verbose=False) self.start(verbose=verbose != "quiet") @@ -713,7 +795,7 @@ def plot_2d(self, **kwargs: Any) -> Any: component=result.component, stack=self.geometry.stack, domain_config=result.config.domain, - source_port=result.config.source.port, + source_port=getattr(result.config.source, "port", None), extend_ports_length=0, port_data=result.config.ports, component_bbox=result.config.component_bbox, diff --git a/tests/meep/test_meep_models.py b/tests/meep/test_meep_models.py index 9d298bda..17e68d19 100644 --- a/tests/meep/test_meep_models.py +++ b/tests/meep/test_meep_models.py @@ -9,7 +9,9 @@ from pydantic import ValidationError from gsim.meep import ( + CouplingResult, DomainConfig, + FiberSourceConfig, ResolutionConfig, SimConfig, SourceConfig, @@ -1410,3 +1412,314 @@ def test_plot_with_dielectric_overlay(self): assert "oxide" in patch_labels plt.close(fig) + + +# --------------------------------------------------------------------------- +# FiberSourceConfig tests +# --------------------------------------------------------------------------- + + +class TestFiberSourceConfig: + """Test FiberSourceConfig model.""" + + def test_creation(self): + cfg = FiberSourceConfig( + beam_waist=5.2, + angle_theta=10.0, + angle_phi=0.0, + polarization="TE", + direction="down", + position=[0.0, 0.0], + z_position=1.5, + fwidth=0.13, + ) + assert cfg.source_type == "fiber" + assert cfg.beam_waist == 5.2 + assert cfg.angle_theta == 10.0 + assert cfg.z_position == 1.5 + assert cfg.fwidth == 0.13 + + def test_model_dump(self): + cfg = FiberSourceConfig( + beam_waist=5.2, + angle_theta=10.0, + angle_phi=0.0, + polarization="TE", + direction="down", + position=[0.0, 0.0], + z_position=1.5, + fwidth=0.13, + ) + d = cfg.model_dump() + assert d["source_type"] == "fiber" + assert d["beam_waist"] == 5.2 + assert d["z_position"] == 1.5 + + def test_source_type_discriminator(self): + """SourceConfig and FiberSourceConfig have distinct source_type.""" + mode_cfg = SourceConfig() + assert mode_cfg.source_type == "mode" + + fiber_cfg = FiberSourceConfig( + beam_waist=5.2, + angle_theta=10.0, + angle_phi=0.0, + polarization="TE", + direction="down", + position=[0.0, 0.0], + z_position=1.5, + fwidth=0.13, + ) + assert fiber_cfg.source_type == "fiber" + + +# --------------------------------------------------------------------------- +# CouplingResult tests +# --------------------------------------------------------------------------- + + +class TestCouplingResult: + """Test CouplingResult model.""" + + def test_empty_result(self): + result = CouplingResult() + assert result.wavelengths == [] + assert result.coupling_efficiency == {} + + def test_from_csv(self, tmp_path): + csv_path = tmp_path / "coupling_efficiency.csv" + csv_path.write_text( + "wavelength,o1,o2\n" + "1.500000,0.25000000,0.01000000\n" + "1.550000,0.30000000,0.00500000\n" + ) + + result = CouplingResult.from_csv(csv_path) + assert len(result.wavelengths) == 2 + assert "o1" in result.coupling_efficiency + assert "o2" in result.coupling_efficiency + assert len(result.coupling_efficiency["o1"]) == 2 + assert abs(result.coupling_efficiency["o1"][0] - 0.25) < 1e-6 + assert abs(result.coupling_efficiency["o2"][1] - 0.005) < 1e-6 + + def test_peak_ce(self): + import math + + result = CouplingResult( + wavelengths=[1.5, 1.55], + coupling_efficiency={ + "o1": [0.25, 0.30], + "o2": [0.01, 0.005], + }, + ) + peaks = result.peak_ce + assert abs(peaks["o1"] - 10 * math.log10(0.30)) < 1e-6 + assert abs(peaks["o2"] - 10 * math.log10(0.01)) < 1e-6 + + def test_plot(self): + import matplotlib as mpl + + mpl.use("Agg") + + result = CouplingResult( + wavelengths=[1.5, 1.55], + coupling_efficiency={"o1": [0.25, 0.30]}, + ) + fig = result.plot(db=True) + assert fig is not None + + def test_plot_linear(self): + import matplotlib as mpl + + mpl.use("Agg") + + result = CouplingResult( + wavelengths=[1.5, 1.55], + coupling_efficiency={"o1": [0.25, 0.30]}, + ) + fig = result.plot(db=False) + assert fig is not None + + +# --------------------------------------------------------------------------- +# Script fiber source tests +# --------------------------------------------------------------------------- + + +class TestScriptFiberSource: + """Test that the runner script includes fiber source support.""" + + def test_script_has_gaussian_beam(self): + from gsim.meep.script import generate_meep_script + + script = generate_meep_script() + assert "GaussianBeamSource" in script + + def test_script_has_fiber_source_builder(self): + from gsim.meep.script import generate_meep_script + + script = generate_meep_script() + assert "build_fiber_source" in script + + def test_script_has_incident_flux(self): + from gsim.meep.script import generate_meep_script + + script = generate_meep_script() + assert "build_incident_flux_monitor" in script + assert "add_flux" in script + + def test_script_has_coupling_efficiency(self): + from gsim.meep.script import generate_meep_script + + script = generate_meep_script() + assert "extract_coupling_efficiency" in script + assert "save_ce_results" in script + + def test_script_branches_on_source_type(self): + from gsim.meep.script import generate_meep_script + + script = generate_meep_script() + assert "source_type" in script + assert '"fiber"' in script + + def test_script_still_valid_python(self): + from gsim.meep.script import generate_meep_script + + script = generate_meep_script() + ast.parse(script) + + +# --------------------------------------------------------------------------- +# SimConfig with FiberSourceConfig tests +# --------------------------------------------------------------------------- + + +class TestSimConfigFiberSource: + """Test SimConfig accepts FiberSourceConfig via discriminated union.""" + + def test_json_roundtrip_fiber_source(self, tmp_path): + from gsim.meep.models.config import AccuracyConfig, DiagnosticsConfig + + fiber_cfg = FiberSourceConfig( + beam_waist=5.2, + angle_theta=10.0, + angle_phi=0.0, + polarization="TE", + direction="down", + position=[0.0, 0.0], + z_position=1.5, + fwidth=0.13, + ) + + cfg = SimConfig( + gds_filename="layout.gds", + verbose_interval=0, + layer_stack=[], + dielectrics=[], + ports=[], + materials={}, + wavelength=WavelengthConfig(wavelength=1.55, bandwidth=0.1, num_freqs=11), + source=fiber_cfg, + stopping=StoppingConfig( + mode="fixed", + max_time=100.0, + decay_dt=50.0, + decay_component="Ey", + threshold=0.05, + dft_min_run_time=100, + ), + resolution=ResolutionConfig(pixels_per_um=32), + domain=DomainConfig( + dpml=1.0, + margin_xy=0.5, + margin_z_above=0.5, + margin_z_below=0.5, + port_margin=0.5, + extend_ports=0.0, + source_port_offset=0.1, + distance_source_to_monitors=0.2, + ), + accuracy=AccuracyConfig( + eps_averaging=False, + subpixel_maxeval=0, + subpixel_tol=1e-4, + simplify_tol=0.0, + ), + diagnostics=DiagnosticsConfig( + save_geometry=True, + save_fields=True, + save_epsilon_raw=False, + save_animation=False, + animation_interval=0.5, + preview_only=False, + verbose_interval=0, + ), + symmetries=[], + ) + + path = tmp_path / "config.json" + cfg.to_json(path) + data = json.loads(path.read_text()) + + assert data["source"]["source_type"] == "fiber" + assert data["source"]["beam_waist"] == 5.2 + assert data["source"]["angle_theta"] == 10.0 + assert data["source"]["z_position"] == 1.5 + + def test_json_roundtrip_mode_source(self, tmp_path): + """Existing mode source still works with the discriminated union.""" + from gsim.meep.models.config import AccuracyConfig, DiagnosticsConfig + + mode_cfg = SourceConfig() + + cfg = SimConfig( + gds_filename="layout.gds", + verbose_interval=0, + layer_stack=[], + dielectrics=[], + ports=[], + materials={}, + wavelength=WavelengthConfig(wavelength=1.55, bandwidth=0.1, num_freqs=11), + source=mode_cfg, + stopping=StoppingConfig( + mode="fixed", + max_time=100.0, + decay_dt=50.0, + decay_component="Ey", + threshold=0.05, + dft_min_run_time=100, + ), + resolution=ResolutionConfig(pixels_per_um=32), + domain=DomainConfig( + dpml=1.0, + margin_xy=0.5, + margin_z_above=0.5, + margin_z_below=0.5, + port_margin=0.5, + extend_ports=0.0, + source_port_offset=0.1, + distance_source_to_monitors=0.2, + ), + accuracy=AccuracyConfig( + eps_averaging=False, + subpixel_maxeval=0, + subpixel_tol=1e-4, + simplify_tol=0.0, + ), + diagnostics=DiagnosticsConfig( + save_geometry=True, + save_fields=True, + save_epsilon_raw=False, + save_animation=False, + animation_interval=0.5, + preview_only=False, + verbose_interval=0, + ), + symmetries=[], + ) + + path = tmp_path / "config.json" + cfg.to_json(path) + data = json.loads(path.read_text()) + + assert data["source"]["source_type"] == "mode" diff --git a/tests/meep/test_simulation.py b/tests/meep/test_simulation.py index b836a357..4b04627b 100644 --- a/tests/meep/test_simulation.py +++ b/tests/meep/test_simulation.py @@ -8,6 +8,7 @@ from gsim.meep import ( FDTD, Domain, + FiberSource, Geometry, Material, ModeSource, @@ -541,3 +542,138 @@ def test_simulation_instantiation(self): assert sim.materials == {} assert sim.monitors == [] assert sim.solver.resolution == 32 + + +# --------------------------------------------------------------------------- +# FiberSource model tests +# --------------------------------------------------------------------------- + + +class TestFiberSource: + def test_defaults(self): + s = FiberSource() + assert s.wavelength == 1.55 + assert s.wavelength_span == 0.1 + assert s.num_freqs == 11 + assert s.beam_waist == 5.2 + assert s.angle_theta == 10.0 + assert s.angle_phi == 0.0 + assert s.polarization == "TE" + assert s.position is None + assert s.z_offset == 1.0 + assert s.direction == "down" + + def test_custom(self): + s = FiberSource( + wavelength=1.31, + beam_waist=4.5, + angle_theta=15.0, + polarization="TM", + z_offset=2.0, + direction="up", + ) + assert s.wavelength == 1.31 + assert s.beam_waist == 4.5 + assert s.angle_theta == 15.0 + assert s.polarization == "TM" + assert s.z_offset == 2.0 + assert s.direction == "up" + + def test_callable_api(self): + s = FiberSource() + result = s(beam_waist=4.0, angle_theta=8.0) + assert result is s + assert s.beam_waist == 4.0 + assert s.angle_theta == 8.0 + + def test_beam_waist_positive(self): + with pytest.raises(ValidationError): + FiberSource(beam_waist=0) + + def test_angle_theta_bounds(self): + with pytest.raises(ValidationError): + FiberSource(angle_theta=90.0) + with pytest.raises(ValidationError): + FiberSource(angle_theta=-1.0) + + def test_z_offset_positive(self): + with pytest.raises(ValidationError): + FiberSource(z_offset=0) + + def test_position_custom(self): + s = FiberSource(position=[1.0, 2.0]) + assert s.position == [1.0, 2.0] + + +class TestFiberSourceSimulation: + """Test FiberSource integration with Simulation.""" + + def test_source_assignment(self): + sim = Simulation() + sim.source = FiberSource(beam_waist=5.2, angle_theta=10.0) + assert isinstance(sim.source, FiberSource) + assert sim.source.beam_waist == 5.2 + + def test_source_default_is_mode(self): + sim = Simulation() + assert isinstance(sim.source, ModeSource) + + def test_validate_fiber_skips_port_check(self): + """FiberSource validation should not require a source port.""" + sim = Simulation() + sim.source = FiberSource() + # Validation still fails because no component, but not due to source port + result = sim.validate_config() + assert not result.valid + assert any("No component" in e for e in result.errors) + assert not any("Source port" in e for e in result.errors) + + def test_wavelength_config_from_fiber(self): + sim = Simulation() + sim.source = FiberSource(wavelength=1.31, wavelength_span=0.05, num_freqs=21) + wl = sim._wavelength_config() + assert wl.wavelength == 1.31 + assert wl.bandwidth == 0.05 + assert wl.num_freqs == 21 + + def test_fiber_z_position_uses_core_layer(self): + """z_position should reference core (highest n) layer, not topmost layer.""" + from gsim.common.stack.extractor import Layer, LayerStack + + # Create a stack with core at z=0..0.22 and metal at z=1.8..2.5 + stack = LayerStack( + layers={ + "core": Layer( + name="core", + gds_layer=(1, 0), + zmin=0.0, + zmax=0.22, + thickness=0.22, + material="si", + layer_type="dielectric", + ), + "metal": Layer( + name="metal", + gds_layer=(12, 0), + zmin=1.8, + zmax=2.5, + thickness=0.7, + material="Aluminum", + layer_type="conductor", + ), + } + ) + sim = Simulation() + sim.source = FiberSource(z_offset=2.0, direction="down", position=[0.0, 0.0]) + cfg = sim._fiber_source_config(stack) + # z_position should be core_top + z_offset = 0.22 + 2.0 = 2.22 + # NOT metal_top + z_offset = 2.5 + 2.0 = 4.5 + assert cfg.z_position == pytest.approx(2.22, abs=0.01) + + def test_fiber_validation_warns_z_offset(self): + """Warn when z_offset >= margin_z_above.""" + sim = Simulation() + sim.source = FiberSource(z_offset=5.0) + sim.domain(margin_z_above=3.0) + result = sim.validate_config() + assert any("z_offset" in w for w in result.warnings) From 0de2238787a813c7f0414466b32ccf6b8798ff2c Mon Sep 17 00:00:00 2001 From: vahid ansari Date: Thu, 19 Feb 2026 08:45:41 +0100 Subject: [PATCH 2/7] update notebook --- nbs/meep_grating_coupler.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nbs/meep_grating_coupler.ipynb b/nbs/meep_grating_coupler.ipynb index e69e81e1..2f664242 100644 --- a/nbs/meep_grating_coupler.ipynb +++ b/nbs/meep_grating_coupler.ipynb @@ -73,7 +73,7 @@ "\n", "sim.source = meep.FiberSource(\n", " wavelength=1.55,\n", - " wavelength_span=0.1,\n", + " wavelength_span=0.07,\n", " num_freqs=21,\n", " beam_waist=5.2,\n", " angle_theta=10.0,\n", From 89cb131e456326e41ef59a5d4681218d0f3aa7f2 Mon Sep 17 00:00:00 2001 From: vahid ansari Date: Tue, 7 Apr 2026 21:00:22 +0200 Subject: [PATCH 3/7] fix: resolve pre-commit issues for fiber source PR - Format long pydantic import line - Add docstring to TestFiberSource class (interrogate) - Add isinstance narrowing for ty type checker - Wrap long lines in ROADMAP.md --- src/gsim/meep/ROADMAP.md | 6 ++++-- src/gsim/meep/models/config.py | 10 +++++++++- tests/meep/test_simulation.py | 4 ++++ 3 files changed, 17 insertions(+), 3 deletions(-) diff --git a/src/gsim/meep/ROADMAP.md b/src/gsim/meep/ROADMAP.md index d62b26be..f1318030 100644 --- a/src/gsim/meep/ROADMAP.md +++ b/src/gsim/meep/ROADMAP.md @@ -4,8 +4,10 @@ Features planned beyond the current S-parameter extraction workflow. ## Planned -- [ ] **Grating coupler simulation** — near-to-far-field transformation, fiber mode overlap, coupling efficiency vs wavelength -- [ ] **Resonator & Q-factor extraction** — Harminv-based resonance finding, Q/FSR extraction, SAX circuit model integration +- [ ] **Grating coupler simulation** — near-to-far-field transformation, fiber mode overlap, coupling efficiency vs + wavelength +- [ ] **Resonator & Q-factor extraction** — Harminv-based resonance finding, Q/FSR extraction, SAX circuit model + integration - [ ] **Parameter sweep framework** — sweep any sim parameter, parallel cloud runs, result aggregation - [ ] **Convergence testing** — automated resolution/domain sweeps, convergence metric, pass/fail report - [ ] **Broadband flux monitors** — total transmission/reflection via `add_flux`, for filters/gratings/stacks diff --git a/src/gsim/meep/models/config.py b/src/gsim/meep/models/config.py index bf178c03..5822ef80 100644 --- a/src/gsim/meep/models/config.py +++ b/src/gsim/meep/models/config.py @@ -10,7 +10,15 @@ from pathlib import Path from typing import Annotated, Any, Literal -from pydantic import BaseModel, ConfigDict, Discriminator, Field, PrivateAttr, Tag, computed_field +from pydantic import ( + BaseModel, + ConfigDict, + Discriminator, + Field, + PrivateAttr, + Tag, + computed_field, +) class SymmetryEntry(BaseModel): diff --git a/tests/meep/test_simulation.py b/tests/meep/test_simulation.py index 4b04627b..2d584825 100644 --- a/tests/meep/test_simulation.py +++ b/tests/meep/test_simulation.py @@ -216,6 +216,7 @@ class TestFieldAssignment: def test_source_port(self): sim = Simulation() + assert isinstance(sim.source, ModeSource) sim.source.port = "o1" assert sim.source.port == "o1" @@ -307,6 +308,7 @@ def test_source_callable(self): sim = Simulation() result = sim.source(port="o1", wavelength=1.31, wavelength_span=0.05) assert result is sim.source + assert isinstance(sim.source, ModeSource) assert sim.source.port == "o1" assert sim.source.wavelength == 1.31 assert sim.source.wavelength_span == 0.05 @@ -550,6 +552,8 @@ def test_simulation_instantiation(self): class TestFiberSource: + """Test FiberSource model defaults and validation.""" + def test_defaults(self): s = FiberSource() assert s.wavelength == 1.55 From e341e523034b28a27916128f784c447c3b0ecb4b Mon Sep 17 00:00:00 2001 From: vahid ansari Date: Wed, 8 Apr 2026 10:30:25 +0200 Subject: [PATCH 4/7] feat: add animation plane selection, fiber source overlay, and show_animation helper Support xz cross-section animations for grating coupler sims, render fiber source metadata in 2D plot overlays, and add CouplingResult.show_animation() for inline Jupyter playback. --- nbs/meep_grating_coupler.ipynb | 145 +++++++++++++++++++++++++++++--- src/gsim/meep/models/api.py | 1 + src/gsim/meep/models/config.py | 4 + src/gsim/meep/models/results.py | 11 +++ src/gsim/meep/overlay.py | 26 ++++++ src/gsim/meep/script.py | 47 +++++++---- src/gsim/meep/simulation.py | 17 ++++ src/gsim/meep/viz.py | 5 ++ 8 files changed, 226 insertions(+), 30 deletions(-) diff --git a/nbs/meep_grating_coupler.ipynb b/nbs/meep_grating_coupler.ipynb index 2f664242..ee613d85 100644 --- a/nbs/meep_grating_coupler.ipynb +++ b/nbs/meep_grating_coupler.ipynb @@ -27,10 +27,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "2", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from ubcpdk import PDK, cells\n", "\n", @@ -59,10 +70,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "4", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Stack validation: PASSED\n", + "Warnings:\n", + " - No stack configured. Will use active PDK with defaults.\n", + " - Stopping: fixed (time=110.0)\n" + ] + } + ], "source": [ "from gsim import meep\n", "\n", @@ -78,12 +100,14 @@ " beam_waist=5.2,\n", " angle_theta=10.0,\n", " z_offset=2.0,\n", + " position=[-25, 0],\n", ")\n", "\n", "sim.monitors = [\"o1\"]\n", "sim.domain(pml=1.0, margin=1.0, margin_z_above=3.0)\n", - "sim.solver(resolution=15, simplify_tol=0.01, save_animation=True, verbose_interval=5.0)\n", - "sim.solver.stop_after_sources(time=80)\n", + "sim.solver(resolution=25, save_animation=True, verbose_interval=5.0)\n", + "sim.solver.stop_after_sources(time=110)\n", + "sim.solver.animation_plane = \"xz\"\n", "\n", "print(sim.validate_config())" ] @@ -98,10 +122,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "6", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/vahid/doplaydo/gsim/src/gsim/meep/simulation.py:576: UserWarning: Material 'Aluminum' has no optical properties (refractive_index) — layer will be omitted from simulation. Use sim.set_material('Aluminum', refractive_index=...) to include it.\n", + " material_data = resolve_materials(\n", + "/Users/vahid/doplaydo/gsim/src/gsim/meep/simulation.py:576: UserWarning: Material 'TiN' has no optical properties (refractive_index) — layer will be omitted from simulation. Use sim.set_material('TiN', refractive_index=...) to include it.\n", + " material_data = resolve_materials(\n", + "/Users/vahid/doplaydo/gsim/src/gsim/meep/simulation.py:576: UserWarning: Material 'passive' has no optical properties (refractive_index) — layer will be omitted from simulation. Use sim.set_material('passive', refractive_index=...) to include it.\n", + " material_data = resolve_materials(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "sim.plot_2d(slices=\"xyz\")" ] @@ -116,10 +163,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "8", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " meep-8abb470b running 10m 49s\n" + ] + }, + { + "ename": "HTTPStatusError", + "evalue": "Server error '503 Service Unavailable' for url 'https://api.gdsfactory.com/api/simulation/sdk/v1/job/019d6bff-3478-7a42-9818-cd3a3c393cf4'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/503", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mHTTPStatusError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[4]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m result = \u001b[43msim\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/doplaydo/gsim/src/gsim/meep/simulation.py:777\u001b[39m, in \u001b[36mSimulation.run\u001b[39m\u001b[34m(self, parent_dir, verbose, wait)\u001b[39m\n\u001b[32m 775\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m wait:\n\u001b[32m 776\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m._job_id\n\u001b[32m--> \u001b[39m\u001b[32m777\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mwait_for_results\u001b[49m\u001b[43m(\u001b[49m\u001b[43mverbose\u001b[49m\u001b[43m=\u001b[49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparent_dir\u001b[49m\u001b[43m=\u001b[49m\u001b[43mparent_dir\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/doplaydo/gsim/src/gsim/meep/simulation.py:744\u001b[39m, in \u001b[36mSimulation.wait_for_results\u001b[39m\u001b[34m(self, verbose, parent_dir)\u001b[39m\n\u001b[32m 742\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._job_id \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 743\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[33m\"\u001b[39m\u001b[33mNo job submitted yet\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m--> \u001b[39m\u001b[32m744\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mgcloud\u001b[49m\u001b[43m.\u001b[49m\u001b[43mwait_for_results\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 745\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_job_id\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[43m=\u001b[49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparent_dir\u001b[49m\u001b[43m=\u001b[49m\u001b[43mparent_dir\u001b[49m\n\u001b[32m 746\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/doplaydo/gsim/src/gsim/gcloud.py:430\u001b[39m, in \u001b[36mwait_for_results\u001b[39m\u001b[34m(verbose, parent_dir, poll_interval, *job_ids)\u001b[39m\n\u001b[32m 428\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m jid, job \u001b[38;5;129;01min\u001b[39;00m jobs.items():\n\u001b[32m 429\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m job.status \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m terminal:\n\u001b[32m--> \u001b[39m\u001b[32m430\u001b[39m jobs[jid] = \u001b[43msim\u001b[49m\u001b[43m.\u001b[49m\u001b[43mget_job\u001b[49m\u001b[43m(\u001b[49m\u001b[43mjid\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 431\u001b[39m \u001b[38;5;66;03m# Stream logs when running\u001b[39;00m\n\u001b[32m 432\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m verbose == \u001b[33m\"\u001b[39m\u001b[33mfull\u001b[39m\u001b[33m\"\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m jobs[jid].status == sim.SimStatus.RUNNING:\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/doplaydo/gsim/.venv/lib/python3.12/site-packages/gdsfactoryplus/sim.py:303\u001b[39m, in \u001b[36mget_job\u001b[39m\u001b[34m(job_id)\u001b[39m\n\u001b[32m 298\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m httpx.Client(timeout=TIMEOUT) \u001b[38;5;28;01mas\u001b[39;00m client:\n\u001b[32m 299\u001b[39m response = client.get(\n\u001b[32m 300\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m_base_url()\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m/job/\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mjob_id\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m,\n\u001b[32m 301\u001b[39m headers=_headers(),\n\u001b[32m 302\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m303\u001b[39m \u001b[43mresponse\u001b[49m\u001b[43m.\u001b[49m\u001b[43mraise_for_status\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 304\u001b[39m data = response.json()\n\u001b[32m 305\u001b[39m job = Job.model_validate(data[\u001b[33m\"\u001b[39m\u001b[33mdata\u001b[39m\u001b[33m\"\u001b[39m])\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/doplaydo/gsim/.venv/lib/python3.12/site-packages/httpx/_models.py:829\u001b[39m, in \u001b[36mResponse.raise_for_status\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 827\u001b[39m error_type = error_types.get(status_class, \u001b[33m\"\u001b[39m\u001b[33mInvalid status code\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 828\u001b[39m message = message.format(\u001b[38;5;28mself\u001b[39m, error_type=error_type)\n\u001b[32m--> \u001b[39m\u001b[32m829\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m HTTPStatusError(message, request=request, response=\u001b[38;5;28mself\u001b[39m)\n", + "\u001b[31mHTTPStatusError\u001b[39m: Server error '503 Service Unavailable' for url 'https://api.gdsfactory.com/api/simulation/sdk/v1/job/019d6bff-3478-7a42-9818-cd3a3c393cf4'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/503" + ] + } + ], "source": [ "result = sim.run()" ] @@ -137,7 +208,19 @@ "execution_count": null, "id": "10", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "result.plot(db=True)" ] @@ -147,7 +230,16 @@ "execution_count": null, "id": "11", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Peak coupling efficiency (dB):\n", + " o1: -37.33 dB\n" + ] + } + ], "source": [ "print(\"Peak coupling efficiency (dB):\")\n", "for port, ce_db in result.peak_ce.items():\n", @@ -159,10 +251,34 @@ "execution_count": null, "id": "12", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "result.show_animation()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fd1b0fc6", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -180,7 +296,8 @@ "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython3" + "pygments_lexer": "ipython3", + "version": "3.12.10" } }, "nbformat": 4, diff --git a/src/gsim/meep/models/api.py b/src/gsim/meep/models/api.py index bc098173..cd19d3d2 100644 --- a/src/gsim/meep/models/api.py +++ b/src/gsim/meep/models/api.py @@ -396,5 +396,6 @@ def __call__(self, **kwargs: Any) -> FDTD: save_epsilon_raw: bool = Field(default=False) save_animation: bool = Field(default=False) animation_interval: float = Field(default=0.5, gt=0) + animation_plane: Literal["xy", "xz"] = Field(default="xy") preview_only: bool = Field(default=False) verbose_interval: float = Field(default=0, ge=0) diff --git a/src/gsim/meep/models/config.py b/src/gsim/meep/models/config.py index 5822ef80..f7717351 100644 --- a/src/gsim/meep/models/config.py +++ b/src/gsim/meep/models/config.py @@ -289,6 +289,10 @@ class DiagnosticsConfig(BaseModel): gt=0, description="MEEP time units between animation frames", ) + animation_plane: Literal["xy", "xz"] = Field( + default="xy", + description="Cross-section plane for field animation: 'xy' or 'xz'", + ) preview_only: bool = Field( description="Init sim and save geometry diagnostics, skip FDTD run", ) diff --git a/src/gsim/meep/models/results.py b/src/gsim/meep/models/results.py index 7b7bec9e..3f51d46d 100644 --- a/src/gsim/meep/models/results.py +++ b/src/gsim/meep/models/results.py @@ -471,6 +471,17 @@ def peak_ce(self) -> dict[str, float]: result[name] = -100.0 return result + def show_animation(self) -> None: + """Display field animation MP4 in Jupyter.""" + mp4_path = self.diagnostic_images.get("animation") + if mp4_path is None: + logger.info("No animation MP4 available.") + return + + from IPython.display import Video, display + + display(Video(mp4_path, embed=True, mimetype="video/mp4")) + def plot(self, db: bool = True, **kwargs: Any) -> Any: """Plot coupling efficiency vs wavelength. diff --git a/src/gsim/meep/overlay.py b/src/gsim/meep/overlay.py index e0cf97e9..f8f9c612 100644 --- a/src/gsim/meep/overlay.py +++ b/src/gsim/meep/overlay.py @@ -55,6 +55,27 @@ class DielectricOverlay: zmax: float +@dataclass(frozen=True) +class FiberSourceOverlay: + """Fiber (Gaussian beam) source metadata for 2D overlay rendering. + + Attributes: + position: (x, y) beam center on the chip surface. + z_position: Absolute z-coordinate of the source plane. + beam_waist: Gaussian beam waist radius in um. + angle_theta: Polar angle from vertical in degrees. + angle_phi: Azimuthal angle in degrees (0 = tilted in XZ plane). + direction: "down" (into chip) or "up". + """ + + position: tuple[float, float] + z_position: float + beam_waist: float + angle_theta: float + angle_phi: float + direction: str + + @dataclass(frozen=True) class SimOverlay: """Simulation cell metadata for 2D visualization overlays. @@ -65,6 +86,7 @@ class SimOverlay: dpml: PML absorber thickness in um. ports: List of port overlays for rendering. dielectrics: List of background dielectric slabs for rendering. + fiber_source: Optional fiber source overlay. """ cell_min: tuple[float, float, float] @@ -72,6 +94,7 @@ class SimOverlay: dpml: float ports: list[PortOverlay] = field(default_factory=list) dielectrics: list[DielectricOverlay] = field(default_factory=list) + fiber_source: FiberSourceOverlay | None = None def build_sim_overlay( @@ -81,6 +104,7 @@ def build_sim_overlay( z_span: float | None = None, dielectrics: list[dict[str, Any]] | None = None, component_bbox: tuple[float, float, float, float] | None = None, + fiber_source: FiberSourceOverlay | None = None, ) -> SimOverlay: """Build a SimOverlay from geometry model, domain config, and port data. @@ -94,6 +118,7 @@ def build_sim_overlay( port extension. When provided, cell XY boundaries are computed from this bbox instead of the geometry model bbox (which may include extended waveguides). + fiber_source: Optional fiber source overlay metadata. Returns: SimOverlay with computed cell boundaries and port overlays. @@ -161,4 +186,5 @@ def build_sim_overlay( dpml=dpml, ports=ports, dielectrics=diel_overlays, + fiber_source=fiber_source, ) diff --git a/src/gsim/meep/script.py b/src/gsim/meep/script.py index 2b211218..3c06eb85 100644 --- a/src/gsim/meep/script.py +++ b/src/gsim/meep/script.py @@ -567,7 +567,6 @@ def build_fiber_source(config, cell_x=None, cell_y=None, dpml=None): src=mp.GaussianSource(frequency=fcen, fwidth=fwidth), center=center, size=size, - beam_x0=mp.Vector3(position[0], position[1], z_position), beam_kdir=beam_kdir, beam_w0=beam_waist, beam_E0=beam_E0, @@ -1054,7 +1053,7 @@ def save_animation_field(sim, xy_plane, frame_counter): return frame_counter + 1 -def render_animation_frames(eps_data, extent): +def render_animation_frames(eps_data, extent, plane="xy"): """Render saved field .npz files into PNGs with fixed global colorbar. Two-pass: first finds the global field maximum across all frames, @@ -1091,6 +1090,9 @@ def render_animation_frames(eps_data, extent): from mpl_toolkits.axes_grid1 import make_axes_locatable + xlabel = "x (um)" + ylabel = "z (um)" if plane == "xz" else "y (um)" + # Pass 2 — render each frame for i, path in enumerate(npz_files): d = np.load(path) @@ -1112,9 +1114,9 @@ def render_animation_frames(eps_data, extent): divider = make_axes_locatable(ax) cax = divider.append_axes("right", size="4%", pad=0.06) fig.colorbar(im, cax=cax, label="Ey") - ax.set_title(f"Ey t={t:.2f}") - ax.set_xlabel("x (um)") - ax.set_ylabel("y (um)") + ax.set_title(f"Ey ({plane.upper()}) t={t:.2f}") + ax.set_xlabel(xlabel) + ax.set_ylabel(ylabel) fig.tight_layout() fig.savefig(f"frames/meep_frame_{i:04d}.png", dpi=150) plt.close(fig) @@ -1375,14 +1377,21 @@ def _verbose_print(sim_obj): _frame_counter = [0] # mutable container for closure _anim_plane = None + _anim_plane_id = diagnostics.get("animation_plane", "xy") if diag_animation: z_min_anim = min(l["zmin"] for l in config["layer_stack"]) z_max_anim = max(l["zmax"] for l in config["layer_stack"]) z_core_anim = (z_min_anim + z_max_anim) / 2 - _anim_plane = mp.Volume( - center=mp.Vector3(cell_center.x, cell_center.y, z_core_anim), - size=mp.Vector3(sim.cell_size.x, sim.cell_size.y, 0), - ) + if _anim_plane_id == "xz": + _anim_plane = mp.Volume( + center=mp.Vector3(cell_center.x, cell_center.y, cell_center.z), + size=mp.Vector3(sim.cell_size.x, 0, sim.cell_size.z), + ) + else: + _anim_plane = mp.Volume( + center=mp.Vector3(cell_center.x, cell_center.y, z_core_anim), + size=mp.Vector3(sim.cell_size.x, sim.cell_size.y, 0), + ) def _capture_frame(sim_obj): _frame_counter[0] = save_animation_field( @@ -1391,8 +1400,8 @@ def _capture_frame(sim_obj): step_funcs.append(mp.at_every(animation_interval, _capture_frame)) logger.info( - "Animation: saving field data every %s time units", - animation_interval, + "Animation (%s plane): saving field data every %s time units", + _anim_plane_id, animation_interval, ) stop_mode = stopping["mode"] @@ -1475,11 +1484,17 @@ def _capture_frame(sim_obj): if mp.am_master(): _ctr = _anim_plane.center _sz = _anim_plane.size - _extent = [ - _ctr.x - _sz.x / 2, _ctr.x + _sz.x / 2, - _ctr.y - _sz.y / 2, _ctr.y + _sz.y / 2, - ] - render_animation_frames(eps_data, _extent) + if _anim_plane_id == "xz": + _extent = [ + _ctr.x - _sz.x / 2, _ctr.x + _sz.x / 2, + _ctr.z - _sz.z / 2, _ctr.z + _sz.z / 2, + ] + else: + _extent = [ + _ctr.x - _sz.x / 2, _ctr.x + _sz.x / 2, + _ctr.y - _sz.y / 2, _ctr.y + _sz.y / 2, + ] + render_animation_frames(eps_data, _extent, plane=_anim_plane_id) compile_animation_mp4() if source_type == "fiber" and incident_flux is not None: diff --git a/src/gsim/meep/simulation.py b/src/gsim/meep/simulation.py index 4df40823..719da3c1 100644 --- a/src/gsim/meep/simulation.py +++ b/src/gsim/meep/simulation.py @@ -448,6 +448,7 @@ def _diagnostics_config(self) -> Any: save_epsilon_raw=self.solver.save_epsilon_raw, save_animation=self.solver.save_animation, animation_interval=self.solver.animation_interval, + animation_plane=self.solver.animation_plane, preview_only=self.solver.preview_only, verbose_interval=self.solver.verbose_interval, ) @@ -791,6 +792,21 @@ def plot_2d(self, **kwargs: Any) -> Any: result = self.build_config() + # Build fiber source overlay if applicable + fiber_overlay = None + if isinstance(self.source, FiberSource): + from gsim.meep.overlay import FiberSourceOverlay + + src_cfg = result.config.source + fiber_overlay = FiberSourceOverlay( + position=(src_cfg.position[0], src_cfg.position[1]), + z_position=src_cfg.z_position, + beam_waist=src_cfg.beam_waist, + angle_theta=src_cfg.angle_theta, + angle_phi=src_cfg.angle_phi, + direction=src_cfg.direction, + ) + return plot_2d( component=result.component, stack=self.geometry.stack, @@ -799,6 +815,7 @@ def plot_2d(self, **kwargs: Any) -> Any: extend_ports_length=0, port_data=result.config.ports, component_bbox=result.config.component_bbox, + fiber_source=fiber_overlay, **kwargs, ) diff --git a/src/gsim/meep/viz.py b/src/gsim/meep/viz.py index 0781b9ea..f9448af8 100644 --- a/src/gsim/meep/viz.py +++ b/src/gsim/meep/viz.py @@ -165,6 +165,7 @@ def build_overlay( source_port: str | None = None, port_data: list | None = None, component_bbox: list[float] | tuple[float, ...] | None = None, + fiber_source: Any | None = None, ) -> Any: """Build a SimOverlay from config, if stack is available. @@ -179,6 +180,7 @@ def build_overlay( component_bbox: Original component bbox ``[xmin, ymin, xmax, ymax]`` from :meth:`Simulation.build_config`. When provided, cell boundaries are computed from this instead of ``component.dbbox()``. + fiber_source: Optional FiberSourceOverlay for rendering. Returns: SimOverlay or None if stack isn't configured. @@ -217,6 +219,7 @@ def build_overlay( port_data, dielectrics=dielectrics, component_bbox=orig_bbox, + fiber_source=fiber_source, ) @@ -273,6 +276,7 @@ def plot_2d( extend_ports_length: float | None = None, port_data: list | None = None, component_bbox: list[float] | tuple[float, ...] | None = None, + fiber_source: Any | None = None, ) -> plt.Axes | None: """Plot 2D cross-sections of the MEEP geometry. @@ -309,5 +313,6 @@ def plot_2d( source_port, port_data=port_data, component_bbox=component_bbox, + fiber_source=fiber_source, ) return plot_prism_slices(gm, x, y, z, ax, legend, slices, overlay=overlay) From 259a3324786de646f9616a73aa7c6f793f8e22bd Mon Sep 17 00:00:00 2001 From: vahid ansari Date: Wed, 8 Apr 2026 14:21:07 +0200 Subject: [PATCH 5/7] feat: render fiber source overlay in 2D cross-section plots Draw the Gaussian beam on plot_2d slices: cone with arrow on XZ/YZ side views, dashed circle footprint on XY top-down view. --- src/gsim/common/viz/render2d.py | 155 +++++++++++++++++++++++++++++++- 1 file changed, 154 insertions(+), 1 deletion(-) diff --git a/src/gsim/common/viz/render2d.py b/src/gsim/common/viz/render2d.py index ecf57ba5..9ceac400 100644 --- a/src/gsim/common/viz/render2d.py +++ b/src/gsim/common/viz/render2d.py @@ -15,7 +15,7 @@ import matplotlib.pyplot as plt import numpy as np -from matplotlib.patches import Polygon, Rectangle +from matplotlib.patches import Circle, FancyArrowPatch, Polygon, Rectangle from gsim.common.geometry_model import GeometryModel @@ -618,6 +618,11 @@ def _draw_overlay( elif y is not None: _draw_overlay_xz(ax, cmin, cmax, pml, overlay.ports, y) + # Draw fiber source overlay + fiber = getattr(overlay, "fiber_source", None) + if fiber is not None: + _draw_fiber_source(ax, fiber, x=x, y=y, z=z) + def _draw_overlay_xy( ax: plt.Axes, @@ -846,6 +851,154 @@ def _draw_overlay_xz( ) +_FIBER_COLOR = (0.2, 0.7, 0.2) # green +_FIBER_BEAM_ALPHA = 0.15 + + +def _draw_fiber_source( + ax: plt.Axes, + fiber: Any, + *, + x: float | None, + y: float | None, + z: float | None, +) -> None: + """Draw fiber source Gaussian beam indicator on 2D slices. + + - **XZ** (y-slice): beam cone from source plane toward chip + - **YZ** (x-slice): beam cone if beam center is near x-slice + - **XY** (z-slice): beam footprint circle at the slice z + """ + fx, fy = fiber.position + fz = fiber.z_position + w0 = fiber.beam_waist + theta = np.radians(fiber.angle_theta) + phi = np.radians(fiber.angle_phi) + sign = -1.0 if fiber.direction == "down" else 1.0 + + if y is not None: + # XZ view — draw beam if center is near the y-slice + if abs(fy - y) > w0: + return + _draw_fiber_beam_side(ax, fx, fz, w0, theta, phi, sign, axis="xz") + elif x is not None: + # YZ view — draw beam if center is near the x-slice + if abs(fx - x) > w0: + return + _draw_fiber_beam_side(ax, fy, fz, w0, theta, phi, sign, axis="yz") + elif z is not None: + # XY view — draw beam footprint circle + _draw_fiber_beam_xy(ax, fx, fy, fz, z, w0, theta, phi, sign) + + +def _draw_fiber_beam_side( + ax: plt.Axes, + h_center: float, + z_src: float, + w0: float, + theta: float, + phi: float, + sign: float, + axis: str = "xz", +) -> None: + """Draw the Gaussian beam cone on XZ or YZ side views.""" + # Beam propagation length (visual, extends to source z ± some distance) + beam_len = 4.0 * w0 + + # Direction components: theta is tilt from vertical, phi selects plane + phi_comp = np.cos(phi) if axis == "xz" else np.sin(phi) + dh = np.sin(theta) * phi_comp + dz = sign * np.cos(theta) + + # Beam center line endpoints + h0, z0 = h_center, z_src + h1 = h0 + dh * beam_len + z1 = z0 + dz * beam_len + + # Draw beam envelope (expanding cone) + # At source: width = w0, at end: width = w0 * 1.5 (divergence visual) + perp_h = -dz # perpendicular in 2D + perp_z = dh + + norm = np.sqrt(perp_h**2 + perp_z**2) + if norm > 0: + perp_h /= norm + perp_z /= norm + + cone = Polygon( + [ + (h0 + perp_h * w0, z0 + perp_z * w0), + (h0 - perp_h * w0, z0 - perp_z * w0), + (h1 - perp_h * w0 * 1.5, z1 - perp_z * w0 * 1.5), + (h1 + perp_h * w0 * 1.5, z1 + perp_z * w0 * 1.5), + ], + facecolor=(*_FIBER_COLOR, _FIBER_BEAM_ALPHA), + edgecolor=(*_FIBER_COLOR, 0.5), + linewidth=0.8, + zorder=92, + label="Fiber source", + ) + ax.add_patch(cone) + + # Central beam axis arrow + ax.add_patch( + FancyArrowPatch( + (h0, z0), + (h1, z1), + arrowstyle="->", + color=_FIBER_COLOR, + linewidth=1.5, + zorder=93, + ) + ) + + # Source plane marker (horizontal line at z_src) + ax.plot( + [h0 - w0, h0 + w0], + [z0, z0], + color=_FIBER_COLOR, + linewidth=2, + linestyle="-", + zorder=93, + ) + + +def _draw_fiber_beam_xy( + ax: plt.Axes, + fx: float, + fy: float, + fz: float, + z_slice: float, + w0: float, + theta: float, + phi: float, + sign: float, +) -> None: + """Draw the Gaussian beam footprint on an XY (z-slice) view.""" + # Offset the beam center based on propagation from source to slice + dz = z_slice - fz + if abs(dz) < 1e-6: + cx, cy = fx, fy + else: + # Lateral shift due to tilt + cx = fx + dz * np.tan(theta) * np.cos(phi) / sign + cy = fy + dz * np.tan(theta) * np.sin(phi) / sign + + ax.add_patch( + Circle( + (cx, cy), + w0, + facecolor=(*_FIBER_COLOR, _FIBER_BEAM_ALPHA), + edgecolor=_FIBER_COLOR, + linewidth=1.5, + linestyle="--", + zorder=92, + label="Fiber source", + ) + ) + ax.plot(cx, cy, "+", color=_FIBER_COLOR, markersize=8, zorder=93) + + def _add_pml_rect( ax: plt.Axes, x: float, From 6f2b8474b12c4f202adbe7319a3c3ceeaf8f40bb Mon Sep 17 00:00:00 2001 From: vahid ansari Date: Thu, 9 Apr 2026 11:32:14 +0200 Subject: [PATCH 6/7] refactor: switch FiberSource to reciprocal eigenmode method Replace GaussianBeamSource with the proven gplugins approach: launch EigenModeSource from waveguide port, measure coupling into fiber mode via get_eigenmode_coefficients with oblique kpoint and NO_DIRECTION. Fixes grating coupler CE from -37 dB to physically meaningful values. Also fix animation frame saving to use MEEP's native HDF5 output (mp.output_efield_y) instead of get_array, avoiding MPI vol mismatch crashes and OOM kills on multi-rank cloud runs. --- src/gsim/meep/models/api.py | 27 +- src/gsim/meep/models/config.py | 23 +- src/gsim/meep/models/results.py | 61 +++- src/gsim/meep/script.py | 547 +++++++++++++++++++------------- src/gsim/meep/simulation.py | 26 +- tests/meep/test_meep_models.py | 23 +- 6 files changed, 432 insertions(+), 275 deletions(-) diff --git a/src/gsim/meep/models/api.py b/src/gsim/meep/models/api.py index cd19d3d2..c1ca962d 100644 --- a/src/gsim/meep/models/api.py +++ b/src/gsim/meep/models/api.py @@ -91,15 +91,24 @@ def __call__(self, **kwargs: Any) -> ModeSource: class FiberSource(BaseModel): - """Gaussian beam source simulating fiber-to-chip coupling. + """Fiber-to-chip coupling via the reciprocal method. - Launches a Gaussian beam from above (or below) to model grating - coupler excitation. Normalization uses an incident flux monitor - rather than eigenmode decomposition at the source. + Simulates grating coupler coupling efficiency by launching an + eigenmode source from the waveguide port and measuring coupling + into a fiber-like mode above the grating. By reciprocity, this + gives the same S-parameters as fiber→waveguide. + + The fiber monitor parameters (angle_theta, beam_waist, position, + z_offset) define where and how the fiber mode is measured above + the chip, not a physical source. """ model_config = ConfigDict(validate_assignment=True) + port: str | None = Field( + default=None, + description="Waveguide port to excite. None = auto-select first port.", + ) wavelength: float = Field( default=1.55, gt=0, @@ -124,7 +133,7 @@ class FiberSource(BaseModel): default=10.0, ge=0, lt=90, - description="Polar angle from vertical in degrees", + description="Fiber angle from vertical in degrees", ) angle_phi: float = Field( default=0.0, @@ -132,20 +141,20 @@ class FiberSource(BaseModel): ) polarization: Literal["TE", "TM"] = Field( default="TE", - description="Beam polarization", + description="Fiber polarization", ) position: list[float] | None = Field( default=None, - description="Beam center [x, y]. None = auto (component bbox center).", + description="Fiber center [x, y] above grating. None = auto (bbox center).", ) z_offset: float = Field( default=1.0, gt=0, - description="Distance above stack top to place source plane (um)", + description="Distance above core top to place fiber monitor plane (um)", ) direction: Literal["down", "up"] = Field( default="down", - description="Beam propagation direction ('down' = into chip)", + description="Fiber direction ('down' = fiber above chip looking down)", ) def __call__(self, **kwargs: Any) -> FiberSource: diff --git a/src/gsim/meep/models/config.py b/src/gsim/meep/models/config.py index f7717351..6d00e127 100644 --- a/src/gsim/meep/models/config.py +++ b/src/gsim/meep/models/config.py @@ -174,11 +174,12 @@ def compute_fwidth(self, fcen: float, monitor_df: float) -> float: class FiberSourceConfig(BaseModel): - """Gaussian beam source config for fiber-to-chip coupling simulation. + """Reciprocal fiber coupling config for grating coupler simulation. - Sent as JSON to the cloud runner, which builds an ``mp.GaussianBeamSource``. - The ``z_position`` is the absolute z-coordinate of the source plane - (resolved from the API-level ``z_offset`` + stack top). + Sent as JSON to the cloud runner. The runner builds an + ``mp.EigenModeSource`` at the waveguide ``port`` and a fiber + mode monitor at ``z_position``. By reciprocity, the coupling + into the fiber mode equals the fiber→waveguide coupling. """ model_config = ConfigDict(validate_assignment=True) @@ -187,15 +188,21 @@ class FiberSourceConfig(BaseModel): default="fiber", description="Source type discriminator.", ) - beam_waist: float = Field(gt=0, description="Gaussian beam waist radius in um") + port: str | None = Field( + default=None, + description="Waveguide port for EigenModeSource. None = auto (first port).", + ) + beam_waist: float = Field(gt=0, description="Fiber mode waist radius in um") angle_theta: float = Field( - ge=0, lt=90, description="Polar angle from vertical (deg)" + ge=0, lt=90, description="Fiber angle from vertical (deg)" ) angle_phi: float = Field(description="Azimuthal angle (deg)") polarization: Literal["TE", "TM"] direction: Literal["down", "up"] - position: list[float] = Field(description="Beam center [x, y]") - z_position: float = Field(description="Absolute z-coordinate of source plane") + position: list[float] = Field(description="Fiber center [x, y] above grating") + z_position: float = Field( + description="Absolute z-coordinate of fiber monitor plane" + ) fwidth: float = Field(gt=0, description="Source fwidth in frequency units") diff --git a/src/gsim/meep/models/results.py b/src/gsim/meep/models/results.py index 3f51d46d..037ff48d 100644 --- a/src/gsim/meep/models/results.py +++ b/src/gsim/meep/models/results.py @@ -106,16 +106,12 @@ def from_csv(cls, path: str | Path) -> SParameterResult: ("geometry_yz", "meep_geometry_yz.png"), ("fields_xy", "meep_fields_xy.png"), ("animation", "meep_animation.mp4"), + ("animation_data", "meep_animation_data.npz"), ]: img_path = path.parent / filename if img_path.exists(): diagnostic_images[key] = str(img_path) - # Detect animation frame PNGs - frame_pngs = sorted(path.parent.glob("meep_frame_*.png")) - if frame_pngs: - diagnostic_images["animation_frames"] = str(path.parent) - return cls( wavelengths=wavelengths, s_params=s_params, @@ -156,16 +152,12 @@ def from_directory(cls, directory: str | Path) -> SParameterResult: ("geometry_yz", "meep_geometry_yz.png"), ("fields_xy", "meep_fields_xy.png"), ("animation", "meep_animation.mp4"), + ("animation_data", "meep_animation_data.npz"), ]: img_path = directory / filename if img_path.exists(): diagnostic_images[key] = str(img_path) - # Detect animation frame PNGs - frame_pngs = sorted(directory.glob("meep_frame_*.png")) - if frame_pngs: - diagnostic_images["animation_frames"] = str(directory) - return cls( debug_info=debug_info, diagnostic_images=diagnostic_images, @@ -196,6 +188,30 @@ def show_animation(self) -> None: display(Video(mp4_path, embed=True, mimetype="video/mp4")) + def load_animation_data(self) -> dict[str, Any] | None: + """Load raw animation frame data from the consolidated .npz. + + Returns: + Dict with keys ``fields`` (N, H, W), ``times`` (N,), + ``eps_data`` (H, W), ``extent`` (4,), ``plane`` (str), + or None if not available. + """ + npz_path = self.diagnostic_images.get("animation_data") + if npz_path is None: + logger.info("No animation data .npz available.") + return None + + import numpy as np + + data = np.load(npz_path) + return { + "fields": data["fields"], + "times": data["times"], + "eps_data": data["eps_data"], + "extent": data["extent"], + "plane": str(data["plane"]), + } + def plot( self, db: bool = True, @@ -439,6 +455,7 @@ def from_csv(cls, path: str | Path) -> CouplingResult: ("geometry_yz", "meep_geometry_yz.png"), ("fields_xy", "meep_fields_xy.png"), ("animation", "meep_animation.mp4"), + ("animation_data", "meep_animation_data.npz"), ]: img_path = path.parent / filename if img_path.exists(): @@ -482,6 +499,30 @@ def show_animation(self) -> None: display(Video(mp4_path, embed=True, mimetype="video/mp4")) + def load_animation_data(self) -> dict[str, Any] | None: + """Load raw animation frame data from the consolidated .npz. + + Returns: + Dict with keys ``fields`` (N, H, W), ``times`` (N,), + ``eps_data`` (H, W), ``extent`` (4,), ``plane`` (str), + or None if not available. + """ + npz_path = self.diagnostic_images.get("animation_data") + if npz_path is None: + logger.info("No animation data .npz available.") + return None + + import numpy as np + + data = np.load(npz_path) + return { + "fields": data["fields"], + "times": data["times"], + "eps_data": data["eps_data"], + "extent": data["extent"], + "plane": str(data["plane"]), + } + def plot(self, db: bool = True, **kwargs: Any) -> Any: """Plot coupling efficiency vs wavelength. diff --git a/src/gsim/meep/script.py b/src/gsim/meep/script.py index 3c06eb85..882db396 100644 --- a/src/gsim/meep/script.py +++ b/src/gsim/meep/script.py @@ -495,127 +495,70 @@ def build_monitors(config, sim): # Fiber source: Gaussian beam + incident flux # --------------------------------------------------------------------------- -def build_fiber_source(config, cell_x=None, cell_y=None, dpml=None): - """Build a MEEP GaussianBeamSource from fiber source config. +def build_fiber_monitor(config, sim): + """Build a fiber mode monitor for reciprocal coupling measurement. - Creates a Gaussian beam launched from above (or below) the device - to simulate fiber-to-chip coupling (grating coupler excitation). + Creates a horizontal mode monitor at the fiber position above (or + below) the grating. The runner will later call + ``get_eigenmode_coefficients`` on this monitor with an oblique + kpoint matching the fiber angle to extract the coupling coefficient. - Args: - config: Simulation config dict. - cell_x: Cell x dimension (if None, computed from component_bbox). - cell_y: Cell y dimension (if None, computed from component_bbox). - dpml: PML thickness (if None, read from config). + Returns: + meep ModeMonitor object """ fdtd = config["fdtd"] fcen = fdtd["fcen"] + df = fdtd["df"] + nfreq = fdtd["num_freqs"] src_cfg = config["source"] - fwidth = src_cfg["fwidth"] - beam_waist = src_cfg["beam_waist"] - theta_deg = src_cfg["angle_theta"] - phi_deg = src_cfg["angle_phi"] - polarization = src_cfg["polarization"] - direction = src_cfg["direction"] position = src_cfg["position"] z_position = src_cfg["z_position"] - domain = config["domain"] - if dpml is None: - dpml = domain["dpml"] - - # Compute beam k-direction from angles - theta = math.radians(theta_deg) - phi = math.radians(phi_deg) - if direction == "down": - # Beam going downward (-z), tilted by theta from vertical - kx = math.sin(theta) * math.cos(phi) - ky = math.sin(theta) * math.sin(phi) - kz = -math.cos(theta) - else: - kx = math.sin(theta) * math.cos(phi) - ky = math.sin(theta) * math.sin(phi) - kz = math.cos(theta) - - beam_kdir = mp.Vector3(kx, ky, kz) - - # Polarization: TE = E in y (for phi=0), TM = E in plane of incidence - if polarization == "TE": - beam_E0 = mp.Vector3(0, 1, 0) - else: - # TM: E in the plane of incidence (xz for phi=0) - beam_E0 = mp.Vector3(math.cos(theta), 0, math.sin(theta)) + dpml = domain["dpml"] - # Source plane: horizontal, spans cell minus PML - if cell_x is not None and cell_y is not None: - sx = cell_x - 2 * dpml - sy = cell_y - 2 * dpml - else: - # Fallback: compute from component bbox - component_bbox = config["component_bbox"] - if component_bbox is not None: - bbox_left, bbox_bottom, bbox_right, bbox_top = component_bbox - else: - bbox_left, bbox_bottom, bbox_right, bbox_top = -10, -10, 10, 10 - margin_xy = domain["margin_xy"] - sx = (bbox_right - bbox_left) + 2 * margin_xy - sy = (bbox_top - bbox_bottom) + 2 * margin_xy + sx = sim.cell_size.x - 2 * dpml + sy = sim.cell_size.y - 2 * dpml center = mp.Vector3(position[0], position[1], z_position) size = mp.Vector3(sx, sy, 0) - source = mp.GaussianBeamSource( - src=mp.GaussianSource(frequency=fcen, fwidth=fwidth), - center=center, - size=size, - beam_kdir=beam_kdir, - beam_w0=beam_waist, - beam_E0=beam_E0, + fiber_mon = sim.add_mode_monitor( + fcen, df, nfreq, + mp.ModeRegion(center=center, size=size), ) + return fiber_mon - return [source], center +def _get_n_at_z(config, z): + """Find the refractive index of the dielectric region at height z. -def build_incident_flux_monitor(config, sim, source_center): - """Build a flux monitor near the source to measure incident power. - - Placed 0.5 um below (toward device) the source center for a - 'down' beam, or 0.5 um above for an 'up' beam. Spans the full - cell minus PML in XY. + Walks through the dielectrics list in the config and returns + the refractive index of the first region that contains z. + Falls back to 1.0 (air) if no region contains z. """ - fdtd = config["fdtd"] - fcen = fdtd["fcen"] - df = fdtd["df"] - nfreq = fdtd["num_freqs"] - src_cfg = config["source"] - direction = src_cfg["direction"] - domain = config["domain"] - dpml = domain["dpml"] + materials = config.get("materials", {}) + for diel in config.get("dielectrics", []): + if diel["zmin"] <= z <= diel["zmax"]: + mat_name = diel["material"] + mat = materials.get(mat_name) + if mat and "refractive_index" in mat: + return mat["refractive_index"] + return 1.0 - # Offset toward the device - offset = 0.5 - if direction == "down": - z_monitor = source_center.z - offset - else: - z_monitor = source_center.z + offset - # Span full cell minus PML in XY - sx = sim.cell_size.x - 2 * dpml - sy = sim.cell_size.y - 2 * dpml - - center = mp.Vector3(source_center.x, source_center.y, z_monitor) - size = mp.Vector3(sx, sy, 0) - - flux = sim.add_flux( - fcen, df, nfreq, - mp.FluxRegion(center=center, size=size), - ) - return flux +def extract_fiber_coupling(config, sim, monitors, fiber_monitor): + """Extract fiber coupling via reciprocal eigenmode decomposition. + An EigenModeSource at the waveguide port launches light toward the + grating. This function measures: -def extract_coupling_efficiency(config, sim, monitors, incident_flux): - """Extract coupling efficiency at each port via eigenmode decomposition. + 1. The incident eigenmode coefficient at the source port (for + normalization). + 2. The coupling into the fiber mode at the fiber monitor plane + using ``get_eigenmode_coefficients`` with ``direction=NO_DIRECTION`` + and an oblique kpoint matching the fiber angle (gplugins approach). - CE = |alpha_waveguide|^2 / incident_flux for each port and frequency. + CE = |alpha_fiber|^2 / |alpha_incident|^2 Returns: (ce_params, debug_data) tuple @@ -626,52 +569,100 @@ def extract_coupling_efficiency(config, sim, monitors, incident_flux): df = fdtd["df"] freqs = np.linspace(fcen - df / 2, fcen + df / 2, nfreq) - # Get total incident flux (array of nfreq values). - # Use abs() because a downward beam produces negative flux through a - # +z-normal plane (MEEP convention: positive flux = +z direction). - inc_flux_raw = mp.get_fluxes(incident_flux) - inc_flux = [abs(f) for f in inc_flux_raw] + src_cfg = config["source"] + theta_deg = src_cfg["angle_theta"] + phi_deg = src_cfg["angle_phi"] + direction = src_cfg["direction"] + z_position = src_cfg["z_position"] - debug_data = { - "incident_flux": [float(f) for f in inc_flux], - "incident_flux_raw": [float(f) for f in inc_flux_raw], - "eigenmode_info": {}, - } + # --- Incident coefficient at waveguide source port --- + source_port = None + for p in config["ports"]: + if p["is_source"]: + source_port = p + break + if source_port is None: + logger.error("No source port found for fiber coupling extraction") + return {}, {} - ce_params = {} + src_kp = _port_kpoint(source_port) + src_ob = sim.get_eigenmode_coefficients( + monitors[source_port["name"]], [1], eig_parity=mp.NO_PARITY, + kpoint_func=lambda f, n, kp=src_kp: kp, + ) + src_dir = source_port["direction"] + # Incoming direction for the source port + in_idx = 0 if src_dir == "+" else 1 + incident_coeffs = src_ob.alpha[0, :, in_idx] - for port in config["ports"]: - port_name = port["name"] - if port_name not in monitors: - continue + # --- Fiber mode kpoint --- + theta = math.radians(theta_deg) + phi = math.radians(phi_deg) + n_clad = _get_n_at_z(config, z_position) + logger.info("Fiber monitor n_clad=%.3f at z=%.3f", n_clad, z_position) - # Eigenmode decomposition at waveguide port - port_kp = _port_kpoint(port) - ob = sim.get_eigenmode_coefficients( - monitors[port_name], [1], eig_parity=mp.NO_PARITY, - kpoint_func=lambda f, n, kp=port_kp: kp, - ) + # k-direction for the fiber mode (unit vector) + if direction == "down": + kx = math.sin(theta) * math.cos(phi) + ky = math.sin(theta) * math.sin(phi) + kz = -math.cos(theta) + else: + kx = math.sin(theta) * math.cos(phi) + ky = math.sin(theta) * math.sin(phi) + kz = math.cos(theta) - # Use the forward-propagating mode (outgoing from grating into waveguide) - # Port direction = direction of incoming mode from outside - # For grating coupler output ports, outgoing = into waveguide - port_dir = port["direction"] - # Outgoing mode: opposite to "incoming" direction convention - out_idx = 1 if port_dir == "+" else 0 - alpha = ob.alpha[0, :, out_idx] + # Scale kpoint by fcen * n_clad (gplugins convention) + fiber_kpoint = mp.Vector3(kx, ky, kz) * (fcen * n_clad) - # CE = |alpha|^2 / incident_flux - ce = np.zeros(nfreq) - for fi in range(nfreq): - if inc_flux[fi] > 0: - ce[fi] = float(abs(alpha[fi]) ** 2 / inc_flux[fi]) + # --- Eigenmode decomposition at fiber monitor --- + fiber_ob = sim.get_eigenmode_coefficients( + fiber_monitor, [1], + eig_parity=mp.NO_PARITY, + direction=mp.NO_DIRECTION, + kpoint_func=lambda f, n, kp=fiber_kpoint: kp, + ) - ce_params[port_name] = ce + # With NO_DIRECTION, pick the coefficient with larger magnitude + a0 = fiber_ob.alpha[0, :, 0] + a1 = fiber_ob.alpha[0, :, 1] + fiber_alpha = np.where(np.abs(a0) >= np.abs(a1), a0, a1) - debug_data["eigenmode_info"][port_name] = { - "alpha_mag": [float(abs(a)) for a in alpha], - "ce": [float(c) for c in ce], - } + debug_data = { + "incident_coefficients": { + "port": source_port["name"], + "alpha_mag": [float(abs(c)) for c in incident_coeffs], + }, + "fiber_coefficients": { + "alpha_0_mag": [float(abs(a)) for a in a0], + "alpha_1_mag": [float(abs(a)) for a in a1], + "alpha_used_mag": [float(abs(a)) for a in fiber_alpha], + "n_clad": n_clad, + "kpoint": [float(fiber_kpoint.x), float(fiber_kpoint.y), + float(fiber_kpoint.z)], + }, + "eigenmode_info": {}, + } + + # --- CE = |alpha_fiber|^2 / |alpha_incident|^2 --- + ce_params = {} + ce = np.zeros(nfreq) + for fi in range(nfreq): + if abs(incident_coeffs[fi]) > 0: + ce[fi] = float( + abs(fiber_alpha[fi]) ** 2 / abs(incident_coeffs[fi]) ** 2 + ) + ce_params["fiber"] = ce + + debug_data["eigenmode_info"]["fiber"] = { + "alpha_mag": [float(abs(a)) for a in fiber_alpha], + "ce": [float(c) for c in ce], + } + + logger.info( + "Fiber CE at center freq: %.4e (%.2f dB)", + ce[nfreq // 2], + 10 * np.log10(max(ce[nfreq // 2], 1e-30)), + ) return ce_params, debug_data @@ -1032,29 +1023,139 @@ def save_field_snapshot(sim, config, cell_center): logger.warning("Field snapshot failed: %s", e) -def save_animation_field(sim, xy_plane, frame_counter): - """Save raw 2D field data during time-stepping (no plotting). +def save_animation_field(sim, anim_plane, frame_counter, plane_id="xy"): + """Save animation frame via MEEP's native HDF5 output (MPI-safe). - Saves a compressed .npz with the Ey field array and timestamp. - Rendering with a globally fixed colorbar happens after sim.run(). + Uses ``mp.output_efield_y`` with ``mp.in_volume`` which is + properly MPI-collective without the ``get_array`` vol-mismatch + bug on cross-section planes. HDF5 files are rendered to PNG + after ``sim.run()`` completes. Returns: Incremented frame counter. """ - field_data = np.real(sim.get_array(vol=xy_plane, component=mp.Ey)) + os.makedirs("frames", exist_ok=True) + # MEEP's output functions handle MPI natively + mp.output_efield_y(sim, mp.Volume( + center=anim_plane.center, size=anim_plane.size, + )) + # MEEP writes ey-TTTTTT.TT.h5 — rename to our naming convention t = sim.meep_time() if mp.am_master(): - os.makedirs("frames", exist_ok=True) - np.savez_compressed( - f"frames/meep_field_{frame_counter:04d}.npz", - field=field_data, - time=t, - ) + # Find the most recently written h5 file + import glob + h5_files = sorted(glob.glob("ey-*.h5"), key=os.path.getmtime) + if h5_files: + latest = h5_files[-1] + dest = f"frames/field_{frame_counter:04d}.h5" + os.rename(latest, dest) return frame_counter + 1 -def render_animation_frames(eps_data, extent, plane="xy"): - """Render saved field .npz files into PNGs with fixed global colorbar. +def render_h5_animation_frames(plane_id="xy"): + """Render HDF5 field data to PNG frames after simulation completes. + + Reads per-step .h5 files saved by ``save_animation_field`` and + renders them with a globally consistent colorbar. + """ + if not HAS_MATPLOTLIB or not mp.am_master(): + return + import glob + + try: + import h5py + except ImportError: + logger.warning("h5py not available — skipping animation frame rendering") + return + + h5_files = sorted(glob.glob("frames/field_*.h5")) + if not h5_files: + logger.warning("No HDF5 field data found for animation") + return + + # First pass: find global min/max for consistent colorbar + vmax = 0 + for path in h5_files: + with h5py.File(path, "r") as hf: + key = list(hf.keys())[0] + data = hf[key][:] + vmax = max(vmax, np.max(np.abs(data))) + + if vmax == 0: + vmax = 1.0 + + # Second pass: render frames + for i, path in enumerate(h5_files): + with h5py.File(path, "r") as hf: + key = list(hf.keys())[0] + data = hf[key][:] + + fig, ax = plt.subplots(figsize=(12, 4)) + im = ax.imshow( + data.T if data.ndim == 2 else data.squeeze().T, + origin="lower", cmap="RdBu_r", + vmin=-vmax, vmax=vmax, aspect="auto", + ) + ax.set_title(f"Ey ({plane_id.upper()}) frame {i}") + plt.colorbar(im, ax=ax, label="Ey") + fig.savefig( + f"frames/meep_frame_{i:04d}.png", + dpi=100, bbox_inches="tight", + ) + plt.close(fig) + + logger.info("Rendered %d animation frames from HDF5 data", len(h5_files)) + + +def consolidate_animation_data(eps_data, extent, plane="xy"): + """Consolidate per-frame .npz files into a single meep_animation_data.npz. + + Loads all per-frame field snapshots, bundles them with the epsilon + background and extent into one file, then removes the per-frame files. + + Returns: + Path to the consolidated file, or None if no frames found. + """ + import glob + + npz_files = sorted(glob.glob("frames/meep_field_*.npz")) + if not npz_files: + logger.warning("No field data files found to consolidate") + return None + + fields = [] + times = [] + for path in npz_files: + d = np.load(path) + fields.append(d["field"]) + times.append(float(d["time"])) + + np.savez_compressed( + "meep_animation_data.npz", + fields=np.array(fields), + times=np.array(times), + eps_data=eps_data, + extent=np.array(extent), + plane=plane, + ) + + # Clean up per-frame intermediates + for path in npz_files: + os.remove(path) + # Remove frames dir if empty + try: + os.rmdir("frames") + except OSError: + pass + + logger.info( + "Consolidated %d frames into meep_animation_data.npz", len(npz_files) + ) + return "meep_animation_data.npz" + + +def render_animation_frames(anim_data_path="meep_animation_data.npz"): + """Render frames from consolidated .npz into PNGs for MP4 compilation. Two-pass: first finds the global field maximum across all frames, then renders every frame with the same vmin/vmax so field decay is @@ -1062,30 +1163,31 @@ def render_animation_frames(eps_data, extent, plane="xy"): Call only on master rank after sim.run(). """ - import glob - if not HAS_MATPLOTLIB: logger.warning( - "matplotlib not available, .npz field files kept but not rendered" + "matplotlib not available, animation data kept in .npz" ) return - npz_files = sorted(glob.glob("frames/meep_field_*.npz")) - if not npz_files: - logger.warning("No field data files found to render") + if not os.path.exists(anim_data_path): + logger.warning("No animation data file found: %s", anim_data_path) return - # Pass 1 — global max - global_max = 0.0 - for path in npz_files: - d = np.load(path) - global_max = max(global_max, float(np.max(np.abs(d["field"])))) + data = np.load(anim_data_path) + fields = data["fields"] + times = data["times"] + eps_data = data["eps_data"] + extent = data["extent"].tolist() + plane = str(data["plane"]) + + n_frames = len(fields) + global_max = float(np.max(np.abs(fields))) if global_max == 0: global_max = 1.0 logger.info( "Rendering %d frames (Ey global max = %.4g) ...", - len(npz_files), global_max, + n_frames, global_max, ) from mpl_toolkits.axes_grid1 import make_axes_locatable @@ -1093,19 +1195,16 @@ def render_animation_frames(eps_data, extent, plane="xy"): xlabel = "x (um)" ylabel = "z (um)" if plane == "xz" else "y (um)" - # Pass 2 — render each frame - for i, path in enumerate(npz_files): - d = np.load(path) - field = d["field"] - t = float(d["time"]) + os.makedirs("frames", exist_ok=True) + for i in range(n_frames): + field = fields[i] + t = float(times[i]) fig, ax = plt.subplots(1, 1, figsize=(5, 4)) - # Epsilon background (grayscale) ax.imshow( eps_data.T, origin="lower", extent=extent, cmap="binary", interpolation="none", ) - # Field overlay with fixed colorbar im = ax.imshow( field.T, origin="lower", extent=extent, cmap="RdBu", interpolation="spline36", alpha=0.8, @@ -1121,20 +1220,18 @@ def render_animation_frames(eps_data, extent, plane="xy"): fig.savefig(f"frames/meep_frame_{i:04d}.png", dpi=150) plt.close(fig) - # Clean up .npz intermediates - for path in npz_files: - os.remove(path) - - logger.info("Rendered %d frames with fixed colorbar", len(npz_files)) + logger.info("Rendered %d frames with fixed colorbar", n_frames) def compile_animation_mp4(fps=15): """Stitch meep_frame_*.png into meep_animation.mp4 via ffmpeg. - Falls back gracefully if ffmpeg is not available — frame PNGs - are still kept as individual files. + On success, removes the intermediate frame PNGs (raw data is + preserved in meep_animation_data.npz). Falls back gracefully + if ffmpeg is not available. """ import glob + import shutil import subprocess frames = sorted(glob.glob("frames/meep_frame_*.png")) @@ -1157,11 +1254,13 @@ def compile_animation_mp4(fps=15): capture_output=True, ) logger.info("Saved meep_animation.mp4") + # Clean up intermediate PNGs — raw data lives in .npz + shutil.rmtree("frames", ignore_errors=True) except FileNotFoundError: - logger.warning("ffmpeg not found — frame PNGs saved but MP4 not created") + logger.warning("ffmpeg not found — frame PNGs kept in frames/") except subprocess.CalledProcessError as e: logger.warning("ffmpeg failed: %s", e.stderr.decode()[:500]) - logger.info("Frame PNGs are still available in frames/") + logger.info("Frame PNGs kept in frames/") def save_epsilon_raw(sim, config, cell_center): @@ -1239,14 +1338,14 @@ def main(): dpml = domain["dpml"] margin_xy = domain["margin_xy"] - # For fiber source, ensure the cell extends to include the source z + # For fiber source, ensure the cell extends to include the fiber monitor z if source_type == "fiber": - src_z = config["source"]["z_position"] - src_dir = config["source"]["direction"] - if src_dir == "down" and src_z > z_max: - z_max = src_z + 0.5 # 0.5 um margin above source - elif src_dir == "up" and src_z < z_min: - z_min = src_z - 0.5 + mon_z = config["source"]["z_position"] + mon_dir = config["source"]["direction"] + if mon_dir == "down" and mon_z > z_max: + z_max = mon_z + 0.5 # 0.5 um margin above fiber monitor + elif mon_dir == "up" and mon_z < z_min: + z_min = mon_z - 0.5 # XY: margin_xy is gap between geometry bbox and PML cell_x = (bbox_right - bbox_left) + 2 * (margin_xy + dpml) @@ -1260,16 +1359,9 @@ def main(): (z_max + z_min) / 2, ) - # Build sources AFTER cell dimensions are known (fiber source needs them) - fiber_source_center = None - if source_type == "fiber": - logger.info("Building Gaussian beam source...") - sources, fiber_source_center = build_fiber_source( - config, cell_x=cell_x, cell_y=cell_y, dpml=dpml, - ) - else: - logger.info("Building eigenmode sources...") - sources = build_sources(config) + # Build eigenmode sources — same for both mode and fiber (reciprocal) paths + logger.info("Building eigenmode sources...") + sources = build_sources(config) if not sources: logger.error("No source found in config") @@ -1317,6 +1409,9 @@ def main(): spx_tol = accuracy["subpixel_tol"] if spx_tol != 1e-4: sim_kwargs["subpixel_tol"] = spx_tol + # Suppress meep's C++ geometry dump (vertex lists for every prism). + # All important info is already logged by this script. + mp.verbosity(0) sim = mp.Simulation(**sim_kwargs) # --- Diagnostics & preview mode --- @@ -1342,11 +1437,11 @@ def main(): logger.info("Building monitors...") monitors = build_monitors(config, sim) - # For fiber source, also build incident flux monitor - incident_flux = None - if source_type == "fiber" and fiber_source_center is not None: - logger.info("Building incident flux monitor...") - incident_flux = build_incident_flux_monitor(config, sim, fiber_source_center) + # For fiber source, build the fiber mode monitor (reciprocal method) + fiber_monitor = None + if source_type == "fiber": + logger.info("Building fiber mode monitor (reciprocal)...") + fiber_monitor = build_fiber_monitor(config, sim) stopping = config["stopping"] run_after = stopping["run_after_sources"] @@ -1382,20 +1477,39 @@ def _verbose_print(sim_obj): z_min_anim = min(l["zmin"] for l in config["layer_stack"]) z_max_anim = max(l["zmax"] for l in config["layer_stack"]) z_core_anim = (z_min_anim + z_max_anim) / 2 + + # Snap coordinates to grid and shrink slightly to avoid MPI + # chunk boundary issues with get_array on cross-section planes. + dx = 1.0 / resolution + def _snap(val): + return round(val * resolution) / resolution + if _anim_plane_id == "xz": _anim_plane = mp.Volume( - center=mp.Vector3(cell_center.x, cell_center.y, cell_center.z), - size=mp.Vector3(sim.cell_size.x, 0, sim.cell_size.z), + center=mp.Vector3( + _snap(cell_center.x), _snap(cell_center.y), + _snap(cell_center.z), + ), + size=mp.Vector3( + sim.cell_size.x - 2 * dx, 0, + sim.cell_size.z - 2 * dx, + ), ) else: _anim_plane = mp.Volume( - center=mp.Vector3(cell_center.x, cell_center.y, z_core_anim), - size=mp.Vector3(sim.cell_size.x, sim.cell_size.y, 0), + center=mp.Vector3( + _snap(cell_center.x), _snap(cell_center.y), + _snap(z_core_anim), + ), + size=mp.Vector3( + sim.cell_size.x - 2 * dx, + sim.cell_size.y - 2 * dx, 0, + ), ) def _capture_frame(sim_obj): _frame_counter[0] = save_animation_field( - sim_obj, _anim_plane, _frame_counter[0] + sim_obj, _anim_plane, _frame_counter[0], _anim_plane_id ) step_funcs.append(mp.at_every(animation_interval, _capture_frame)) @@ -1478,29 +1592,16 @@ def _capture_frame(sim_obj): if diag_fields: save_field_snapshot(sim, config, cell_center) - if diag_animation and _frame_counter[0] > 0 and _anim_plane is not None: - # get_array is collective — all ranks must call - eps_data = sim.get_array(vol=_anim_plane, component=mp.Dielectric) + if diag_animation and _frame_counter[0] > 0: + # Render HDF5 field data to PNG frames, then compile MP4 + render_h5_animation_frames(plane=_anim_plane_id) if mp.am_master(): - _ctr = _anim_plane.center - _sz = _anim_plane.size - if _anim_plane_id == "xz": - _extent = [ - _ctr.x - _sz.x / 2, _ctr.x + _sz.x / 2, - _ctr.z - _sz.z / 2, _ctr.z + _sz.z / 2, - ] - else: - _extent = [ - _ctr.x - _sz.x / 2, _ctr.x + _sz.x / 2, - _ctr.y - _sz.y / 2, _ctr.y + _sz.y / 2, - ] - render_animation_frames(eps_data, _extent, plane=_anim_plane_id) compile_animation_mp4() - if source_type == "fiber" and incident_flux is not None: - logger.info("Extracting coupling efficiency...") - ce_params, debug_data = extract_coupling_efficiency( - config, sim, monitors, incident_flux + if source_type == "fiber" and fiber_monitor is not None: + logger.info("Extracting fiber coupling (reciprocal method)...") + ce_params, debug_data = extract_fiber_coupling( + config, sim, monitors, fiber_monitor ) debug_data["_meep_time"] = sim.meep_time() debug_data["_timesteps"] = sim.timestep() diff --git a/src/gsim/meep/simulation.py b/src/gsim/meep/simulation.py index 719da3c1..b8088038 100644 --- a/src/gsim/meep/simulation.py +++ b/src/gsim/meep/simulation.py @@ -334,10 +334,10 @@ def _source_config(self) -> Any: ) def _fiber_source_config(self, stack: Any) -> Any: - """Translate FiberSource → FiberSourceConfig. + """Translate FiberSource → FiberSourceConfig (reciprocal method). - Resolves position (auto-center on component bbox) and computes - absolute z from stack top + z_offset. + Resolves fiber monitor position and the waveguide port for + the EigenModeSource. """ from gsim.meep.models.config import FiberSourceConfig @@ -357,8 +357,6 @@ def _fiber_source_config(self, stack: Any) -> Any: ] # Compute absolute z from core layer top + offset. - # Use the highest-n layer (waveguide core) as reference, NOT the - # topmost layer (which could be a metal far above the grating). from gsim.meep.ports import _find_highest_n_layer core_layer, _ = _find_highest_n_layer(stack) @@ -366,7 +364,6 @@ def _fiber_source_config(self, stack: Any) -> Any: z_ref_top = core_layer.zmax z_ref_bottom = core_layer.zmin else: - # Fallback: use full stack extent z_ref_top = max(layer.zmax for layer in stack.layers.values()) z_ref_bottom = min(layer.zmin for layer in stack.layers.values()) @@ -375,11 +372,12 @@ def _fiber_source_config(self, stack: Any) -> Any: else: z_position = z_ref_bottom - src.z_offset - # Compute fwidth + # Compute fwidth (same as ModeSource — eigenmode source) wl_cfg = self._wavelength_config() fwidth = max(3 * wl_cfg.df, 0.2 * wl_cfg.fcen) return FiberSourceConfig( + port=src.port, beam_waist=src.beam_waist, angle_theta=src.angle_theta, angle_phi=src.angle_phi, @@ -564,9 +562,17 @@ def build_config(self) -> BuildResult: ) used_materials.add(diel["material"]) - # Extract port info from original component + # Extract port info from original component. + # For fiber (reciprocal): the waveguide port IS the EigenModeSource. if is_fiber: - port_infos = extract_port_info(original_component, stack, mark_source=False) + fiber_port = source_cfg.port + port_infos = extract_port_info( + original_component, stack, source_port=fiber_port + ) + # Resolve auto-selected port name back into config + if fiber_port is None and port_infos: + resolved_port = next((p.name for p in port_infos if p.is_source), None) + source_cfg = source_cfg.model_copy(update={"port": resolved_port}) else: port_infos = extract_port_info( original_component, stack, source_port=source_cfg.port @@ -577,7 +583,7 @@ def build_config(self) -> BuildResult: used_materials, overrides=self._material_overrides() ) - # Compute source fwidth (for mode source only; fiber already has fwidth) + # Compute source fwidth if is_fiber: source_for_config = source_cfg else: diff --git a/tests/meep/test_meep_models.py b/tests/meep/test_meep_models.py index 17e68d19..a02afb5e 100644 --- a/tests/meep/test_meep_models.py +++ b/tests/meep/test_meep_models.py @@ -1547,33 +1547,26 @@ def test_plot_linear(self): class TestScriptFiberSource: - """Test that the runner script includes fiber source support.""" + """Test that the runner script includes reciprocal fiber coupling support.""" - def test_script_has_gaussian_beam(self): + def test_script_has_fiber_monitor_builder(self): from gsim.meep.script import generate_meep_script script = generate_meep_script() - assert "GaussianBeamSource" in script + assert "build_fiber_monitor" in script - def test_script_has_fiber_source_builder(self): + def test_script_has_fiber_coupling_extractor(self): from gsim.meep.script import generate_meep_script script = generate_meep_script() - assert "build_fiber_source" in script - - def test_script_has_incident_flux(self): - from gsim.meep.script import generate_meep_script - - script = generate_meep_script() - assert "build_incident_flux_monitor" in script - assert "add_flux" in script + assert "extract_fiber_coupling" in script + assert "save_ce_results" in script - def test_script_has_coupling_efficiency(self): + def test_script_has_n_at_z_helper(self): from gsim.meep.script import generate_meep_script script = generate_meep_script() - assert "extract_coupling_efficiency" in script - assert "save_ce_results" in script + assert "_get_n_at_z" in script def test_script_branches_on_source_type(self): from gsim.meep.script import generate_meep_script From 7b1e2f847085ba2349db33530988904c1c24e107 Mon Sep 17 00:00:00 2001 From: vahid ansari Date: Thu, 9 Apr 2026 12:36:17 +0200 Subject: [PATCH 7/7] update notebook --- nbs/meep_grating_coupler.ipynb | 201 +++++++++++++-------------------- 1 file changed, 81 insertions(+), 120 deletions(-) diff --git a/nbs/meep_grating_coupler.ipynb b/nbs/meep_grating_coupler.ipynb index ee613d85..703a0a76 100644 --- a/nbs/meep_grating_coupler.ipynb +++ b/nbs/meep_grating_coupler.ipynb @@ -27,21 +27,10 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "2", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from ubcpdk import PDK, cells\n", "\n", @@ -70,21 +59,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "4", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Stack validation: PASSED\n", - "Warnings:\n", - " - No stack configured. Will use active PDK with defaults.\n", - " - Stopping: fixed (time=110.0)\n" - ] - } - ], + "outputs": [], "source": [ "from gsim import meep\n", "\n", @@ -98,15 +76,15 @@ " wavelength_span=0.07,\n", " num_freqs=21,\n", " beam_waist=5.2,\n", - " angle_theta=10.0,\n", + " angle_theta=0.0,\n", " z_offset=2.0,\n", " position=[-25, 0],\n", ")\n", "\n", "sim.monitors = [\"o1\"]\n", "sim.domain(pml=1.0, margin=1.0, margin_z_above=3.0)\n", - "sim.solver(resolution=25, save_animation=True, verbose_interval=5.0)\n", - "sim.solver.stop_after_sources(time=110)\n", + "sim.solver(resolution=20, save_animation=False, verbose_interval=5.0)\n", + "sim.solver.stop_after_sources(time=50)\n", "sim.solver.animation_plane = \"xz\"\n", "\n", "print(sim.validate_config())" @@ -122,33 +100,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "6", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/vahid/doplaydo/gsim/src/gsim/meep/simulation.py:576: UserWarning: Material 'Aluminum' has no optical properties (refractive_index) — layer will be omitted from simulation. Use sim.set_material('Aluminum', refractive_index=...) to include it.\n", - " material_data = resolve_materials(\n", - "/Users/vahid/doplaydo/gsim/src/gsim/meep/simulation.py:576: UserWarning: Material 'TiN' has no optical properties (refractive_index) — layer will be omitted from simulation. Use sim.set_material('TiN', refractive_index=...) to include it.\n", - " material_data = resolve_materials(\n", - "/Users/vahid/doplaydo/gsim/src/gsim/meep/simulation.py:576: UserWarning: Material 'passive' has no optical properties (refractive_index) — layer will be omitted from simulation. Use sim.set_material('passive', refractive_index=...) to include it.\n", - " material_data = resolve_materials(\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "sim.plot_2d(slices=\"xyz\")" ] @@ -163,34 +118,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "8", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " meep-8abb470b running 10m 49s\n" - ] - }, - { - "ename": "HTTPStatusError", - "evalue": "Server error '503 Service Unavailable' for url 'https://api.gdsfactory.com/api/simulation/sdk/v1/job/019d6bff-3478-7a42-9818-cd3a3c393cf4'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/503", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mHTTPStatusError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[4]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m result = \u001b[43msim\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/doplaydo/gsim/src/gsim/meep/simulation.py:777\u001b[39m, in \u001b[36mSimulation.run\u001b[39m\u001b[34m(self, parent_dir, verbose, wait)\u001b[39m\n\u001b[32m 775\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m wait:\n\u001b[32m 776\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m._job_id\n\u001b[32m--> \u001b[39m\u001b[32m777\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mwait_for_results\u001b[49m\u001b[43m(\u001b[49m\u001b[43mverbose\u001b[49m\u001b[43m=\u001b[49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparent_dir\u001b[49m\u001b[43m=\u001b[49m\u001b[43mparent_dir\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/doplaydo/gsim/src/gsim/meep/simulation.py:744\u001b[39m, in \u001b[36mSimulation.wait_for_results\u001b[39m\u001b[34m(self, verbose, parent_dir)\u001b[39m\n\u001b[32m 742\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._job_id \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 743\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[33m\"\u001b[39m\u001b[33mNo job submitted yet\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m--> \u001b[39m\u001b[32m744\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mgcloud\u001b[49m\u001b[43m.\u001b[49m\u001b[43mwait_for_results\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 745\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_job_id\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mverbose\u001b[49m\u001b[43m=\u001b[49m\u001b[43mverbose\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparent_dir\u001b[49m\u001b[43m=\u001b[49m\u001b[43mparent_dir\u001b[49m\n\u001b[32m 746\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/doplaydo/gsim/src/gsim/gcloud.py:430\u001b[39m, in \u001b[36mwait_for_results\u001b[39m\u001b[34m(verbose, parent_dir, poll_interval, *job_ids)\u001b[39m\n\u001b[32m 428\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m jid, job \u001b[38;5;129;01min\u001b[39;00m jobs.items():\n\u001b[32m 429\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m job.status \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m terminal:\n\u001b[32m--> \u001b[39m\u001b[32m430\u001b[39m jobs[jid] = \u001b[43msim\u001b[49m\u001b[43m.\u001b[49m\u001b[43mget_job\u001b[49m\u001b[43m(\u001b[49m\u001b[43mjid\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 431\u001b[39m \u001b[38;5;66;03m# Stream logs when running\u001b[39;00m\n\u001b[32m 432\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m verbose == \u001b[33m\"\u001b[39m\u001b[33mfull\u001b[39m\u001b[33m\"\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m jobs[jid].status == sim.SimStatus.RUNNING:\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/doplaydo/gsim/.venv/lib/python3.12/site-packages/gdsfactoryplus/sim.py:303\u001b[39m, in \u001b[36mget_job\u001b[39m\u001b[34m(job_id)\u001b[39m\n\u001b[32m 298\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m httpx.Client(timeout=TIMEOUT) \u001b[38;5;28;01mas\u001b[39;00m client:\n\u001b[32m 299\u001b[39m response = client.get(\n\u001b[32m 300\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m_base_url()\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m/job/\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mjob_id\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m,\n\u001b[32m 301\u001b[39m headers=_headers(),\n\u001b[32m 302\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m303\u001b[39m \u001b[43mresponse\u001b[49m\u001b[43m.\u001b[49m\u001b[43mraise_for_status\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 304\u001b[39m data = response.json()\n\u001b[32m 305\u001b[39m job = Job.model_validate(data[\u001b[33m\"\u001b[39m\u001b[33mdata\u001b[39m\u001b[33m\"\u001b[39m])\n", - "\u001b[36mFile \u001b[39m\u001b[32m~/doplaydo/gsim/.venv/lib/python3.12/site-packages/httpx/_models.py:829\u001b[39m, in \u001b[36mResponse.raise_for_status\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 827\u001b[39m error_type = error_types.get(status_class, \u001b[33m\"\u001b[39m\u001b[33mInvalid status code\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m 828\u001b[39m message = message.format(\u001b[38;5;28mself\u001b[39m, error_type=error_type)\n\u001b[32m--> \u001b[39m\u001b[32m829\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m HTTPStatusError(message, request=request, response=\u001b[38;5;28mself\u001b[39m)\n", - "\u001b[31mHTTPStatusError\u001b[39m: Server error '503 Service Unavailable' for url 'https://api.gdsfactory.com/api/simulation/sdk/v1/job/019d6bff-3478-7a42-9818-cd3a3c393cf4'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/503" - ] - } - ], + "outputs": [], "source": [ "result = sim.run()" ] @@ -208,19 +139,7 @@ "execution_count": null, "id": "10", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "result.plot(db=True)" ] @@ -230,16 +149,7 @@ "execution_count": null, "id": "11", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Peak coupling efficiency (dB):\n", - " o1: -37.33 dB\n" - ] - } - ], + "outputs": [], "source": [ "print(\"Peak coupling efficiency (dB):\")\n", "for port, ce_db in result.peak_ce.items():\n", @@ -251,23 +161,7 @@ "execution_count": null, "id": "12", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "result.show_animation()" ] @@ -278,6 +172,73 @@ "id": "fd1b0fc6", "metadata": {}, "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.animation import FuncAnimation\n", + "from matplotlib.colors import LogNorm\n", + "from IPython.display import HTML\n", + "\n", + "data = result.load_animation_data()\n", + "fields_abs = np.abs(data[\"fields\"])\n", + "vmax = fields_abs.max()\n", + "floor = vmax * 1e-4 # 4 orders of magnitude below peak\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 4))\n", + "ax.imshow(data[\"eps_data\"].T, origin=\"lower\", extent=data[\"extent\"], cmap=\"binary\")\n", + "im = ax.imshow(\n", + " np.clip(fields_abs[0].T, floor, None),\n", + " origin=\"lower\",\n", + " extent=data[\"extent\"],\n", + " cmap=\"hot\",\n", + " alpha=0.8,\n", + " norm=LogNorm(vmin=floor, vmax=vmax),\n", + ")\n", + "fig.colorbar(im, ax=ax, label=\"|Ey|\")\n", + "ax.set_xlabel(\"x (µm)\")\n", + "ax.set_ylabel(\"y (µm)\")\n", + "title = ax.set_title(f\"|Ey| (log) t={data['times'][0]:.2f}\")\n", + "\n", + "\n", + "def update(i):\n", + " im.set_data(np.clip(fields_abs[i].T, floor, None))\n", + " title.set_text(f\"|Ey| (log) t={data['times'][i]:.2f}\")\n", + " return [im, title]\n", + "\n", + "\n", + "ani = FuncAnimation(fig, update, frames=len(data[\"times\"]), interval=67)\n", + "plt.close(fig)\n", + "HTML(ani.to_jshtml())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e6037483", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c305697c", + "metadata": {}, + "outputs": [], + "source": [ + "from gsim import gcloud\n", + "\n", + "job_id = gcloud.upload(\"gc_diagnostic_v2a\", \"meep\")\n", + "gcloud.start(job_id)\n", + "result = gcloud.wait_for_results(job_id, verbose=\"full\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c6aa0f29", + "metadata": {}, + "outputs": [], "source": [] } ],