pystratify 0.10.2__py3-none-any.whl

pystratify/convergence.py

@@ -0,0 +1,48 @@
+"""Multipole truncation order for a sphere of given size."""
+
+from __future__ import annotations
+
+import numpy as np
+
+__all__ = ["truncation_order", "tail_estimate", "orders_needed"]
+
+
+def truncation_order(radius, n_host, wavelength, regime="far") -> int:
+    """Number of multipole orders needed for a sphere of outer radius ``radius``.
+
+    ``regime='far'``: cross sections and far field, Wiscombe, Appl. Opt. 19,
+    1505 (1980).  ``regime='near'``: fields at the surface, Allardice & Le Ru,
+    Appl. Opt. 53, 7224 (2014).  ``wavelength`` may be an array (the shortest
+    is used) and ``n_host`` complex (its modulus is used).
+    """
+    x = 2 * np.pi * float(radius) * abs(complex(n_host)) / float(np.min(wavelength))
+    if not np.isfinite(x) or x <= 0:
+        raise ValueError("radius, n_host and wavelength must give a positive, finite size parameter")
+    if regime == "near":
+        order = x + 11 * x ** (1 / 3) + 1
+    elif regime == "far":
+        order = x + 4 * x ** (1 / 3) + (1 if x <= 8 else 2)
+    else:
+        raise ValueError("regime must be 'far' or 'near'")
+    return max(1, int(order))
+
+
+def tail_estimate(terms):
+    """Remainder of a series estimated from its last terms (axis 0 = order).
+
+    The decay-rate series are asymptotically geometric in l, ratio
+    (r_< / r_>)^2 times a polynomial, so the neglected tail is ~ t_L q/(1 - q)
+    with q the worst recent ratio: far larger than t_L when q -> 1.  +inf
+    where the terms are not decreasing.
+    """
+    a = np.abs(terms[-4:])
+    with np.errstate(all="ignore"):
+        q = np.max(a[1:] / a[:-1], axis=0)
+        return np.where(a[-1] == 0, 0.0, np.where(q < 1, a[-1] * q / (1 - q), np.inf))
+
+
+def orders_needed(q, tol, l_cap):
+    """Orders for a geometric series of ratio q^2 to leave a tail below tol."""
+    if q >= 1:
+        return l_cap
+    return 1.25 * np.log(tol * (1 - q * q)) / (2 * np.log(q)) + 16

pystratify/cylinder_emission.py

