flexcompute-core 0.0.1.dev0__py3-none-any.whl → 0.0.1.dev2__py3-none-any.whl

flexcompute/core/_migration/__init__.py

@@ -0,0 +1 @@
+"""Temporary migration-only namespace for the first flexcompute development release."""

flexcompute/core/_migration/em/__init__.py

@@ -0,0 +1 @@
+"""Temporary migrated EM contracts for the first flexcompute development release."""

flexcompute/core/_migration/em/numerical/README.md

@@ -0,0 +1,109 @@
+# flexcompute.core._migration.em.numerical
+
+`flexcompute.core._migration.em.numerical` owns portable numerical kernels and
+deterministic schema-level EM conventions shared across packages. These are the
+formulas, sign conventions, and result interpretations that would otherwise be
+duplicated across runtime consumers.
+
+```mermaid
+flowchart TD
+  Public["public tidy3d"]
+  Solver["em_solver"]
+  Schema["flexcompute.core._migration.em.schema"]
+  Adapter["flexcompute.core._migration.em.numerical.schema"]
+  Raw["flexcompute.core._migration.em.numerical.raw"]
+
+  Public --> Raw
+  Solver --> Raw
+  Schema --> Raw
+  Schema --> Adapter
+  Adapter --> Raw
+```
+
+Paths below are relative to this directory unless they begin with `flex/` or
+`src/`.
+
+## Layers
+
+| Layer | Primary input | May import |
+| --- | --- | --- |
+| `raw` | arrays, scalars, simple typed payloads | third-party array libraries only |
+| `schema` | `flexcompute.core._migration.em.schema` model instances | `flexcompute.core._migration.em.schema` and `raw` |
+
+A schema adapter unpacks a model into keyword scalars once, then delegates the
+arithmetic: `schema/source_time.py:10-23` against the keyword-only raw
+signature it calls at `raw/source_time.py:10-22`.
+
+The split is contract-enforced, and the enforcement is deliberately asymmetric.
+
+| Contract | Asserts |
+| --- | --- |
+| `migrated-em-raw-numerical` | `numerical.raw` imports none of `tidy3d`, `flexcompute.rf`, `tidy3d_extras`, `flexcompute.core._migration.em.schema`, `em_solver` |
+| `flexcompute-core` | `flexcompute.core._migration.em` imports no public product and no runtime consumer; `flexcompute.core._migration.em.schema` is allowed within the package |
+
+Both live in `flex/utils/repository-tests/compute/.importlinter` and are checked
+by import-linter across the whole EM import graph, so a breach is reported
+wherever the import is written rather than only when this package's own tests
+run.
+
+## Consumers
+
+| Consumer | Entry point | Example |
+| --- | --- | --- |
+| public Tidy3D | `raw` | `flex/public/tidy3d/tidy3d/components/source/time.py:249` |
+| `flexcompute.core._migration.em.schema` | `raw`, or `schema` where a model must be unpacked | `flex/public/flexcompute-core/src/flexcompute/core/_migration/em/schema/tidy3d/components/data/monitor_data.py:78-82`; `flex/public/flexcompute-core/src/flexcompute/core/_migration/em/schema/tidy3d/components/source/time.py:13` |
+| `em_solver` | `raw` | in `src/Tidy3DCore/em-solver/em_solver/`: `eme_kernels.py:9`, `setup.py:25`, `point_cloud.py:13` |
+
+Public Tidy3D calls `raw` directly instead of owning a public adapter
+namespace. Only `flexcompute.core._migration.em.schema` has an adapter layer, and only where a schema
+model has to be unpacked first.
+
+## Conventions owned here
+
+| Convention | Kernel | Behavior |
+| --- | --- | --- |
+| power and Poynting | `raw/field_data.py:14-17`, `:33-46` | `0.5 * E x H*`, complex. The kernels conjugate but do not take the real part. |
+| planar monitor flux correction | `schema/field_data.py` | Preserves the centered Yee-grid flux convention after fields are interpolated to the exact monitor plane. |
+| colocated integration | `raw/mode.py:10-16` | `colocate=None` means `True`; `colocate` and `use_colocated_integration` combine with OR, not AND. Resolver at `:19-31`: an explicit argument wins, otherwise any colocated monitor makes the call colocated. |
+| snap margin | `raw/microwave.py:8-11` | `(2, 2, 2)` when field data is colocated, `(0, 0, 0)` otherwise, keeping automatic current paths off interpolated H fields near metal surfaces (call site and reason: `flex/public/flexcompute-core/src/flexcompute/core/_migration/em/schema/tidy3d/components/microwave/path_integrals/mode_plane_analyzer.py:60-62`). |
+| current sign | `raw/microwave.py:14-17` | Opposite the voltage polarity, because current flows from the plus to the minus terminal (`flex/public/flexcompute-core/src/flexcompute/core/_migration/em/schema/tidy3d/components/microwave/path_integrals/integrals/auto.py:79-84`). The voltage integral takes the polarity unchanged at `:63`. |
+| FDTD result diagnostics | `schema/solver_diagnostics.py` | Maps schema simulation context and solver completion flags to shared warning messages without owning logging. |
+
+Read the kernel when the exact behavior matters; this table routes, it does not
+restate.
+
+## What stays out of raw
+
+`raw` owns conventions duplicated in Python across public Tidy3D,
+`flexcompute.core._migration.em.schema`, and `em_solver`. A source family whose evaluation is owned by
+a native runtime is not duplicated Python convention, so its wrapper stays at
+the runtime boundary instead.
+
+`BroadbandPulse` is the worked example. Public Tidy3D delegates pulse
+evaluation to the extras native extension at
+`flex/public/tidy3d/tidy3d/components/source/time.py:681-692`; the schema class
+raises `SetupError` at
+`flex/public/flexcompute-core/src/flexcompute/core/_migration/em/schema/tidy3d/components/source/time.py:649-655`.
+There is no shared Python kernel between the two, and moving runtime-owned
+implementation detail into `raw` would cost `raw` its product-neutrality.
+
+## Validation
+
+```bash
+uv run --project flex/public/flexcompute-core pytest flex/public/flexcompute-core/tests/_migration/em
+
+# The layer split is an import contract, so it needs the whole EM graph rather
+# than this package alone. From a full checkout:
+PYTHONPATH=flex/utils/repository-tests/compute \
+  python3 -m repository_tests.compute.import_boundaries
+```
+
+The contract runner exits 2 in a narrow worktree that does not contain every
+package root, so run it from a full checkout or let CI run it.
+
+| Test or contract | Covers |
+| --- | --- |
+| the `migrated-em` and `migrated-em-raw-numerical` contracts | the layer split |
+| `flex/public/flexcompute-core/tests/_migration/em/test_shared_numerical_kernels.py` | the conventions above, at `:25` (power and overlap signs and conjugation), `:280` (mode sorting and colocation), `:315` (path-integral sign and margin) |
+| `flex/public/flexcompute-core/tests/_migration/em/test_shared_numerical_mirrors.py` | the same behavior at the consumer and schema-wrapper level, mirroring the equivalent public Tidy3D client tests |
+| `flex/public/flexcompute-core/tests/_migration/em/test_schema_field_data_numerics.py` | planar field-monitor flux correction and its deliberate no-op cases |

