pystratify 0.10.2__py3-none-any.whl

pystratify/PLANAR-LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright (C) 2012-2024 Steven Byrnes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

pystratify/__init__.py

@@ -0,0 +1,125 @@
+"""PyStratify: light scattering by multilayered (stratified) spheres.
+
+Quick start::
+
+    import numpy as np
+    import pystratify as ps
+
+    wavelength = np.linspace(500, 900, 401)              # nm
+    radii = [50, 55]                                     # nm: SiO2 core, Au shell
+    n_au = ...                                           # (401,) complex, e.g. from refractiveindex.info
+    n = np.stack([np.full(401, 1.45), n_au, np.full(401, 1.33)], axis=1)   # host last
+    sol = ps.solve(radii, n, wavelength)
+    ps.cross_sections(sol).q_ext                         # (401,)
+"""
+
+from .casimir import CasimirPolder, casimir_polder
+from .chiral import ChiralSolution, solve_chiral
+from .convergence import truncation_order
+from .decay import DecayRates, decay_rates, locate_shell
+from .drude import DRUDE, DrudeModel, free_path_correction, surface_damping_wavelength
+from .emission import EmissionPattern, dipole_far_field, source_covariance
+from .ensemble import ShellAverage, SpectralDensity, shell_average, spectral_density
+from .energy import (
+    EnergyDensity,
+    ShellEnergy,
+    electric_prefactor,
+    energy_density,
+    energy_prefactors,
+    shell_energy,
+)
+from .farfield import (
+    CrossSections,
+    HelicityCrossSections,
+    ScatteringPattern,
+    amplitude_matrix,
+    angular_functions,
+    cross_sections,
+    helicity_cross_sections,
+    mueller_matrix,
+    scattering_amplitudes,
+    scattering_pattern,
+)
+from .nearfield import NearField, near_field
+from .pairs import GreenDyadic, green_dyadic
+from .normalized import NormalizedRates, NormalizedTerms, normalized_decay_rates, normalized_terms
+from .rates import EmissionRates, emission_rates
+from .sheets import Feibelman, Sheet, graphene_conductivity
+from .riccati import log_riccati
+from .solver import TE, TM, Solution, solve
+from .problem import Problem, PlaneWave, PointDipole, FocusedBeam
+from .observables import solve_problem, solve_focused
+from .focused import (
+    FocusedField,
+    FocusedResult,
+    focal_field,
+    focused_cylinders,
+    focused_field_cylinders,
+    focused_field_films,
+    focused_field_spheres,
+    focused_films,
+    focused_spheres,
+)
+from .cylindrical import solve_cylinder, CylinderSolution, cross_widths, cylinder_pattern
+
+__version__ = "0.10.2"
+
+__all__ = [
+    "Problem", "PlaneWave", "PointDipole", "FocusedBeam", "solve_problem", "solve_focused",
+    "focused_films", "focused_spheres", "focused_cylinders", "FocusedResult",
+    "focused_field_films", "focused_field_spheres", "focused_field_cylinders", "FocusedField", "focal_field",
+    "solve_cylinder", "CylinderSolution", "cross_widths", "cylinder_pattern",
+    "solve",
+    "Solution",
+    "solve_chiral",
+    "ChiralSolution",
+    "TM",
+    "TE",
+    "truncation_order",
+    "cross_sections",
+    "CrossSections",
+    "helicity_cross_sections",
+    "HelicityCrossSections",
+    "scattering_amplitudes",
+    "amplitude_matrix",
+    "mueller_matrix",
+    "scattering_pattern",
+    "ScatteringPattern",
+    "dipole_far_field",
+    "EmissionPattern",
+    "source_covariance",
+    "angular_functions",
+    "near_field",
+    "NearField",
+    "energy_density",
+    "EnergyDensity",
+    "shell_energy",
+    "ShellEnergy",
+    "electric_prefactor",
+    "energy_prefactors",
+    "decay_rates",
+    "DecayRates",
+    "emission_rates",
+    "EmissionRates",
+    "locate_shell",
+    "Feibelman",
+    "Sheet",
+    "graphene_conductivity",
+    "DRUDE",
+    "DrudeModel",
+    "free_path_correction",
+    "surface_damping_wavelength",
+    "log_riccati",
+    "normalized_decay_rates",
+    "casimir_polder",
+    "CasimirPolder",
+    "green_dyadic",
+    "GreenDyadic",
+    "shell_average",
+    "ShellAverage",
+    "spectral_density",
+    "SpectralDensity",
+    "normalized_terms",
+    "NormalizedTerms",
+    "NormalizedRates",
+]

pystratify/casimir.py