@@ -0,0 +1,264 @@
+"""Three-dimensional point dipoles: cylindrical orders and continuous axial spectrum."""
+
+from dataclasses import dataclass, replace
+
+import numpy as np
+from scipy.optimize import minimize_scalar, brentq
+
+from .cylindrical import solve_cylinder, vectors
+from .special import cylinder_pair
+from .integration import integrate
+from .response import source_coefficients
+
+
+@dataclass(frozen=True)
+class CylinderRates:
+    total: np.ndarray
+    escape: np.ndarray
+    guided: np.ndarray
+    absorbed: np.ndarray
+    error: float
+    evaluations: int
+    orders: int
+    converged: bool
+    balance_error: np.ndarray
+    poles: tuple
+    grazing_error: float = 0.0
+
+
+def axis_vectors(beta, k, q, orders):
+    M, N = np.zeros((len(orders), 3), complex), np.zeros((len(orders), 3), complex)
+    for i, m in enumerate(orders):
+        if m == 0:
+            N[i, 2] = q / k
+        elif m == 1:
+            M[i, :2], N[i, :2] = (1j / 2, -.5), (1j * beta / (2 * k), -beta / (2 * k))
+        elif m == -1:
+            M[i, :2], N[i, :2] = (1j / 2, .5), (-1j * beta / (2 * k), -beta / (2 * k))
+    return M, N
+
+
+class CylinderSource:
+    def __init__(self, radii, n, wavelength, radius, dipole="electric", m_max=None, tolerance=1e-6):
+        self.radii, self.n = np.asarray(radii, float), np.asarray(n, complex)
+        self.wavelength, self.radius = float(wavelength), float(radius)
+        self.layer = int(np.searchsorted(self.radii, radius))
+        if radius < 0 or not np.isfinite(radius) or wavelength <= 0:
+            raise ValueError("source radius must be nonnegative and wavelength positive")
+        if dipole not in ("electric", "magnetic"):
+            raise ValueError("dipole must be electric or magnetic")
+        if any(self.n[j].imag != 0 or self.n[j].real <= 0 for j in (self.layer, len(n) - 1)):
+            raise ValueError("source medium and exterior must be lossless with positive index")
+        self.mu = np.ones_like(self.n) if dipole == "electric" else self.n ** 2
+        self.k0 = 2 * np.pi / wavelength
+        self.ks = self.k0 * self.n[self.layer].real
+        self.tolerance = tolerance
+        gap = np.min(np.abs(self.radii - radius))
+        if gap == 0:
+            raise ValueError("source cannot lie on an interface")
+        self.maximum = max(2.0, np.max(np.abs(self.n)) / self.n[self.layer].real + 16 / (self.ks * gap))
+        qratio = max(np.minimum(self.radii / max(radius, 1e-300), radius / self.radii)) if radius else 0
+        size = self.k0 * max(abs(self.n)) * self.radii[-1]
+        needed = max(8, int(np.ceil(size + 4 * size ** (1 / 3) + 8)), int(np.ceil(-np.log(tolerance) / max(1e-8, -2 * np.log(max(qratio, 1e-300))))) + 10)
+        self.m_max = int(m_max) if m_max is not None else (1 if radius == 0 else min(1500, needed))
+        self.explicit_order = m_max is not None
+
+    def solution(self, b, maximum=None):
+        return solve_cylinder(self.radii, self.n, self.wavelength, mu=self.mu, beta=self.ks * b, m_max=self.m_max if maximum is None else maximum)
+
+    def coefficients(self, solution):
+        d, radius, orders = self.layer, self.radius, solution.orders
+        k, beta, q = self.ks, solution.beta, solution.q[d]
+        if radius == 0:
+            M, N = axis_vectors(beta, k, q, orders)
+            Mr, Nr = axis_vectors(-beta, k, q, -orders)
+            parity = np.where(np.abs(orders) % 2, -1, 1)[:, None]
+            Mr, Nr = parity * Mr, parity * Nr
+            direct = np.stack((Nr, Mr), axis=-2)
+            S = np.exp(solution.log_s[0])
+            reflected = S @ direct
+            field = np.einsum("mip,mij->mpj", np.stack((N, M), axis=-2), reflected)
+            reflected_work = np.einsum("mii->mi", field)
+            return reflected_work, direct, None, None
+        d, pairs, R, S = solution.reflection_at(radius)
+        Mj, Nj = vectors(q, k, beta, radius, orders, pairs[0])
+        Mh, Nh = vectors(q, k, beta, radius, orders, pairs[1])
+        Mjr, Njr = vectors(q, k, -beta, radius, -orders, pairs[0])
+        Mhr, Nhr = vectors(q, k, -beta, radius, -orders, pairs[1])
+        factor = np.exp(pairs[0][2] + pairs[1][2])[:, None, None]
+        direct_regular = factor * np.stack((Nhr, Mhr), axis=-2)
+        direct_outgoing = factor * np.stack((Njr, Mjr), axis=-2)
+        A, B = source_coefficients(R, S, direct_regular, direct_outgoing, blocks=True)
+        field = np.einsum("mip,mij->mpj", np.stack((Nj, Mj), axis=-2), A) + np.einsum("mip,mij->mpj", np.stack((Nh, Mh), axis=-2), B)
+        reflected_work = np.einsum("mii->mi", field)
+        return reflected_work, direct_outgoing + B, direct_regular + A, pairs
+
+    @staticmethod
+    def inverse_reference(log_matrix, function_log=0):
+        reference = log_matrix + (function_log[:, None, None] if np.ndim(function_log) else function_log)
+        scale = np.max(reference.real, axis=(-2, -1))
+        inverse = np.linalg.inv(np.exp(reference - scale[:, None, None]))
+        return inverse, scale
+
+    def amplitudes(self, solution, outward, inward, pairs):
+        d = self.layer
+        lh = pairs[1][2] if pairs is not None else 0
+        inverse_out, scale_out = self.inverse_reference(solution.log_b_out[d], lh)
+        transformed_out = inverse_out @ outward
+        if inward is not None:
+            inverse_in, scale_in = self.inverse_reference(solution.log_a[d], pairs[0][2])
+            transformed_in = inverse_in @ inward
+        else:
+            transformed_in, scale_in = None, None
+        return transformed_out, scale_out, transformed_in, scale_in
+
+    def field_at(self, solution, amplitudes, layer, radius):
+        out, scale_out, inward, scale_in = amplitudes
+        pairs = cylinder_pair(solution.q[layer], radius, solution.orders)
+        if layer >= self.layer:
+            B = np.exp(solution.log_b_out[layer] + pairs[1][2][:, None, None] - scale_out[:, None, None]) @ out
+            A = np.exp(solution.log_s[layer] + (pairs[0][2] - pairs[1][2])[:, None, None]) @ B
+        else:
+            A = np.exp(solution.log_a[layer] + pairs[0][2][:, None, None] - scale_in[:, None, None]) @ inward
+            B = np.exp(solution.log_b[layer] + pairs[1][2][:, None, None] - scale_in[:, None, None]) @ inward
+        k = self.k0 * self.n[layer]
+        Mj, Nj = vectors(solution.q[layer], k, solution.beta, radius, solution.orders, pairs[0])
+        Mh, Nh = vectors(solution.q[layer], k, solution.beta, radius, solution.orders, pairs[1])
+        E = np.einsum("mip,mij->mpj", np.stack((Nj, Mj), axis=-2), A) + np.einsum("mip,mij->mpj", np.stack((Nh, Mh), axis=-2), B)
+        H = -1j * self.n[layer] / self.mu[layer] * (np.einsum("mip,mij->mpj", np.stack((Mj, Nj), axis=-2), A) + np.einsum("mip,mij->mpj", np.stack((Mh, Nh), axis=-2), B))
+        return E, H
+
+    def spectral(self, b, maximum=None, powers=True):
+        solution = self.solution(b, maximum)
+        work, outward, inward, pairs = self.coefficients(solution)
+        green = 1.5 * np.sum(work, axis=0)
+        escape, absorbed = np.zeros(3), np.zeros(3)
+        if powers:
+            amplitudes = self.amplitudes(solution, outward, inward, pairs)
+            coefficient = np.exp(-amplitudes[1])[:, None, None] * amplitudes[0]
+            if self.ks * b < self.k0 * self.n[-1].real:
+                escape = 1.5 * (self.mu[self.layer] / self.mu[-1]).real * np.sum(np.abs(coefficient) ** 2, axis=(0, 1))
+            for j in range(len(self.radii)):
+                if self.n[j].imag == 0:
+                    continue
+                flux = []
+                for r in (0 if j == 0 else self.radii[j - 1], self.radii[j]):
+                    if r == 0:
+                        flux.append(np.zeros(3))
+                        continue
+                    E, H = self.field_at(solution, amplitudes, j, r)
+                    flux.append(r * np.sum(np.real(E[:, 1] * H[:, 2].conj() - E[:, 2] * H[:, 1].conj()), axis=0))
+                absorbed += .75 * np.pi * self.mu[self.layer].real * self.k0 * (flux[0] - flux[1])
+        tail = 0.0 if self.radius == 0 else float(np.max(np.sum(np.abs(work[np.abs(solution.orders) >= max(1, solution.orders[-1] - 3)]), axis=0)))
+        return green, escape, absorbed, tail
+
+    def guided_poles(self):
+        if np.any(self.n.imag):
+            return []
+        low, high = self.n[-1].real / self.n[self.layer].real, max(self.n.real) / self.n[self.layer].real
+        if high <= low:
+            return []
+        count = min(4000, max(160, int(30 * self.k0 * self.radii[-1] * max(self.n.real))))
+        grid = np.linspace(low + 1e-8, high - 1e-8, count)
+        positive = np.arange(self.m_max, 2 * self.m_max + 1)
+        def determinant(b):
+            sol = solve_cylinder(self.radii, self.n, self.wavelength, mu=self.mu, beta=self.ks * b, m_max=self.m_max, _response_only=True)
+            C = sol.transfers[-1]
+            D = C[:, :2, :2] + C[:, :2, 2:] @ sol.response.regular_in[-1]
+            return np.linalg.det(D)[positive] / np.maximum(1e-300, np.sum(np.abs(D[positive]) ** 2, axis=(-2, -1)))
+        values = np.abs(np.array([determinant(b) for b in grid]))
+        poles = []
+        for m in range(values.shape[1]):
+            indices = np.flatnonzero((values[1:-1, m] < values[:-2, m]) & (values[1:-1, m] < values[2:, m])) + 1
+            for j in indices:
+                fit = minimize_scalar(lambda b: abs(determinant(b)[m]), bounds=(grid[j - 1], grid[j + 1]), method="bounded", options={"xatol":1e-13})
+                if fit.fun < 1e-7 and not any(abs(fit.x - p) < 2e-7 for p in poles):
+                    h = min(1e-5, (grid[j + 1] - grid[j - 1]) / 10)
+                    phase = np.exp(-1j * np.angle(determinant(fit.x + h)[m] - determinant(fit.x - h)[m]))
+                    root = brentq(lambda b: np.real(phase * determinant(b)[m]), fit.x - h, fit.x + h, xtol=2e-13)
+                    poles.append(root)
+        return sorted(poles)
+
+    def pattern(self, theta, phi=0):
+        theta, phi = np.broadcast_arrays(theta, phi)
+        density = np.zeros(theta.shape + (3,))
+        prefactor = 3 / (8 * np.pi) * (self.mu[self.layer] * self.n[-1] / (self.mu[-1] * self.n[self.layer])).real
+        beta = self.n[-1].real / self.n[self.layer].real * np.cos(np.clip(theta, 1e-6, np.pi - 1e-6))
+        for b in np.unique(beta):
+            solution = self.solution(b)
+            _, outward, inward, pairs = self.coefficients(solution)
+            transformed, scale, _, _ = self.amplitudes(solution, outward, inward, pairs)
+            coefficient = np.exp(-scale)[:, None, None] * transformed
+            selected = beta == b
+            phase = np.exp(1j * (phi[selected, None] - np.pi / 2) * solution.orders)
+            far = np.einsum("pm,mij->pij", phase, coefficient)
+            density[selected] = prefactor * np.sum(abs(far) ** 2, axis=1)
+        return density
+
+    def _rates_once(self, tolerance=1e-6, max_evaluations=20000):
+        poles = self.guided_poles()
+        guided, regular_parts, residue_error = np.zeros(3), [], 0.0
+        for root in poles:
+            step = 1e-5 * max(1, root)
+            def residue(h):
+                return h * (self.spectral(root + h, powers=False)[0] - self.spectral(root - h, powers=False)[0]) / 2
+            r1, r2 = residue(step), residue(step / 2)
+            r2 = (4 * r2 - r1) / 3
+            residue_error += np.pi * float(np.max(np.abs(r1 - r2)))
+            guided -= np.pi * r2.imag
+            left = self.spectral(root - step, powers=False)[0].real + r2.real / step
+            right = self.spectral(root + step, powers=False)[0].real - r2.real / step
+            regular_parts.append((root, step, left, right))
+        def sample(b):
+            green, escape, absorbed, tail = self.spectral(b)
+            return np.r_[green.real, escape, absorbed, tail]
+        caps, grazing_error, cap_evaluations = [], 0.0, 0
+        if np.any(self.n.imag):
+            lines = np.unique(self.n[self.n.imag == 0].real / self.n[self.layer].real)
+            for line in lines:
+                neighbours = [abs(line - v) for v in lines if v != line]
+                width = min(1e-5 * max(1, line), line / 4, min(neighbours, default=np.inf) / 4)
+                if width <= 0:
+                    continue
+                for side in (-1, 1):
+                    edge, outer = line + side * width, line + side * 2 * width
+                    if not 0 < outer < self.maximum:
+                        continue
+                    if cap_evaluations + 2 >= max_evaluations:
+                        raise ArithmeticError("adaptive integration evaluation budget exceeded")
+                    value, away = sample(edge), sample(outer)
+                    cap_evaluations += 2
+                    # The vector basis loses digits at grazing incidence. Continue
+                    # only the narrow end cap and charge its variation to the error
+                    # budget; never relax the requested convergence tolerance.
+                    grazing_error += 4 * width * float(np.max(abs(value - away)))
+                    caps.append((line, side, width, value))
+        def integrand(b):
+            for root, step, left, right in regular_parts:
+                if abs(b - root) < step:
+                    f = (b - root + step) / (2 * step)
+                    return np.r_[left * (1 - f) + right * f, np.zeros(7)]
+            for line, side, width, value in caps:
+                if 0 <= side * (b - line) < width:
+                    return value
+            return sample(b)
+        breaks = [0, *[v / self.n[self.layer].real for v in self.n.real if v > 0], self.maximum]
+        breaks += [p - 1e-5 * max(1, p) for p in poles] + [p + 1e-5 * max(1, p) for p in poles]
+        integral = integrate(integrand, [b for b in breaks if 0 <= b <= self.maximum], tolerance, max_evaluations - cap_evaluations)
+        total, escape, absorbed = 1 + integral.value[:3] + guided, integral.value[3:6], integral.value[6:9]
+        balance = np.abs(total - escape - guided - absorbed) / np.maximum(1, abs(total))
+        tail_ok = self.radius == 0 or integral.value[-1] <= tolerance * max(1, np.max(abs(total)))
+        error = integral.error + residue_error + grazing_error
+        converged = integral.converged and error <= tolerance * max(1, np.max(abs(total))) and tail_ok and np.max(balance) <= tolerance and residue_error <= tolerance * max(1, np.max(abs(total)))
+        return CylinderRates(total, escape, guided, absorbed, error, integral.evaluations + cap_evaluations, self.m_max, bool(converged), balance, tuple(poles), grazing_error)
+
+    def rates(self, tolerance=1e-6, max_evaluations=20000):
+        """Refine automatic angular order within one total quadrature budget."""
+        spent = 0
+        for attempt in range(4):
+            result = self._rates_once(tolerance, max_evaluations - spent)
+            spent += result.evaluations
+            if result.converged or self.explicit_order or self.radius == 0 or self.m_max == 1500 or max_evaluations - spent < 200:
+                return replace(result, evaluations=spent)
+            self.m_max = min(1500, int(np.ceil(1.5 * self.m_max)) + 4)
+        return replace(result, evaluations=spent)