flexcompute/core/_migration/em/numerical/__init__.py

@@ -0,0 +1 @@
+"""Shared numerical kernels and schema-facing numerical adapters for EM packages."""

flexcompute/core/_migration/em/numerical/raw/__init__.py

@@ -0,0 +1 @@
+"""Product-neutral shared numerical kernels."""

flexcompute/core/_migration/em/numerical/raw/diffraction.py

@@ -0,0 +1,55 @@
+"""Shared diffraction-order numerical kernels."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+COS_THETA_THRESH = 1e-5
+C_0 = 2.99792458e14
+
+
+def shifted_orders(orders: tuple[int, ...], bloch_vec: float | np.ndarray) -> np.ndarray:
+    """Return diffraction orders shifted by the Bloch vector."""
+
+    return bloch_vec + np.atleast_2d(orders).T
+
+
+def reciprocal_coords_from_epsilon(
+    orders: Any,
+    *,
+    size: float,
+    bloch_vec: float | np.ndarray,
+    frequency: float,
+    epsilon: complex,
+) -> np.ndarray:
+    """Return normalized reciprocal coordinates from order, Bloch, and epsilon data."""
+
+    if size == 0:
+        return np.atleast_2d(0)
+    order_tuple = tuple(int(order) for order in np.atleast_1d(orders))
+    bloch_array = shifted_orders(order_tuple, bloch_vec)
+    return bloch_array / size * C_0 / frequency / np.real(np.sqrt(epsilon))
+
+
+def amplitude_norm(theta_data: np.ndarray, eta: np.ndarray | complex) -> np.ndarray:
+    """Return diffraction amplitude normalization."""
+
+    cos_theta = np.cos(np.nan_to_num(theta_data))
+    cos_theta[cos_theta <= COS_THETA_THRESH] = np.inf
+    return 1.0 / np.sqrt(2.0 * np.asarray(eta)) / np.sqrt(cos_theta)
+
+
+def angle_is_propagating(angle_theta: float) -> bool:
+    """Return whether a diffraction angle is valid for a propagating order."""
+
+    return bool(np.isfinite(angle_theta) and np.cos(angle_theta) > COS_THETA_THRESH)
+
+
+def bloch_vec_at_freq(bloch_vec: float | np.ndarray, freq_index: int) -> float:
+    """Return scalar Bloch vector for a monitor frequency index."""
+
+    if np.ndim(bloch_vec) == 0:
+        return float(bloch_vec)
+    return float(np.asarray(bloch_vec)[freq_index])

flexcompute/core/_migration/em/numerical/raw/field_data.py

@@ -0,0 +1,204 @@
+"""Shared field-data numerical kernels."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+OUTER_DOT_BLOCK_TARGET_BYTES = 64 * 1024**2
+OUTER_DOT_BLOCK_MIN_SIZE = 8
+OUTER_DOT_BLOCK_MAX_SIZE = 64
+
+
+def complex_poynting(e1: Any, e2: Any, h1: Any, h2: Any) -> Any:
+    """Return the complex time-averaged Poynting component ``0.5 E x H*``."""
+
+    return 0.5 * (e1 * h2.conj() - e2 * h1.conj())
+
+
+def instantaneous_power_flow(
+    E: tuple[np.ndarray, np.ndarray],
+    H: tuple[np.ndarray, np.ndarray],
+    dS: tuple[np.ndarray, np.ndarray],
+) -> np.ndarray:
+    """Compute instantaneous power flow for real fields."""
+
+    dS_EuHv, dS_EvHu = dS
+    Eu, Ev = E
+    Hu, Hv = H
+    return np.sum((Eu * Hv) * dS_EuHv - (Ev * Hu) * dS_EvHu, axis=(-2, -1))
+
+
+def complex_power_flow(
+    E: tuple[np.ndarray, np.ndarray],
+    H: tuple[np.ndarray, np.ndarray],
+    dS: tuple[np.ndarray, np.ndarray],
+) -> np.ndarray:
+    """Compute ``0.5 * E x H*`` integrated with Yee-grid area elements."""
+
+    dS_EuHv, dS_EvHu = dS
+    Eu, Ev = E
+    Hu, Hv = H
+    return 0.5 * np.sum(
+        (Eu * np.conj(Hv)) * dS_EuHv - (Ev * np.conj(Hu)) * dS_EvHu,
+        axis=(-2, -1),
+    )
+
+
+def dot(
+    E1: tuple[np.ndarray, np.ndarray],
+    H1: tuple[np.ndarray, np.ndarray],
+    E2: tuple[np.ndarray, np.ndarray],
+    H2: tuple[np.ndarray, np.ndarray],
+    dS: tuple[np.ndarray, np.ndarray],
+    conjugate: bool = False,
+    bidirectional: bool = True,
+) -> np.ndarray:
+    """Compute the modal overlap integral."""
+
+    dS_EuHv, dS_EvHu = dS
+    E1u, E1v = E1
+    H1u, H1v = H1
+    E2u, E2v = E2
+    H2u, H2v = H2
+
+    dS_EuHv_flat = np.asarray(dS_EuHv).reshape(-1)
+    dS_EvHu_flat = np.asarray(dS_EvHu).reshape(-1)
+
+    if bidirectional:
+        term_specs = (
+            (0.25, E1u, H2v, dS_EuHv_flat),
+            (0.25, H1v, E2u, dS_EuHv_flat),
+            (-0.25, E1v, H2u, dS_EvHu_flat),
+            (-0.25, H1u, E2v, dS_EvHu_flat),
+        )
+    else:
+        term_specs = (
+            (0.5, E1u, H2v, dS_EuHv_flat),
+            (-0.5, E1v, H2u, dS_EvHu_flat),
+        )
+
+    batch_shape = np.broadcast_shapes(
+        *(left.shape[:-2] for _, left, _, _ in term_specs),
+        *(right.shape[:-2] for _, _, right, _ in term_specs),
+    )
+    dtype = np.result_type(
+        *(a.dtype for _, a, _, _ in term_specs),
+        *(a.dtype for _, _, a, _ in term_specs),
+        *(d.dtype for _, _, _, d in term_specs),
+    )
+    result = np.zeros(batch_shape, dtype=dtype)
+
+    for coeff, left, right, d_area in term_specs:
+        left_flat = left.reshape(*left.shape[:-2], -1)
+        right_flat = right.reshape(*right.shape[:-2], -1)
+        if conjugate:
+            left_flat = np.conj(left_flat)
+        result += (
+            coeff
+            * ((left_flat * d_area)[..., np.newaxis, :] @ right_flat[..., :, np.newaxis])[..., 0, 0]
+        )
+
+    return result
+
+
+def outer_dot(
+    E1: tuple[np.ndarray, np.ndarray],
+    H1: tuple[np.ndarray, np.ndarray],
+    E2: tuple[np.ndarray, np.ndarray],
+    H2: tuple[np.ndarray, np.ndarray],
+    dS: tuple[np.ndarray, np.ndarray],
+    conjugate: bool = False,
+    bidirectional: bool = True,
+) -> np.ndarray:
+    """Compute a pairwise modal-overlap matrix."""
+
+    E1u, E1v = E1
+    H1u, H1v = H1
+    E2u, E2v = E2
+    H2u, H2v = H2
+    dS_EuHv, dS_EvHu = dS
+
+    n_modes_1 = E1u.shape[-3]
+    n_modes_2 = E2u.shape[-3]
+    broadcast_shape = E1u.shape[:-3]
+    num_grid_points = E1u.shape[-2] * E1u.shape[-1]
+    dtype = np.result_type(
+        E1u.dtype,
+        E1v.dtype,
+        H1u.dtype,
+        H1v.dtype,
+        E2u.dtype,
+        E2v.dtype,
+        H2u.dtype,
+        H2v.dtype,
+        np.asarray(dS_EuHv).dtype,
+        np.asarray(dS_EvHu).dtype,
+    )
+
+    S = np.zeros((*broadcast_shape, n_modes_1, n_modes_2), dtype=dtype)
+    if n_modes_1 == 0 or n_modes_2 == 0:
+        return S
+
+    if conjugate:
+        E1u, E1v = np.conj(E1u), np.conj(E1v)
+        H1u, H1v = np.conj(H1u), np.conj(H1v)
+
+    itemsize = np.dtype(dtype).itemsize
+    if num_grid_points == 0:
+        block_size = OUTER_DOT_BLOCK_MAX_SIZE
+    else:
+        block_size = int(OUTER_DOT_BLOCK_TARGET_BYTES // (num_grid_points * itemsize))
+        block_size = max(OUTER_DOT_BLOCK_MIN_SIZE, block_size)
+        block_size = min(OUTER_DOT_BLOCK_MAX_SIZE, block_size)
+
+    block_size_left = min(n_modes_1, block_size)
+    block_size_right = min(n_modes_2, block_size)
+
+    dS_EuHv_flat = np.asarray(dS_EuHv).reshape(-1)
+    dS_EvHu_flat = np.asarray(dS_EvHu).reshape(-1)
+    if dS_EuHv_flat.size != num_grid_points or dS_EvHu_flat.size != num_grid_points:
+        raise ValueError("Tangential area shape mismatch in blocked outer_dot kernel.")
+
+    num_batches = int(np.prod(broadcast_shape, dtype=int)) if broadcast_shape else 1
+    out_flat = S.reshape(num_batches, n_modes_1, n_modes_2)
+
+    if bidirectional:
+        term_specs = (
+            (0.25, E1u, H2v, dS_EuHv_flat),
+            (0.25, H1v, E2u, dS_EuHv_flat),
+            (-0.25, E1v, H2u, dS_EvHu_flat),
+            (-0.25, H1u, E2v, dS_EvHu_flat),
+        )
+    else:
+        term_specs = (
+            (0.5, E1u, H2v, dS_EuHv_flat),
+            (-0.5, E1v, H2u, dS_EvHu_flat),
+        )
+
+    flattened_terms = tuple(
+        (
+            coeff,
+            left.reshape(num_batches, n_modes_1, num_grid_points),
+            right.reshape(num_batches, n_modes_2, num_grid_points),
+            d_area,
+        )
+        for coeff, left, right, d_area in term_specs
+    )
+
+    for batch_idx in range(num_batches):
+        out_batch = out_flat[batch_idx]
+        for coeff, left_term, right_term, d_area in flattened_terms:
+            left_batch = left_term[batch_idx]
+            right_batch = right_term[batch_idx]
+            for i0 in range(0, n_modes_1, block_size_left):
+                i0_end = min(i0 + block_size_left, n_modes_1)
+                left_block = left_batch[i0:i0_end]
+                for i1 in range(0, n_modes_2, block_size_right):
+                    i1_end = min(i1 + block_size_right, n_modes_2)
+                    right_block = right_batch[i1:i1_end]
+                    weighted_right = right_block * d_area
+                    out_batch[i0:i0_end, i1:i1_end] += coeff * (left_block @ weighted_right.T)
+
+    return S

flexcompute/core/_migration/em/numerical/raw/grid.py

@@ -0,0 +1,149 @@
+"""Shared Yee-grid integration and grid-correction kernels."""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+import numpy as np
+
+C_0 = 2.99792458e14
+
+
+def clipped_widths(coords: np.ndarray, lo: float, hi: float) -> np.ndarray:
+    """Return consecutive widths of ``coords`` clipped to ``[lo, hi]``."""
+
+    clipped = np.clip(coords, lo, hi)
+    return clipped[1:] - clipped[:-1]
+
+
+def colocated_edges_1d(
+    sample_boundaries: np.ndarray,
+    mnt_min: float = -np.inf,
+    mnt_max: float = np.inf,
+) -> np.ndarray:
+    """Return integration-cell edges around boundary-colocated samples."""
+
+    sample_boundaries = np.asarray(sample_boundaries)
+    centers = (sample_boundaries[1:] + sample_boundaries[:-1]) / 2
+    edges = np.concatenate([[sample_boundaries[0]], centers, [sample_boundaries[-1]]])
+    return np.clip(edges, mnt_min, mnt_max)
+
+
+def colocated_widths_1d(
+    sample_boundaries: np.ndarray,
+    mnt_min: float = -np.inf,
+    mnt_max: float = np.inf,
+) -> np.ndarray:
+    """Return per-sample widths for boundary-colocated data."""
+
+    sample_boundaries = np.asarray(sample_boundaries)
+    if sample_boundaries.size <= 1:
+        return np.array([1.0])
+    edges = colocated_edges_1d(sample_boundaries, mnt_min, mnt_max)
+    return edges[1:] - edges[:-1]
+
+
+def yee_primal_dual_widths_1d(
+    boundaries: np.ndarray,
+    mnt_min: float = -np.inf,
+    mnt_max: float = np.inf,
+    *,
+    valid_bounds: tuple[float, float] | None = None,
+    keep_inds: np.ndarray | None = None,
+) -> tuple[np.ndarray, np.ndarray]:
+    """Return per-cell primal and dual widths for native Yee-staggered samples.
+
+    When ``keep_inds`` holds the sorted cell indices kept by a downsampled
+    (``interval_space``) recording and selects a strict subset of cells, the
+    exact per-cell widths no longer tile the kept samples, so each returned
+    width is instead the box rule over the kept native positions of its
+    staggered set (midpoints between kept neighbors, clipped like
+    ``colocated_widths_1d``), which cannot over-count past the outermost kept
+    sample. Both returned arrays then have length ``len(keep_inds)``.
+    """
+
+    boundaries = np.asarray(boundaries)
+    if boundaries.size == 2:
+        return np.array([1.0]), np.array([1.0])
+
+    valid_min, valid_max = valid_bounds if valid_bounds is not None else boundaries[[0, -1]]
+    integration_min = max(mnt_min, float(valid_min))
+    integration_max = min(mnt_max, float(valid_max))
+
+    field_centers = (boundaries[:-1] + boundaries[1:]) / 2
+
+    if keep_inds is not None and len(keep_inds) < boundaries.size - 1:
+        # Downsampled recording: box rule over the kept native positions of each staggered set.
+        primal_widths = colocated_widths_1d(
+            field_centers[keep_inds], integration_min, integration_max
+        )
+        dual_widths = colocated_widths_1d(
+            boundaries[:-1][keep_inds], integration_min, integration_max
+        )
+        return primal_widths, dual_widths
+
+    centers = np.concatenate([[integration_min], field_centers])
+    bnds = np.concatenate([boundaries[:-1], [integration_max]])
+
+    primal_widths = clipped_widths(bnds, integration_min, integration_max)
+    dual_widths = clipped_widths(centers, integration_min, integration_max)
+    return primal_widths, dual_widths
+
+
+def mode_grid_correction_factors(
+    primal_distances: Any,
+    dual_distances: Any,
+    n_complex: Any,
+    freqs: Any,
+    *,
+    angle_theta: float,
+    direction: str,
+) -> tuple[Any, Any]:
+    """Return primal and dual mode-grid phase corrections before wrapper interpolation."""
+
+    cos_theta = np.cos(angle_theta)
+    k_vec = cos_theta * 2 * np.pi * n_complex * freqs / C_0
+    if direction == "-":
+        k_vec *= -1
+    return (
+        np.exp(1j * k_vec * primal_distances),
+        np.exp(1j * k_vec * dual_distances),
+    )
+
+
+def closest_adjacent_grid_offsets(grid_coords: Any, position: float) -> tuple[float, ...]:
+    """Return signed offsets from ``position`` to its adjacent grid pair.
+
+    A single-point grid returns a one-element tuple. Otherwise the pair is the
+    grid point closest to ``position`` and its neighbor on the position's side,
+    clamped to stay in range: a position past the outermost point yields the
+    outermost in-range pair, which is then one-sided and classified as
+    unbracketed by ``classify_plane_offsets``. The clamp also keeps the low end
+    from wrapping to the far side of the grid.
+    """
+
+    offsets = np.asarray(grid_coords, dtype=float) - position
+    if offsets.size == 1:
+        return (float(offsets[0]),)
+    closest_ind = int(np.argmin(np.abs(offsets)))
+    first_ind = closest_ind - 1 if offsets[closest_ind] > 0 else closest_ind
+    first_ind = min(max(first_ind, 0), offsets.size - 2)
+    return (float(offsets[first_ind]), float(offsets[first_ind + 1]))
+
+
+def classify_plane_offsets(offsets: Any) -> Literal["on_grid", "unbracketed", "bracketed"]:
+    """Classify how a plane phase correction follows from its grid offsets.
+
+    Returns ``"on_grid"`` for a lone offset lying exactly on the plane (the
+    correction there is exactly unity), ``"unbracketed"`` when no bracketing
+    pair exists -- a lone off-plane point, or all offsets on one side of the
+    plane -- and ``"bracketed"`` when linear interpolation to the plane is
+    defined (an offset exactly at zero interpolates to the exact endpoint).
+    """
+
+    offsets = np.asarray(offsets, dtype=float)
+    if offsets.size == 1:
+        return "on_grid" if offsets[0] == 0.0 else "unbracketed"
+    if offsets.min() > 0 or offsets.max() < 0:
+        return "unbracketed"
+    return "bracketed"

flexcompute/core/_migration/em/numerical/raw/medium.py

@@ -0,0 +1,97 @@
+"""Shared medium dispersion numerical kernels."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import autograd.numpy as np
+
+C_0 = 2.99792458e14
+MU_0 = 1.25663706212e-12
+EPSILON_0 = 1 / (MU_0 * C_0**2)
+
+
+def eps_sigma_to_eps_complex(permittivity: Any, conductivity: Any, frequency: Any) -> Any:
+    """Convert permittivity/conductivity to complex permittivity."""
+
+    return permittivity + 1j * conductivity / (2 * np.pi * frequency * EPSILON_0)
+
+
+def medium_eps_model(permittivity: float, conductivity: float, frequency: Any) -> Any:
+    """Return nondispersive medium complex permittivity."""
+
+    return eps_sigma_to_eps_complex(permittivity, conductivity, frequency)
+
+
+def pole_residue_eps_model(eps_inf: float, poles: Any, frequency: Any) -> Any:
+    """Return pole-residue complex permittivity."""
+
+    omega = 2 * np.pi * frequency
+    eps = eps_inf + 0 * frequency + 0.0j
+    for a, c in poles:
+        a_cc = np.conj(a)
+        c_cc = np.conj(c)
+        eps = eps - c / (1j * omega + a)
+        eps = eps - c_cc / (1j * omega + a_cc)
+    return eps
+
+
+def lo_to_eps_model(poles: Any, eps_inf: float, frequency: Any) -> Any:
+    """Return longitudinal/transverse-optical pole complex permittivity."""
+
+    omega = 2 * np.pi * frequency
+    eps = eps_inf
+    for omega_lo, gamma_lo, omega_to, gamma_to in poles:
+        eps *= omega_lo**2 - omega**2 - 1j * omega * gamma_lo
+        eps /= omega_to**2 - omega**2 - 1j * omega * gamma_to
+    return eps
+
+
+def sellmeier_n_model(coeffs: Any, frequency: Any) -> Any:
+    """Return Sellmeier refractive index from coefficients and frequency."""
+
+    wvl = C_0 / np.array(frequency)
+    wvl2 = wvl**2
+    n_squared = 1.0
+    for B, C in coeffs:
+        n_squared = n_squared + B * wvl2 / (wvl2 - C)
+    return np.sqrt(n_squared + 0j)
+
+
+def nk_to_eps_complex(n: Any, k: Any = 0) -> Any:
+    """Convert refractive-index components to complex permittivity."""
+
+    return (n + 1j * k) ** 2
+
+
+def sellmeier_eps_model(coeffs: Any, frequency: Any) -> Any:
+    """Return Sellmeier complex permittivity."""
+
+    return nk_to_eps_complex(sellmeier_n_model(coeffs, frequency))
+
+
+def lorentz_eps_model(eps_inf: float, coeffs: Any, frequency: Any) -> Any:
+    """Return Lorentz complex permittivity."""
+
+    eps = eps_inf + 0.0j
+    for de, f, delta in coeffs:
+        eps = eps + (de * f**2) / (f**2 - 2j * frequency * delta - frequency**2)
+    return eps
+
+
+def drude_eps_model(eps_inf: float, coeffs: Any, frequency: Any) -> Any:
+    """Return Drude complex permittivity."""
+
+    eps = eps_inf + 0.0j
+    for f, delta in coeffs:
+        eps = eps - (f**2) / (frequency**2 + 1j * frequency * delta)
+    return eps
+
+
+def debye_eps_model(eps_inf: float, coeffs: Any, frequency: Any) -> Any:
+    """Return Debye complex permittivity."""
+
+    eps = eps_inf + 0.0j
+    for de, tau in coeffs:
+        eps = eps + de / (1 - 1j * frequency * tau)
+    return eps

flexcompute/core/_migration/em/numerical/raw/microwave.py

@@ -0,0 +1,25 @@
+"""Shared microwave path-integral convention kernels."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+
+def snap_margin_for_field_colocation(field_data_colocated: bool) -> tuple[int, int, int]:
+    """Return snap margin used to keep automatic current paths off interpolated H fields."""
+
+    return (2, 2, 2) if field_data_colocated else (0, 0, 0)
+
+
+def path_integral_current_sign(polarity: Literal["+", "-"]) -> Literal["+", "-"]:
+    """Return current-integral sign for a lumped-element voltage polarity."""
+
+    return "-" if polarity == "+" else "+"
+
+
+def axis_size_vector(axis: int, size: tuple[float, float, float]) -> tuple[float, float, float]:
+    """Return a 3D size vector with extent only along ``axis``."""
+
+    values = [0.0, 0.0, 0.0]
+    values[axis] = size[axis]
+    return tuple(values)