@@ -0,0 +1,97 @@
+"""Casimir-Polder potential of a ground-state atom in or near a multilayered sphere.
+
+For an isotropic electric polarizability alpha(i xi) (Buhmann & Welsch, Prog. Quantum Electron. 31,
+51 (2007), Eq. (110)),
+
+    U(r) = (hbar mu_0 / 2 pi) int_0^inf dxi xi^2 alpha(i xi) Tr G_s(r, r, i xi),
+
+with the scattered Green's dyadic at imaginary frequency.  The trace is the dipole series of the
+normalized formulation at k = i xi n(i xi)/c, Tr G_s = (i k / 6 pi)(g_perp + 2 g_par) (shell
+normalization, as for the decay rates and the shift), and with alpha = 4 pi eps_0 alpha_V in volume
+units
+
+    U(r) = -(hbar / 3 pi c^3) int_0^inf dxi xi^3 n_d(i xi) alpha_V(i xi) [g_perp + 2 g_par](i xi).
+
+At imaginary frequency every auxiliary function is real up to a fixed phase (P real, A and B
+imaginary, jbar real), the Hankel-type solution decays like exp(-kappa r), and the normalized
+series converge geometrically at the emitter as for real frequencies; nothing can overflow.
+The integral is done by Gauss-Legendre quadrature in ln xi.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from .energy import gauss_legendre
+from .normalized import L_CAP, _complex_converged, _dipole_series, _Sweep
+from .convergence import orders_needed
+
+__all__ = ["CasimirPolder", "casimir_polder"]
+
+HBAR = 1.054571817e-34  # J s
+C_NM = 2.99792458e17  # speed of light, nm/s
+
+
+@dataclass(frozen=True)
+class CasimirPolder:
+    """Casimir-Polder potential ``energy`` (J) at the radii ``r``; ``xi`` and ``integrand`` (P, X) are the
+    quadrature nodes (rad/s) and xi^3 n_d alpha_V [g_perp + 2 g_par], ``orders`` the most multipoles used."""
+
+    r: np.ndarray
+    energy: np.ndarray
+    xi: np.ndarray
+    integrand: np.ndarray
+    orders: int
+    converged: np.ndarray
+
+    @property
+    def frequency(self) -> np.ndarray:
+        """U / h in Hz."""
+        return self.energy / (2 * np.pi * HBAR)
+
+
+def casimir_polder(radii, eps, r, polarizability, mu=None, xi_range=(1e9, 1e19), nodes=96, tol=1e-10, l_cap=L_CAP):
+    """Casimir-Polder potential of an atom at radius (radii) ``r`` (nm), in any layer.
+
+    ``eps(xi)`` and ``mu(xi)`` (optional) return the (N + 1,) permittivities and permeabilities of the
+    layers at imaginary frequency i xi (xi in rad/s; real and >= 1 for passive media), host last.
+    ``polarizability(xi)`` is the atom's isotropic polarizability alpha(i xi) / (4 pi eps_0) in nm^3.
+    The integral over xi runs over ``xi_range`` with ``nodes`` Gauss-Legendre nodes in ln xi; every
+    order sum meets ``tol`` (automatic truncation, at most ``l_cap`` orders).  Lengths in nm.
+    """
+    radii = np.atleast_1d(np.asarray(radii, dtype=float))
+    r = np.atleast_1d(np.asarray(r, dtype=float))
+    if np.any(~(r > 0)) or np.any(np.isin(r, radii)):
+        raise ValueError("positions must be positive and off the interfaces")
+    shells = np.searchsorted(radii, r, side="right")
+    t, w = gauss_legendre(nodes)
+    lo, hi = np.log(xi_range[0]), np.log(xi_range[1])
+    ln_xi = 0.5 * (hi - lo) * t + 0.5 * (hi + lo)
+    xi, w = np.exp(ln_xi), 0.5 * (hi - lo) * w * np.exp(ln_xi)  # d xi = xi d ln xi
+    q = np.max(np.minimum(radii[None, :] / r[:, None], r[:, None] / radii[None, :]))
+    integrand = np.zeros((r.size, xi.size))
+    ok = np.ones(r.size, dtype=bool)
+    used = 0
+    for i, x in enumerate(xi):
+        e = np.atleast_1d(np.asarray(eps(x), dtype=complex))
+        m = np.ones_like(e) if mu is None else np.atleast_1d(np.asarray(mu(x), dtype=complex))
+        if e.shape != (radii.size + 1,) or m.shape != e.shape:
+            raise ValueError(f"eps and mu must return ({radii.size + 1},) arrays, host last")
+        n = np.sqrt(e * m).real + 0j  # real at imaginary frequency for passive media
+        k = 1j * (x / C_NM) * n
+        L = int(min(l_cap, max(32, orders_needed(q, tol, l_cap))))
+        while True:
+            terms = _Sweep(radii, n, m, k, L).at(r)
+            g, _ = _dipole_series(terms, "electric")
+            good = _complex_converged(g, tol)
+            if good.all() or L >= l_cap:
+                break
+            L = min(2 * L, l_cap)
+        used = max(used, L)
+        ok &= good
+        trace = (g[:, :, 0] + 2 * g[:, :, 1]).sum(axis=1).real
+        integrand[:, i] = x**3 * n[shells].real * polarizability(x) * trace
+    energy = -HBAR / (3 * np.pi * C_NM**3) * integrand @ w
+    return CasimirPolder(r=r, energy=energy, xi=xi, integrand=integrand, orders=used, converged=ok)

pystratify/chiral.py

@@ -0,0 +1,426 @@
+"""Multilayered spheres with chiral (Pasteur) layers.
+
+Constitutive relations (Gaussian units, time dependence exp(-i omega t)):
+
+    D = eps E + i kappa H,     B = mu H - i kappa E,
+
+the convention of treams (Beutel et al., Comput. Phys. Commun. 297, 109076
+(2024)) and of Lindell et al., *Electromagnetic Waves in Chiral and
+Bi-Isotropic Media* (1994) after exp(jwt) -> exp(-iwt).  In every layer the
+field splits into the Beltrami fields Q_s = E + s i Z H (s = +-1,
+Z = sqrt(mu/eps) = mu/n), which obey curl Q_s = s k_s Q_s with
+k_s = k0 (n + s kappa): kappa > 0 slows helicity +1 (left-circular in the
+optics convention).  The host must be achiral.
+
+Per multipole order the fields of a layer are W_s = M + s N with wavenumber
+k_s, and E_tan, H_tan continuous at an interface gives, with channel values
+v_s = u_s/x_s and derivatives d_s = u_s'/x_s (u = A psi + B xi),
+
+    v' = C_v v,   d' = C_d d,   C_v = [[1+z, 1-z], [1-z, 1+z]]/2,
+    C_d = [[1+z, z-1], [z-1, 1+z]]/2,   z = Z_{j+1} / Z_j,
+
+so helicity mixes only through the impedance contrast (a dual, impedance-
+matched particle conserves helicity).  The regular solution is swept
+outwards as the 2x2 matrix rho = Xi R Psi^-1 (B = R A, scaled at the
+interface as in the achiral solver): with D1 = psi'/psi, D3 = xi'/xi,
+
+    rho' = Lambda^-1 (N0 + N1 rho) (D0 + D1m rho)^-1 Lambda,
+    N0 = D1' C_v - C_d D1,  N1 = D1' C_v - C_d D3,
+    D0 = C_d D1 - D3' C_v,  D1m = C_d D3 - D3' C_v,  Lambda = D1' - D3',
+
+the matrix form of the achiral Moebius step.  As there, the large parts
+(l+1)/x of D1 and l/x of D3 are combined analytically, so N0 and D1m - which
+vanish for identical media - are built from the material contrasts
+directly, and rho is carried as element-wise logarithms so it may fall far
+below the double range across thick absorbing shells.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from .convergence import truncation_order
+from .riccati import log_riccati
+from .sheets import _feibelman_arrays, _sheet_arrays, _sheet_terms
+from .solver import _batch, _side
+
+__all__ = ["ChiralSolution", "solve_chiral", "HELICITY_TO_TMTE", "log_matmul"]
+
+#: (TM, TE) = (N, M) amplitudes of W_+ = M + N and W_- = M - N, as columns
+HELICITY_TO_TMTE = np.array([[1.0, -1.0], [1.0, 1.0]])
+_TMTE_TO_HELICITY = np.linalg.inv(HELICITY_TO_TMTE)
+_SIGN = np.array([1.0, -1.0])
+_SAFE_LOG = 600.0
+
+
+def _inv2(m):
+    a, b, c, d = m[..., 0, 0], m[..., 0, 1], m[..., 1, 0], m[..., 1, 1]
+    out = np.empty_like(m)
+    det = a * d - b * c
+    out[..., 0, 0], out[..., 0, 1], out[..., 1, 0], out[..., 1, 1] = d / det, -b / det, -c / det, a / det
+    return out
+
+
+def _log(a):
+    with np.errstate(divide="ignore", invalid="ignore"):
+        return np.log(a)
+
+
+def _log_add(log_x, log_y):
+    with np.errstate(all="ignore"):
+        m = np.maximum(log_x.real, log_y.real)
+        m = np.where(np.isfinite(m), m, 0.0)
+        return m + np.log(np.exp(log_x - m) + np.exp(log_y - m))
+
+
+def log_matmul(log_a, log_b):
+    """log(A @ B) for stacks of 2x2 matrices given as element-wise complex logarithms."""
+    return _log_add(
+        log_a[..., :, 0, None] + log_b[..., None, 0, :],
+        log_a[..., :, 1, None] + log_b[..., None, 1, :],
+    )
+
+
+@dataclass(frozen=True)
+class ChiralSolution:
+    """T-matrix of a multilayered sphere with chiral layers, for a batch of wavelengths.
+
+    ``log_t_helicity`` has shape ``(W, L, 2, 2)``: log of the host T-matrix
+    block in the helicity basis [out, in] (index 0 = +1, 1 = -1) for the
+    waves W_s = M + s N; ``t_matrix`` is the same block in the (TM, TE)
+    basis used by the far-field functions.
+
+    Internal fields, shape ``(W, N + 1, L, 2, 2)`` [layer, ..., channel, incident
+    helicity]: in layer j the regular solution excited by a unit incident wave
+    W_h in the host is sum_c (alpha_ch psi_l(k_jc r) + beta_ch xi_l(k_jc r)) W_c,
+    with ``log_alpha`` = log alpha (the identity in the host) and ``log_r`` =
+    log R, beta = R alpha (zero in the core, T in the host).  The outgoing
+    solution, a unit outgoing wave W_h in the host and nothing incoming, is
+    ``log_beta_out`` = log beta and ``log_s`` = log S, alpha = S beta (zero in the host).
+
+    Interface maps, shape ``(W, N, L, 2, 2)``: ``log_in[:, j]`` carries the
+    psi amplitudes of any regular solution from layer j + 1 to layer j
+    (alpha_j = M alpha_{j+1}), ``log_out[:, j]`` the xi amplitudes of any
+    outgoing solution from layer j to layer j + 1 (beta_{j+1} = M beta_j).
+    Chained, they continue a field found in one layer (e.g. of a source) to
+    the others without inverting ``log_alpha`` or ``log_beta_out``.
+    """
+
+    radii: np.ndarray
+    n: np.ndarray  # (W, N + 1)
+    mu: np.ndarray  # (W, N + 1)
+    kappa: np.ndarray  # (W, N + 1)
+    wavelength: np.ndarray  # (W,)
+    orders: np.ndarray  # (L,)
+    log_t_helicity: np.ndarray  # (W, L, 2, 2)
+    log_alpha: np.ndarray  # (W, N + 1, L, 2, 2)
+    log_r: np.ndarray  # (W, N + 1, L, 2, 2)
+    log_beta_out: np.ndarray  # (W, N + 1, L, 2, 2)
+    log_s: np.ndarray  # (W, N + 1, L, 2, 2)
+    log_in: np.ndarray  # (W, N, L, 2, 2)
+    log_out: np.ndarray  # (W, N, L, 2, 2)
+    sheet_sigma: np.ndarray | None = None  # (W, N): 2D sheets at the interfaces (see pystratify.sheets)
+    sheet_zeta: np.ndarray | None = None  # (W, N)
+
+    @property
+    def has_sheets(self) -> bool:
+        return self.sheet_sigma is not None and bool(np.any(self.sheet_sigma) or np.any(self.sheet_zeta))
+
+    @property
+    def n_shells(self) -> int:
+        return self.radii.size
+
+    @property
+    def k(self) -> np.ndarray:
+        """Mean wavenumbers k0 n, shape (W, N + 1) (the host's is exact)."""
+        return 2 * np.pi * self.n / self.wavelength[:, None]
+
+    @property
+    def k_helicity(self) -> np.ndarray:
+        """Wavenumbers k0 (n + s kappa) of helicity s = +1, -1: shape (W, N + 1, 2)."""
+        return 2 * np.pi * (self.n[..., None] + _SIGN * self.kappa[..., None]) / self.wavelength[:, None, None]
+
+    @property
+    def t_helicity(self) -> np.ndarray:
+        with np.errstate(under="ignore"):
+            return np.exp(self.log_t_helicity)
+
+    @property
+    def t_matrix(self) -> np.ndarray:
+        """T-matrix blocks (W, L, 2, 2) in the (TM, TE) basis [out, in]."""
+        return HELICITY_TO_TMTE @ self.t_helicity @ _TMTE_TO_HELICITY
+
+
+def _interface_matrices(l, x_in, x_out, diff, side_in, side_out, delta):
+    """N0, N1, D0, D1m (W, L, 2, 2) of one interface.
+
+    ``x_*``, ``diff`` = x_in - x_out (from the contrasts): (W, 2); ``side_*`` =
+    (r, X) = (psi_{l+1}/psi_l, xi_{l-1}/xi_l), each (W, 2, L); ``delta`` = 1 - z.
+    """
+    (r_i, big_i), (r_o, big_o) = side_in, side_out
+    xi, xo, diff = x_in[..., None], x_out[..., None], diff[..., None]  # (W, 2, 1)
+    h = (1 - delta / 2)[:, None, None]
+    half = (delta / 2)[:, None, None]
+    shape = r_i.shape[:1] + (l.size, 2, 2)
+    n0, n1, d0, d1 = (np.empty(shape, dtype=complex) for _ in range(4))
+
+    def put(target, c, e, value):
+        target[..., c, e] = value
+
+    for c in (0, 1):
+        e = 1 - c
+        # diagonal: the large parts combine into contrasts
+        put(n0, c, c, h[:, 0] * ((l + 1) * diff[:, c] / (xi[:, c] * xo[:, c]) + r_i[:, c] - r_o[:, c]))
+        put(n1, c, c, h[:, 0] * ((l + 1) / xo[:, c] - r_o[:, c] - big_i[:, c] + l / xi[:, c]))
+        put(d0, c, c, h[:, 0] * ((l + 1) / xi[:, c] - r_i[:, c] - big_o[:, c] + l / xo[:, c]))
+        put(d1, c, c, h[:, 0] * (big_i[:, c] - big_o[:, c] + l * diff[:, c] / (xi[:, c] * xo[:, c])))
+        # off-diagonal: proportional to the impedance contrast
+        put(n0, c, e, half[:, 0] * ((l + 1) * (1 / xo[:, c] + 1 / xi[:, e]) - r_o[:, c] - r_i[:, e]))
+        put(n1, c, e, half[:, 0] * ((l + 1) / xo[:, c] - r_o[:, c] + big_i[:, e] - l / xi[:, e]))
+        put(d0, c, e, -half[:, 0] * ((l + 1) / xi[:, e] - r_i[:, e] + big_o[:, c] - l / xo[:, c]))
+        put(d1, c, e, -half[:, 0] * (big_i[:, e] + big_o[:, c] - l / xi[:, e] - l / xo[:, c]))
+    return n0, n1, d0, d1
+
+
+def _sheet_corrections(d1_in, d3_in, d1_out, d3_out, z_in, z_out, sigma, a, tau, p):
+    """Additions to N0, N1, D0, D1m (W, L, 2, 2) from a 2D sheet on the interface (pystratify.sheets).
+
+    With the sheet, v' = C_v^ v + S_v d and d' = C_d^ d + S_d v, where (J = [[1, -1], [-1, 1]],
+    O = [[1, 1], [1, 1]], g = tau / p): C_v^ = C_v + z (tau - 1) J / 2, C_d^ = C_d + (tau - 1) J / 2,
+    S_v = g i Z' sigma J / 2, S_d = -i Z' sigma O / 2 - g a J / (2 i Z).  ``d*``: (W, L, 2) per
+    channel; ``z_*``, ``sigma``: (W,); ``a``, ``tau``, ``p``: (W, L).
+    """
+    J = np.array([[1.0, -1.0], [-1.0, 1.0]])
+    O = np.ones((2, 2))
+    zeta = (z_out / z_in)[:, None, None, None]
+    tau, a, gain = tau[..., None, None], a[..., None, None], (tau / p)[..., None, None]
+    sig = sigma[:, None, None, None]
+    dcv = zeta * (tau - 1) / 2 * J
+    dcd = (tau - 1) / 2 * J
+    s_v = gain * 1j * z_out[:, None, None, None] * sig / 2 * J
+    s_d = -1j * z_out[:, None, None, None] * sig / 2 * O - gain * a / (2j * z_in[:, None, None, None]) * J
+
+    def left(d, m):  # diag(d) @ m
+        return d[..., :, None] * m
+
+    def right(m, d):  # m @ diag(d)
+        return m * d[..., None, :]
+
+    n0 = left(d1_out, dcv) - right(dcd, d1_in) + right(left(d1_out, s_v), d1_in) - s_d
+    n1 = left(d1_out, dcv) - right(dcd, d3_in) + right(left(d1_out, s_v), d3_in) - s_d
+    d0 = right(dcd, d1_in) - left(d3_out, dcv) + s_d - right(left(d3_out, s_v), d1_in)
+    d1 = right(dcd, d3_in) - left(d3_out, dcv) + s_d - right(left(d3_out, s_v), d3_in)
+    return n0, n1, d0, d1
+
+
+def _log_moebius(n0, n1, d0, d1, log_rho):
+    """log[(N0 + N1 rho)(D0 + D1m rho)^-1] element-wise, rho = exp(log_rho), for any magnitude of rho,
+    and log[(D0 + D1m rho)^-1] (the inverse amplitude transfer up to Lambda).
+
+    Where every element of rho is below e^-600, rho = e^s rho_hat and the result
+    is N0 D0^-1 + e^s N1 rho_hat D0^-1: the neglected terms are e^-600 relative to
+    one of these two (the N0 D0^-1 D1m rho D0^-1 cross term matters only if N0 is
+    itself below e^-600).  Above e^600, rho is scaled down to e^600, which changes
+    the ratio only by e^-600 relative.
+    """
+    with np.errstate(invalid="ignore"):
+        s = np.max(log_rho.real, axis=(-2, -1))  # (W, L)
+    tiny = np.isfinite(s) & (s <= -_SAFE_LOG)
+    shift = np.where(np.isfinite(s) & (s > _SAFE_LOG), s - _SAFE_LOG, 0.0)[..., None, None]
+    with np.errstate(all="ignore"):
+        rho = np.exp(np.where(tiny[..., None, None], -np.inf, log_rho - shift))
+        den_inv = _inv2(d0 + d1 @ rho)
+        out = _log((n0 + n1 @ rho) @ den_inv)
+        log_den_inv = _log(den_inv) - shift
+    if tiny.any():
+        rho_hat = np.exp(log_rho[tiny] - s[tiny][:, None, None])
+        inv = _inv2(d0[tiny])
+        out[tiny] = _log_add(_log(n0[tiny] @ inv), s[tiny][:, None, None] + _log(n1[tiny] @ rho_hat @ inv))
+    return out, log_den_inv
+
+
+def _log_moebius_inward(n0, n1, d0, d1, log_sig):
+    """Outgoing solution across an interface, outer to inner:
+    log[(sig N0 - D0)^-1 (D1m - sig N1)] element-wise for sig = exp(log_sig) (already
+    similarity-transformed by Lambda), any magnitude; below e^-600 to first order in sig."""
+    with np.errstate(invalid="ignore"):
+        s = np.max(log_sig.real, axis=(-2, -1))
+    tiny = np.isfinite(s) & (s <= -_SAFE_LOG)
+    shift = np.where(np.isfinite(s) & (s > _SAFE_LOG), s - _SAFE_LOG, 0.0)[..., None, None]
+    with np.errstate(all="ignore"):
+        sig = np.exp(np.where(tiny[..., None, None], -np.inf, log_sig - shift))
+        out = _log(_inv2(sig @ n0 - d0) @ (d1 - sig @ n1))
+    if tiny.any():
+        sig_hat = np.exp(log_sig[tiny] - s[tiny][:, None, None])
+        inv = _inv2(d0[tiny])
+        first = inv @ sig_hat @ (n1[tiny] - n0[tiny] @ inv @ d1[tiny])
+        out[tiny] = _log_add(_log(-inv @ d1[tiny]), s[tiny][:, None, None] + _log(first))
+    return out
+
+
+def solve_chiral(radii, n, kappa, wavelength, mu=None, l_max=None, sheets=None) -> ChiralSolution:
+    """Solve a multilayered sphere whose shells may be chiral.
+
+    Parameters
+    ----------
+    radii : (N,) outer radii of the core and shells, strictly increasing.
+    n : (N + 1,) or (W, N + 1) refractive indices n = sqrt(eps mu), host last.
+    kappa : like ``n``, Pasteur chirality parameters (dimensionless, complex
+        for a lossy chiral response); the host's must be 0, and n +- kappa must
+        not be zero or negative real.
+    wavelength : scalar or (W,) vacuum wavelength(s), same unit as ``radii``.
+    mu : like ``n``, relative permeabilities (default 1).
+    l_max : truncation order; default :func:`truncation_order` (Wiscombe) for
+        the shortest wavelength, as :func:`~pystratify.solve`.
+    sheets : 2D materials at interfaces, ``{j: Sheet(...)}`` or ``{j: conductivity}``
+        (j = 0: surface of the core), as :func:`~pystratify.solve`; see :mod:`pystratify.sheets`.
+
+    With ``kappa = 0`` everywhere the result equals :func:`~pystratify.solve`'s
+    (``t_matrix`` then is diagonal).
+    """
+    radii = np.atleast_1d(np.asarray(radii, dtype=float))
+    if radii.ndim != 1 or radii.size == 0 or not np.all(np.isfinite(radii)):
+        raise ValueError("radii must be a non-empty 1-D array of finite values")
+    if radii[0] <= 0 or np.any(np.diff(radii) <= 0):
+        raise ValueError("radii must be positive and strictly increasing")
+    N = radii.size
+    n, mu, wavelength = _batch(n, mu, wavelength, N + 1)
+    try:
+        kappa = np.ascontiguousarray(np.broadcast_to(np.asarray(kappa, dtype=complex), n.shape))
+    except ValueError:
+        raise ValueError(f"kappa needs shape ({N + 1},) or ({wavelength.size}, {N + 1}), host last") from None
+    if not np.all(np.isfinite(kappa)):
+        raise ValueError("chirality parameters must be finite")
+    if np.any(kappa[:, -1] != 0):
+        raise ValueError("the host must be achiral (kappa = 0 in the last entry)")
+    helicity_n = n[..., None] + _SIGN * kappa[..., None]
+    if np.any(helicity_n == 0) or np.any((helicity_n.imag == 0) & (helicity_n.real < 0)):
+        raise ValueError(
+            "n +- kappa must not be zero or negative real (a lossless backward-wave helicity is not supported)"
+        )
+    if l_max is None:
+        l_max = max(truncation_order(radii[-1], abs(v), lam) for v, lam in zip(n[:, -1], wavelength))
+    l_max = int(l_max)
+    if l_max < 1:
+        raise ValueError("l_max must be >= 1")
+    l = np.arange(1, l_max + 1)
+    W = wavelength.size
+
+    k0 = 2 * np.pi / wavelength
+    kc = k0[:, None, None] * helicity_n  # (W, N + 1, 2)
+    x_in = kc[:, :N] * radii[:, None]  # (W, N, 2): k_{j,s} R_j
+    x_out = kc[:, 1:] * radii[:, None]  # (W, N, 2): k_{j+1,s} R_j
+    lp_in, lx_in, r_in, big_in, d1_in, d3_in = _side(x_in, *log_riccati(x_in, l_max + 1), l)
+    lp_out, lx_out, r_out, big_out, d1_out, d3_out = _side(x_out, *log_riccati(x_out, l_max + 1), l)
+    # 1 - Z_{j+1}/Z_j from the contrasts, Z = mu/n
+    n_i, n_o, mu_i, mu_o = n[:, :N], n[:, 1:], mu[:, :N], mu[:, 1:]
+    delta = (mu_i * (n_o - n_i) + n_i * (mu_i - mu_o)) / (mu_i * n_o)  # (W, N)
+    # x - x' per helicity from the contrasts, not by subtraction of the products
+    diff_n = (n_i - n_o)[..., None] + _SIGN * (kappa[:, :N] - kappa[:, 1:])[..., None]  # (W, N, 2)
+
+    if _feibelman_arrays(sheets, N, W) is not None:
+        raise NotImplementedError("d-parameters (Feibelman) are not part of the chiral solver: use solve()")
+    sigma, zeta = _sheet_arrays(sheets, N, W)
+    sheet_a, sheet_p, sheet_tau = _sheet_terms(sigma, zeta, k0, radii, l)
+
+    log_rho = np.full((W, l_max, 2, 2), -np.inf, dtype=complex)
+    log_rho_out = np.empty((N, W, l_max, 2, 2), dtype=complex)
+    log_transfer_inv = np.empty((N, W, l_max, 2, 2), dtype=complex)  # a = K^-1 a' at interface j
+    interface = []
+    for j in range(N):
+        if j:  # carry rho across shell j: rho_ce *= [xi_c(o)/xi_c(i)] [psi_e(i)/psi_e(o)]
+            grow_xi = np.moveaxis(lx_in[:, j] - lx_out[:, j - 1], 1, -1)  # (W, L, 2)
+            fall_psi = np.moveaxis(lp_out[:, j - 1] - lp_in[:, j], 1, -1)
+            log_rho = log_rho + grow_xi[..., :, None] + fall_psi[..., None, :]
+        mats = _interface_matrices(
+            l,
+            x_in[:, j],
+            x_out[:, j],
+            k0[:, None] * radii[j] * diff_n[:, j],
+            (r_in[:, j], big_in[:, j]),
+            (r_out[:, j], big_out[:, j]),
+            delta[:, j],
+        )
+        if np.any(sigma[:, j]) or np.any(zeta[:, j]):
+            extra = _sheet_corrections(
+                *(np.moveaxis(v[:, j], 1, -1) for v in (d1_in, d3_in, d1_out, d3_out)),
+                mu[:, j] / n[:, j],
+                mu[:, j + 1] / n[:, j + 1],
+                sigma[:, j],
+                sheet_a[:, j],
+                sheet_tau[:, j],
+                sheet_p[:, j],
+            )
+            mats = tuple(m + e for m, e in zip(mats, extra))
+        interface.append(mats)
+        log_m, log_den_inv = _log_moebius(*mats, log_rho)
+        # similarity with Lambda = diag(-i / (psi xi)) at the outer arguments
+        lam = np.moveaxis(lp_out[:, j] + lx_out[:, j], 1, -1)  # (W, L, 2): log(psi xi)
+        log_rho = log_m + lam[..., :, None] - lam[..., None, :]
+        log_rho_out[j] = log_rho
+        log_transfer_inv[j] = log_den_inv + (np.log(-1j) - lam)[..., None, :]  # (D0 + D1m rho)^-1 Lambda
+
+    # amplitudes from the host inwards: scaled a = diag(psi/x) alpha, a_inner = K^-1 a_outer
+    log_x_in, log_x_out = np.log(x_in), np.log(x_out)  # (W, N, 2)
+    log_alpha = np.empty((W, N + 1, l_max, 2, 2), dtype=complex)
+    log_r = np.full((W, N + 1, l_max, 2, 2), -np.inf, dtype=complex)
+    log_in = np.empty((W, N, l_max, 2, 2), dtype=complex)
+    log_alpha[:, N] = _log(np.eye(2) + 0j)
+    for j in range(N - 1, -1, -1):
+        outer = np.moveaxis(lp_out[:, j], 1, -1) - log_x_out[:, j, None, :]  # (W, L, 2): log(psi/x)
+        inner = np.moveaxis(lp_in[:, j], 1, -1) - log_x_in[:, j, None, :]
+        # alpha_j = diag(x/psi)_in K^-1 diag(psi/x)_out alpha_{j+1}
+        log_in[:, j] = log_transfer_inv[j] + outer[..., None, :] - inner[..., :, None]
+        scaled = log_matmul(log_transfer_inv[j], log_alpha[:, j + 1] + outer[..., :, None])
+        log_alpha[:, j] = scaled - inner[..., :, None]
+        # R of layer j + 1 from rho at its inner boundary: R_ce = rho_ce (x_c / xi_c) (psi_e / x_e)
+        to_r_rows = log_x_out[:, j, None, :] - np.moveaxis(lx_out[:, j], 1, -1)
+        log_r[:, j + 1] = log_rho_out[j] + to_r_rows[..., :, None] + outer[..., None, :]
+    # outgoing solution from the host inwards: scaled b = diag(xi/x) beta, sigma = (psi/x) S (x/xi),
+    # sigma = (sig' N0 - D0)^-1 (D1m - sig' N1) and b = (N0 sigma + N1)^-1 Lambda b'
+    log_beta_out = np.empty((W, N + 1, l_max, 2, 2), dtype=complex)
+    log_s = np.full((W, N + 1, l_max, 2, 2), -np.inf, dtype=complex)
+    log_out = np.empty((W, N, l_max, 2, 2), dtype=complex)
+    log_beta_out[:, N] = _log(np.eye(2) + 0j)
+    log_sig = np.full((W, l_max, 2, 2), -np.inf, dtype=complex)  # outer side of interface N - 1
+    for j in range(N - 1, -1, -1):
+        n0, n1, d0, d1 = interface[j]
+        lam = np.moveaxis(lp_out[:, j] + lx_out[:, j], 1, -1)
+        # sig~' = Lambda sig' Lambda^-1, Lambda = diag(-i / (psi xi)): element factor (psi xi)_e / (psi xi)_c
+        log_sig_in = _log_moebius_inward(n0, n1, d0, d1, log_sig - lam[..., :, None] + lam[..., None, :])
+        with np.errstate(under="ignore", over="ignore"):
+            forward = n0 @ np.exp(log_sig_in) + n1
+        transfer = _inv2(forward)  # (N0 sigma + N1)^-1, then Lambda
+        outer_xi = np.moveaxis(lx_out[:, j], 1, -1) - log_x_out[:, j, None, :]  # log(xi/x), outer side
+        inner_xi = np.moveaxis(lx_in[:, j], 1, -1) - log_x_in[:, j, None, :]
+        # beta_{j+1} = diag(x/xi)_out Lambda^-1 (N0 sigma + N1) diag(xi/x)_in beta_j, Lambda^-1 = diag(i psi xi)
+        log_out[:, j] = _log(forward) + (np.log(1j) + lam - outer_xi)[..., :, None] + inner_xi[..., None, :]
+        log_transfer = _log(transfer) + (np.log(-1j) - lam)[..., None, :]
+        scaled = log_matmul(log_transfer, log_beta_out[:, j + 1] + outer_xi[..., :, None])
+        log_beta_out[:, j] = scaled - inner_xi[..., :, None]
+        # S of layer j from sigma at its outer boundary: S_ce = sigma_ce (x_c / psi_c) (xi_e / x_e)
+        inner_psi = np.moveaxis(lp_in[:, j], 1, -1) - log_x_in[:, j, None, :]
+        log_s[:, j] = log_sig_in - inner_psi[..., :, None] + inner_xi[..., None, :]
+        if j:  # carry sigma across layer j to the outer side of interface j - 1
+            fall_psi = np.moveaxis(lp_out[:, j - 1] - lp_in[:, j], 1, -1)
+            grow_xi = np.moveaxis(lx_in[:, j] - lx_out[:, j - 1], 1, -1)
+            log_sig = log_sig_in + fall_psi[..., :, None] + grow_xi[..., None, :]
+    return ChiralSolution(
+        radii=radii,
+        n=n,
+        mu=mu,
+        kappa=kappa,
+        wavelength=wavelength,
+        orders=l,
+        log_t_helicity=log_r[:, N],
+        log_alpha=log_alpha,
+        log_r=log_r,
+        log_beta_out=log_beta_out,
+        log_s=log_s,
+        log_in=log_in,
+        log_out=log_out,
+        sheet_sigma=sigma,
+        sheet_zeta=zeta,
+    )