pystratify/cylindrical.py

@@ -0,0 +1,177 @@
+"""Vector cylindrical basis for concentric, infinite circular cylinders."""
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from .response import block_sweep, log_value, log_add
+from .special import cylinder_pair
+
+
+def outgoing_root(value):
+    q = np.sqrt(np.asarray(value, complex))
+    return np.where((q.imag < 0) | ((q.imag == 0) & (q.real < 0)), -q, q)
+
+
+def log_apply(matrix, logarithms):
+    terms = log_value(matrix)[..., :, :, None] + logarithms[..., None, :, :]
+    result = terms[..., 0, :]
+    for j in range(1, terms.shape[-2]):
+        result = log_add(result, terms[..., j, :])
+    return result
+
+
+def vectors(q, k, beta, radius, orders, pair):
+    f, df, _ = pair
+    m = np.asarray(orders)
+    M = np.stack((1j * m * f / (q * radius), -df, np.zeros_like(f)), axis=-1)
+    N = np.stack((1j * beta * df / k, -beta * m * f / (k * q * radius), q * f / k), axis=-1)
+    return M, N
+
+
+def traces(q, k, y, beta, radius, orders, pair):
+    M, N = vectors(q, k, beta, radius, orders, pair)
+    return np.stack((
+        np.stack((N[..., 2], np.zeros_like(N[..., 2])), axis=-1),
+        np.stack((np.zeros_like(N[..., 2]), -1j * y * N[..., 2]), axis=-1),
+        np.stack((N[..., 1], M[..., 1]), axis=-1),
+        np.stack((-1j * y * M[..., 1], -1j * y * N[..., 1]), axis=-1),
+    ), axis=-2)
+
+
+@dataclass
+class CylinderSolution:
+    radii: np.ndarray
+    n: np.ndarray
+    mu: np.ndarray
+    wavelength: float
+    beta: complex
+    orders: np.ndarray
+    q: np.ndarray
+    response: object
+    transfers: np.ndarray
+    inner_pairs: list
+    outer_pairs: list
+    log_a: np.ndarray
+    log_b: np.ndarray
+    log_b_out: np.ndarray
+    log_s: np.ndarray
+    t: np.ndarray
+
+    def reflection_at(self, radius):
+        layer = int(np.searchsorted(self.radii, radius))
+        pairs = cylinder_pair(self.q[layer], radius, self.orders)
+        shape = (len(self.orders), 2, 2)
+        regular, outgoing = np.zeros(shape, complex), np.zeros(shape, complex)
+        jlog, hlog = pairs[0][2], pairs[1][2]
+        if layer:
+            old_j, old_h = self.outer_pairs[layer - 1][0][2], self.outer_pairs[layer - 1][1][2]
+            regular = self.response.regular_out[layer - 1] * np.exp(old_j - old_h + hlog - jlog)[:, None, None]
+        if layer < len(self.radii):
+            old_j, old_h = self.inner_pairs[layer][0][2], self.inner_pairs[layer][1][2]
+            outgoing = self.response.outgoing_in[layer] * np.exp(jlog - hlog + old_h - old_j)[:, None, None]
+        return layer, pairs, regular, outgoing
+
+    def field(self, points, polarization="axial-electric"):
+        points = np.asarray(points, float)
+        rho, phi, z = np.hypot(points[..., 0], points[..., 1]), np.arctan2(points[..., 1], points[..., 0]), points[..., 2]
+        out_e, out_h = np.zeros(points.shape, complex), np.zeros(points.shape, complex)
+        incident = np.array([1, 0], complex) if polarization == "axial-electric" else np.array([0, 1j], complex)
+        for idx in np.ndindex(rho.shape):
+            radius = max(rho[idx], 1e-12 * self.wavelength)
+            layer = int(np.searchsorted(self.radii, radius))
+            pairs = cylinder_pair(self.q[layer], radius, self.orders)
+            E, H = np.zeros(3, complex), np.zeros(3, complex)
+            k = 2 * np.pi * self.n[layer] / self.wavelength
+            for b, logs in enumerate((self.log_a[layer], self.log_b[layer])):
+                M, N = vectors(self.q[layer], k, self.beta, radius, self.orders, pairs[b])
+                coefficient = np.exp(logs + pairs[b][2][:, None, None]) @ incident
+                phase = (1j ** self.orders) * np.exp(1j * self.orders * phi[idx] + 1j * self.beta * z[idx])
+                E += np.sum(phase[:, None] * (coefficient[:, :1] * N + coefficient[:, 1:] * M), axis=0)
+                H += np.sum(-1j * self.n[layer] / self.mu[layer] * phase[:, None] * (coefficient[:, :1] * M + coefficient[:, 1:] * N), axis=0)
+            c, s = np.cos(phi[idx]), np.sin(phi[idx])
+            out_e[idx] = c * E[0] - s * E[1], s * E[0] + c * E[1], E[2]
+            out_h[idx] = c * H[0] - s * H[1], s * H[0] + c * H[1], H[2]
+        return out_e, out_h
+
+
+def solve_cylinder(radii, n, wavelength, *, mu=None, beta=0, m_max=None, _response_only=False):
+    radii, n = np.asarray(radii, float), np.asarray(n, complex)
+    mu = np.ones_like(n) if mu is None else np.asarray(mu, complex)
+    if radii.ndim != 1 or not len(radii) or radii[0] <= 0 or np.any(np.diff(radii) <= 0):
+        raise ValueError("radii must be positive and strictly increasing")
+    if n.shape != (len(radii) + 1,) or mu.shape != n.shape or not np.all(np.isfinite(n)) or np.any(n == 0):
+        raise ValueError("one finite nonzero index per radial region, host last, is required")
+    if not np.isfinite(wavelength) or wavelength <= 0:
+        raise ValueError("wavelength must be positive and finite")
+    k = 2 * np.pi * n / wavelength
+    q = outgoing_root(k * k - beta * beta)
+    if np.any(np.abs(q) < 1e-13 / wavelength):
+        raise ValueError("exact axial incidence/light-line evaluation needs its limiting form")
+    if m_max is None:
+        size = max(abs(q * radii[-1]))
+        m_max = max(8, int(np.ceil(size + 4 * size ** (1 / 3) + 8)))
+    if int(m_max) != m_max or not 1 <= m_max <= 1500:
+        raise ValueError("m_max must be an integer in 1..1500")
+    orders = np.arange(-int(m_max), int(m_max) + 1)
+    inner = [cylinder_pair(q[j], r, orders) for j, r in enumerate(radii)]
+    outer = [cylinder_pair(q[j + 1], r, orders) for j, r in enumerate(radii)]
+    transforms = []
+    for j, radius in enumerate(radii):
+        ti = np.concatenate([traces(q[j], k[j], n[j] / mu[j], beta, radius, orders, v) for v in inner[j]], axis=-1)
+        to = np.concatenate([traces(q[j + 1], k[j + 1], n[j + 1] / mu[j + 1], beta, radius, orders, v) for v in outer[j]], axis=-1)
+        transforms.append(np.linalg.solve(to, ti))
+    transfers = np.array(transforms)
+    propagation = np.array([
+        np.exp(outer[j][0][2] - outer[j][1][2] + inner[j + 1][1][2] - inner[j + 1][0][2])[:, None, None]
+        for j in range(len(radii) - 1)
+    ]).reshape(len(radii) - 1, len(orders), 1, 1)
+    response = block_sweep(transfers, propagation)
+    if _response_only:
+        return CylinderSolution(radii, n, mu, float(wavelength), beta, orders, q, response, transfers, inner, outer, None, None, None, None, None)
+    log_a = np.full((len(n), len(orders), 2, 2), -np.inf + 0j)
+    log_a[-1, :, 0, 0] = log_a[-1, :, 1, 1] = 0
+    for j in range(len(radii) - 1, -1, -1):
+        C = transfers[j]
+        inverse = np.linalg.inv(C[:, :2, :2] + C[:, :2, 2:] @ response.regular_in[j])
+        log_a[j] = log_apply(inverse, log_a[j + 1]) + (outer[j][0][2] - inner[j][0][2])[:, None, None]
+    log_b = np.full_like(log_a, -np.inf)
+    for j in range(1, len(n)):
+        reflection = response.regular_out[j - 1]
+        offset = outer[j - 1][0][2] - outer[j - 1][1][2]
+        log_b[j] = log_apply(reflection, log_a[j]) + offset[:, None, None]
+    t = np.exp(log_b[-1])
+    if not np.all(np.isfinite(t)):
+        raise ArithmeticError("cylindrical response exceeded numerical precision")
+    log_bo = np.full_like(log_a, -np.inf)
+    log_so = np.full_like(log_a, -np.inf)
+    log_bo[-1, :, 0, 0] = log_bo[-1, :, 1, 1] = 0
+    for j in range(len(radii) - 1, -1, -1):
+        C = transfers[j]
+        inverse = np.linalg.inv(C[:, 2:, :2] @ response.outgoing_in[j] + C[:, 2:, 2:])
+        log_bo[j] = log_apply(inverse, log_bo[j + 1]) + (outer[j][1][2] - inner[j][1][2])[:, None, None]
+        log_so[j] = log_value(response.outgoing_in[j]) + (inner[j][1][2] - inner[j][0][2])[:, None, None]
+    return CylinderSolution(radii, n, mu, float(wavelength), beta, orders, q, response, transfers, inner, outer, log_a, log_b, log_bo, log_so, t)
+
+
+def cross_widths(solution, polarization="unpolarized"):
+    if solution.n[-1].imag != 0 or abs(solution.beta.imag) > 0:
+        raise ValueError("cross widths require a lossless exterior and real incidence")
+    a = np.eye(2, dtype=complex)
+    columns = [0, 1] if polarization == "unpolarized" else [0 if polarization == "axial-electric" else 1]
+    power = np.sum(np.abs(solution.t[..., columns]) ** 2, axis=(0, 1))
+    extinction = -np.real(np.sum(solution.t[:, [0, 1], [0, 1]], axis=0))[columns]
+    factor = 4 / (2 * np.pi * solution.n[-1].real / solution.wavelength)
+    sca, ext = factor * np.mean(power), factor * np.mean(extinction)
+    return dict(extinction=ext, scattering=sca, absorption=ext - sca,
+                efficiency_extinction=ext / (2 * solution.radii[-1]),
+                efficiency_scattering=sca / (2 * solution.radii[-1]),
+                efficiency_absorption=(ext - sca) / (2 * solution.radii[-1]))
+
+
+def cylinder_pattern(solution, phi, polarization="unpolarized"):
+    phase = np.exp(1j * np.asarray(phi)[:, None] * solution.orders[None])
+    amplitudes = np.einsum("pm,mij->pij", phase, solution.t)
+    power = np.sum(np.abs(amplitudes) ** 2, axis=1)
+    columns = [0, 1] if polarization == "unpolarized" else [0 if polarization == "axial-electric" else 1]
+    return 2 / (np.pi * (2 * np.pi * solution.n[-1].real / solution.wavelength)) * np.mean(power[:, columns], axis=-1)