miepython 3.3.0__py3-none-any.whl → 3.3.1__py3-none-any.whl

miepython/__init__.py

@@ -178,7 +178,7 @@ __all__ = (
     "_D_downwards",
 )
 
-__version__ = "3.3.0"
+__version__ = "3.3.1"
 __author__ = "Scott Prahl"
 __email__ = "scott.prahl@oit.edu"
 __copyright__ = "2017-2026, Scott Prahl"

miepython/core.py

@@ -69,6 +69,55 @@ def wiscombe_terms(x):
     return int(x + 4.05 * x**0.33333 + 2.0)
 
 
+def _check_m_x(m, x):
+    """
+    Reject an index or size parameter that the kernels would silently misread.
+
+    The kernels treat any index whose real part fails ``m.real > 0`` as a perfect
+    conductor, so a NaN or negative real part gave the answer for a metal sphere
+    instead of an error.  A NaN or infinite x failed differently on each backend.
+
+    Args:
+        m: refractive index of the sphere, scalar or array
+        x: size parameter of the sphere, scalar or array
+
+    Raises:
+        ValueError: if m or x is not finite, x is negative, or m.real is negative
+    """
+    m = np.asarray(m)
+    x = np.asarray(x)
+    if not np.all(np.isfinite(m)):
+        raise ValueError(f"refractive index must be finite, got m={m}")
+    if np.any(m.real < 0):
+        raise ValueError(
+            f"real part of the refractive index must not be negative, got m={m}; "
+            "use m.real == 0 for a perfect conductor"
+        )
+    if not np.all(np.isfinite(x)):
+        raise ValueError(f"size parameter must be finite, got x={x}")
+    if np.any(x < 0):
+        raise ValueError(f"size parameter must not be negative, got x={x}")
+
+
+def _check_one_sphere(m, x):
+    """
+    Reject arrays of m or x in functions that describe a single sphere.
+
+    The angular functions vectorize over mu, so an array of spheres has no
+    unambiguous shape to return.  Without this check numpy raised "truth value of
+    an array is ambiguous" from deep inside.
+
+    Args:
+        m: refractive index of the sphere
+        x: size parameter of the sphere
+
+    Raises:
+        ValueError: if m or x is not a scalar
+    """
+    if np.ndim(m) > 0 or np.ndim(x) > 0:
+        raise ValueError("this function takes one sphere, so m and x must be scalars; loop over spheres for more")
+
+
 def coefficients(m, x, n_pole=0, internal=False):
     """
     Computes the Mie coefficients for a sphere.
@@ -103,6 +152,10 @@ def coefficients(m, x, n_pole=0, internal=False):
           automatically corrected to its conjugate value to ensure a valid input.
         - Every returned coefficient is a real term; the arrays carry no padding.
 
+    Raises:
+        ValueError: if m or x is not finite, x is negative, or the real part of
+            m is negative.  A perfect conductor is m.real == 0, not m.real < 0.
+
     Examples:
         Compute coefficients for a single sphere:
 
@@ -123,6 +176,7 @@ def coefficients(m, x, n_pole=0, internal=False):
         >>> print(f"{a[0, 0]:.6f}")
         0.447946-0.386652j
     """
+    _check_m_x(m, x)
     mlen = np.size(m) if np.ndim(m) > 0 else 0
     xlen = np.size(x) if np.ndim(x) > 0 else 0
 
@@ -208,6 +262,10 @@ def efficiencies_mx(m, x, n_pole=0, e_field=True):
         - This implementation assumes spherical, homogeneous particles in a
           non-absorbing medium.
 
+    Raises:
+        ValueError: if m or x is not finite, x is negative, or the real part of
+            m is negative.  A perfect conductor is m.real == 0, not m.real < 0.
+
     Examples:
         Compute efficiencies for one sphere:
 
@@ -228,6 +286,8 @@ def efficiencies_mx(m, x, n_pole=0, e_field=True):
         Use :func:`efficiencies` instead when the diameter and wavelength are
         known rather than the size parameter.
     """
+    _check_m_x(m, x)
+
     # ensure imaginary part of refractive index is negative
     if np.isscalar(m):
         m = np.conj(m) if np.imag(m) > 0 else m
@@ -361,7 +421,14 @@ def S1_S2(m, x, mu, norm="albedo", n_pole=0):
 
     Returns:
         S1, S2: the scattering amplitudes at each angle mu [sr**(-0.5)]
+
+    Raises:
+        ValueError: if m or x is not finite, x is negative, or the real part of
+            m is negative.  A perfect conductor is m.real == 0, not m.real < 0.
+            Also if m or x is an array, since this describes one sphere.
     """
+    _check_m_x(m, x)
+    _check_one_sphere(m, x)
     if np.imag(m) > 0:  # ensure imaginary part of refractive index is negative
         m = np.conj(m)
 

miepython/field.py

@@ -82,7 +82,7 @@ import numpy as np
 from scipy.special import factorial2, spherical_jn
 from ._backend import D_calc, pi_tau
 from .bessel import spherical_h1
-from .core import S1_S2, coefficients, wiscombe_terms
+from .core import S1_S2, _check_m_x, coefficients, wiscombe_terms
 from .util import cartesian_to_spherical, spherical_vector_to_cartesian
 
 __all__ = (
@@ -287,6 +287,7 @@ def _coefficients_abcd(lambda0, d_sphere, m_sphere, n_env, n_pole):
     """
     x = np.pi * d_sphere * n_env / lambda0
     m_rel = m_sphere / n_env
+    _check_m_x(m_rel, x)  # before wiscombe_terms, which cannot take a NaN x
     if n_pole == 0:
         # Wiscombe's criterion truncates the scattered series, which converges
         # faster than the field evaluated right at the surface.  Now that an_bn

miepython/monte_carlo.py

@@ -1,37 +1,64 @@
 """
-Sample scattering angles from the Mie phase function.
-
-Monte Carlo photon transport needs a random exit direction distributed according to
-the phase function.  This module builds the inverse-transform table that provides
-one: ``mu_with_uniform_cdf`` returns angles spaced so that equal steps along the
-cumulative distribution are equally likely, and ``generate_mie_costheta`` draws from
-that table.  ``docs/06_random_deviates.ipynb`` works through the whole procedure.
-
-Importing
----------
-
-This module is *not* imported with the package, because it imports ``miepython``
-itself and doing so from ``miepython/__init__.py`` would be circular.  Ask for it by
-name::
-
-    import numpy as np
-    import miepython.monte_carlo as mc
-
-    m, x = 1.33, 2.0                              # a water droplet
-    mu, cdf = mc.mu_with_uniform_cdf(m, x, 500)   # 500-entry lookup table
-
-    rng = np.random.default_rng(12345)
-    cosines = [mc.generate_mie_costheta(mu, rng=rng) for _ in range(10000)]
-
-Build the table once and reuse it: it costs a full Mie calculation, while each draw
-off it costs one random number.  The number of table entries sets how finely the
-phase function is resolved, so strongly forward-scattering spheres need more of
-them.
+Sample random scattering angles from the Mie phase function.
+
+A Monte Carlo simulation of light transport needs, at every scattering event, a
+random direction in which the photon leaves the sphere. For unpolarized light
+only the polar angle theta depends on the sphere, and it must be drawn so that
+its cosine mu follows the phase function. This module does that by inverse
+transform sampling: build the cumulative distribution of mu once, then map each
+uniform random number u to the cosine at which the distribution reaches u.
+
+``cdf``
+    The cumulative distribution at evenly spaced cosines.
+``mu_with_uniform_cdf``
+    The cosines at which the cumulative distribution reaches evenly spaced
+    probabilities, a lookup table that makes each draw cheap.
+``generate_mie_costheta``
+    One random cosine drawn from that table.
+
+``docs/06_random_deviates.ipynb`` works through the whole procedure.
+
+This module is *not* imported with the package, because it imports
+``miepython`` itself and doing so from ``miepython/__init__.py`` would be
+circular. Import it by name, as the examples below do.
+
+Examples:
+    Invert the distribution with ``np.interp`` to draw many cosines at once.
+    Their average is the asymmetry parameter g:
+
+    >>> import numpy as np
+    >>> import miepython as mie
+    >>> import miepython.monte_carlo as mc
+    >>> m, x = 1.33, 2.0                          # a water droplet
+    >>> mu, cdf = mc.cdf(m, x, 1000)
+    >>> rng = np.random.default_rng(42)
+    >>> cosines = np.interp(rng.random(100_000), cdf, mu)
+    >>> print(f"{np.mean(cosines):.2f}")
+    0.67
+    >>> qext, qsca, qback, g = mie.efficiencies_mx(m, x)
+    >>> print(f"{g:.2f}")
+    0.67
+
+    Or build a lookup table once and draw one cosine at a time, as a photon
+    transport loop does:
+
+    >>> mu_table, _ = mc.mu_with_uniform_cdf(m, x, 1000)
+    >>> cosines = [mc.generate_mie_costheta(mu_table, rng=rng) for _ in range(100_000)]
+    >>> print(f"{np.mean(cosines):.2f}")
+    0.67
+
+Building either table costs a full Mie calculation, while each draw costs only a
+random number or two, so build it once and reuse it. Evenly spaced cosines
+resolve the narrow forward peak of a large sphere poorly; ``cdf`` explains how
+many are needed and warns when there are too few, while ``mu_with_uniform_cdf``
+chooses enough by itself.
 
 Passing ``rng`` keeps the draws reproducible without disturbing the process-wide
 ``numpy.random``; omitting it falls back to that global generator.
 """
 
+import warnings
+
 import numpy as np
 import miepython as mie
 
@@ -41,87 +68,102 @@ __all__ = (
     "generate_mie_costheta",
 )
 
+# Largest acceptable relative error in the integral of the phase function
+CDF_TOLERANCE = 0.01
+
 
 def cdf(m, x, num):
     """
-    Create a CDF for unpolarized scattering uniformly spaced in cos(theta).
+    Cumulative distribution of the unpolarized phase function in cos(theta).
 
-    The CDF covers scattered (exit) angles ranging from 180 to 0 degrees.
-    (The cosines are uniformly distributed over -1 to 1.) Because the angles
-    are uniformly distributed in cos(theta), the scattering function is not
-    sampled uniformly and therefore huge array sizes are needed to adequately
-    sample highly anisotropic phase functions.
+    The cosines mu are evenly spaced from -1 (backscattering) to 1 (forward
+    scattering), and cdf[i] is the probability that a scattered photon leaves
+    with a cosine no greater than mu[i]. It is found by integrating the phase
+    function with the trapezoidal rule, so cdf[0] is exactly 0 and the values
+    never decrease.
 
-    Since this is a cumulative distribution function, the maximum value
-    should be 1.
+    A large sphere scatters much of its light into a diffraction peak about
+    4/x radians wide around the forward direction. Near theta = 0, mu = cos(theta)
+    is close to 1 - theta**2/2, so that peak spans only about 8/x**2 in mu,
+    while the cosines are 2/(num - 1) apart. To put several cosines inside the
+    peak, num must therefore grow roughly as x**2; x = 30 needs about 5000.
+
+    The phase function integrates to exactly one, so the raw trapezoidal sum
+    shows how well num resolves it. If that sum is off by more than
+    ``CDF_TOLERANCE``, a ``RuntimeWarning`` is issued; increase num until it
+    stops. The result is then divided by the sum so that cdf[-1] is exactly 1.
 
     Args:
-        m: the complex index of refraction of the sphere
-        x: the size parameter of the sphere
-        num: length of desired CDF array
+        m: complex index of refraction of the sphere
+        x: size parameter of the sphere
+        num: number of cosines, at least two
 
     Returns:
-        mu: array of cosines of angles
-        cdf: array of cumulative distribution function values
+        mu: evenly spaced cosines of the scattering angle, from -1 to 1
+        cdf: cumulative probability at each cosine, from 0 to 1
+
+    Raises:
+        ValueError: if num is less than two or the phase function is not finite
     """
+    if num < 2:
+        raise ValueError("num must be at least 2")
+    return _trapezoid_cdf(m, x, num, stacklevel=3)
+
+
+def _trapezoid_cdf(m, x, num, stacklevel):
+    """Integrate the phase function at num cosines, warning at the caller's caller."""
     mu = np.linspace(-1, 1, num)
-    intensity_per_mu = mie.i_unpolarized(m, x, mu, norm="4pi") / num
-    cdf_values = np.cumsum(intensity_per_mu)
+    intensity_per_mu = mie.i_unpolarized(m, x, mu, norm="4pi") / 2
+    cdf_values = np.zeros(num)
+    cdf_values[1:] = np.cumsum((intensity_per_mu[1:] + intensity_per_mu[:-1]) * np.diff(mu) / 2)
+    total = cdf_values[-1]
+    if not np.isfinite(total):
+        raise ValueError(f"phase function is not finite for m={m}, x={x}")
+    if abs(total - 1) > CDF_TOLERANCE:
+        warnings.warn(
+            f"phase function under-resolved for x={x}: integral over {num} angles is {total:.4g}, "
+            "not 1, so sampled angles will be inaccurate; use more angles",
+            RuntimeWarning,
+            stacklevel=stacklevel,
+        )
+    cdf_values /= total
     return mu, cdf_values
 
 
 def mu_with_uniform_cdf(m, x, num):
     """
-    Create a CDF for unpolarized scattering for uniform CDF.
-
-    The CDF covers scattered (exit) angles ranging from 180 to 0 degrees.
-    (The cosines are uniformly distributed over -1 to 1.) These angles mu
-    correspond to uniform spacing of the cumulative distribution function
-    for unpolarized Mie scattering where cdf[i] = i/(num-1).
+    Inverse-transform table for sampling the unpolarized phase function.
 
-    This is a brute force implementation that solves the problem by
-    calculating the CDF at many points and then scanning to find the
-    specific angles that correspond to uniform interval of the CDF.
+    The table holds num cosines mu running from -1 (backscattering) to 1
+    (forward scattering), spaced so that a scattered photon is equally likely
+    to fall between any two neighbours: cdf[i] is exactly i/(num - 1). The
+    cosines are therefore bunched where scattering is strong and sparse where
+    it is weak. ``generate_mie_costheta`` draws random cosines from this table.
 
-    Since this is a cumulative distribution function, the maximum value
-    should be 1.
+    The table is found by calculating ``cdf`` at max(2000, 5*x**2) evenly
+    spaced cosines, enough to resolve the forward peak whatever num is (see
+    ``cdf``), and interpolating to find where it reaches each step. Because
+    that count grows as x**2, building the table takes seconds at x = 100 and
+    over a minute at x = 300.
 
     Args:
-        m: the complex index of refraction of the sphere
-        x: the size parameter of the sphere
-        num: length of desired CDF array
+        m: complex index of refraction of the sphere
+        x: size parameter of the sphere
+        num: number of entries in the table, at least two
 
     Returns:
-        mu: array of cosines of angles (irregularly spaced)
-        cdf: array of cumulative distribution function values
-    """
-    big_num = 2000  # large to work with x up to 10
-    big_mu, big_cdf = cdf(m, x, big_num)
-    mu = np.empty(num)
-    cdf_values = np.empty(num)
-
-    mu[0] = -1  # cos[180 degrees] is -1
-    cdf_values[0] = 0  # initial cdf is zero
-
-    big_k = 0  # index into big_cdf
-    for k in range(1, num - 1):
+        mu: unevenly spaced cosines of the scattering angle, from -1 to 1
+        cdf: evenly spaced cumulative probabilities, from 0 to 1
 
-        target = k / (num - 1)
-        while big_cdf[big_k] < target:
-            big_k += 1
-
-        delta = big_cdf[big_k] - target
-        delta_cdf = big_cdf[big_k] - big_cdf[big_k - 1]
-        delta_mu = big_mu[big_k] - big_mu[big_k - 1]
-
-        mu[k] = big_mu[big_k] - delta / delta_cdf * delta_mu  # interpolate
-        cdf_values[k] = target
-
-    #       print(' mu[',k,']=% .5f'%mu[k],' cdf[',k,']=% .5f'%cdf[k],
-    #       'cdf=',big_cdf[big_k], fraction)
-
-    mu[num - 1] = 1  # cos[0 degrees] is 1
-    cdf_values[num - 1] = 1  # last cdf is one
+    Raises:
+        ValueError: if num is less than two or the phase function is not finite
+    """
+    if num < 2:
+        raise ValueError("num must be at least 2")
+    big_num = max(2000, int(5 * x**2))  # resolve the forward peak, see cdf
+    big_mu, big_cdf = _trapezoid_cdf(m, x, big_num, stacklevel=3)
+    cdf_values = np.arange(num) / (num - 1)
+    mu = np.interp(cdf_values, big_cdf, big_mu)
 
     return [mu, cdf_values]
 

miepython/rayleigh.py

@@ -1,7 +1,125 @@
-"""Rayleigh approximation for scattering by small particles."""
+"""
+Rayleigh approximation for scattering by spheres much smaller than the wavelength.
+
+When a sphere is small both outside (x << 1) and inside (abs(m) * x << 1), the
+incident field is nearly uniform across it, and it radiates as a single
+oscillating electric dipole. Every scattering quantity then follows in closed
+form from the ratio (m**2 - 1) / (m**2 + 2), with no series of multipoles to
+sum. This module evaluates those expressions, following Bohren and Huffman,
+equations 5.4 and 5.7 to 5.9. A perfect conductor also radiates a magnetic
+dipole, and has its own expressions, described below.
+
+The functions mirror those of the same names in ``miepython``, with the same
+arguments and the same ``norm`` choices, so one can stand in for the other:
+
+``efficiencies_mx(m, x)``, ``efficiencies(m, d, lambda0, n_env)``
+    qext, qsca, qback and g.
+``S1_S2(m, x, mu, norm)``
+    The scattering amplitudes at each mu = cos(theta).
+``i_par``, ``i_per``, ``i_unpolarized``, ``intensities``
+    Scattered intensities at each mu.
+``phase_matrix(m, x, mu, norm)``
+    The 4x4 Mueller matrix at each mu.
+
+Nothing here takes ``n_pole``, since there is only the dipole.
+
+Order of approximation:
+    Strictly, Rayleigh scattering is only the leading term in x: an electric
+    dipole whose strength is set by the static polarizability. Not every
+    expression here stops at that term, so this is better described as a
+    small-particle approximation.
+
+    - qsca and qback are the leading terms, 8/3 x**4 abs(ratio)**2 and
+      4 x**4 abs(ratio)**2.
+    - qext carries Bohren and Huffman's next-order correction. Its absorption
+      term includes a relative x**2 correction, the order at which the
+      magnetic dipole and the electric quadrupole first contribute (the
+      2 m**2 + 3 in its denominator is the quadrupole's), and scattering is
+      added as 8/3 x**4 Re(ratio**2).
+    - ``S1_S2`` gives the electric dipole its own relative x**2 correction, the
+      x**5 term, but leaves out the magnetic dipole and quadrupole. The angular
+      pattern is therefore exactly that of a dipole, and g is 0.
+    - A perfect conductor gets only the leading terms of its electric and
+      magnetic dipoles.
+
+    The corrections are not applied evenly, so a dielectric's qext is more
+    accurate than its qsca. ``miepython`` itself goes further for x < 0.1,
+    using Wiscombe's expansions, which keep the electric dipole, the magnetic
+    dipole and the electric quadrupole, each with its own corrections.
+
+Accuracy:
+    Relative error in qext against the full Mie solution:
+
+    =================  =========  ========  ========
+    m                  x = 0.01   x = 0.1   x = 0.5
+    =================  =========  ========  ========
+    1.5                -7e-6      -7e-4     -1e-2
+    1.5 - 0.1j         8e-10      6e-6      4e-3
+    0.05 - 1.43j       2e-6       2e-2      14
+    -1j (conductor)    -2e-5      -2e-3     -4e-2
+    =================  =========  ========  ========
+
+    The last row is a silver-like sphere near its plasmon resonance, where
+    m**2 is close to -2 and the denominator of the ratio nearly vanishes. There
+    the approximation fails at much smaller x than for an ordinary dielectric.
+
+    For a dielectric the asymmetry parameter g is 0, because dipole scattering
+    is the same forwards and backwards. The Mie value is 0.002 at x = 0.1 and
+    0.05 at x = 0.5 for m = 1.5.
+
+Conventions:
+    The index is m = n - ik, as in the rest of the package, and an index with a
+    positive imaginary part is conjugated. The inputs that ``miepython``
+    rejects, a NaN or infinite m or x, a negative x or a negative real part of
+    m, raise the same ``ValueError`` here. The efficiencies accept an array of
+    m or x and return arrays, g included. The angular functions describe one
+    sphere and vectorize over mu only.
+
+Perfect conductors:
+    As in the rest of the package, m.real == 0 means a perfect conductor,
+    whatever the imaginary part, and m = 0 is one too. No field enters such a
+    sphere, so the dielectric expressions, which describe the field inside,
+    do not apply. Instead the surface currents radiate an electric dipole and
+    a magnetic dipole half as strong and opposite in sign, a1 = 2i x**3/3 and
+    b1 = -a1/2. The sphere absorbs nothing, qext = qsca = 10/3 x**4, and
+    qback = 9 x**4. The two dipoles add backwards and partly cancel forwards,
+    so g = -2/5 and the backscattered intensity is nine times the forward one.
+
+Examples:
+    A small absorbing sphere, compared with the full Mie solution:
+
+    >>> import numpy as np
+    >>> import miepython as mie
+    >>> from miepython import rayleigh
+    >>> qext, qsca, qback, g = rayleigh.efficiencies_mx(1.5 - 0.1j, 0.1)
+    >>> print(f"{qext:.5f} {qsca:.6f} {g:.4f}")
+    0.02006 0.000024 0.0000
+    >>> qext, qsca, qback, g = mie.efficiencies_mx(1.5 - 0.1j, 0.1)
+    >>> print(f"{qext:.5f} {qsca:.6f} {g:.4f}")
+    0.02006 0.000024 0.0020
+
+    The dipole pattern scatters equally forwards and backwards, and half as
+    much at 90 degrees:
+
+    >>> mu = np.array([-1.0, 0.0, 1.0])
+    >>> print(np.round(rayleigh.i_unpolarized(1.5, 0.1, mu), 4))
+    [0.1195 0.0597 0.1195]
+    >>> print(np.round(mie.i_unpolarized(1.5, 0.1, mu), 4))
+    [0.1188 0.0597 0.1199]
+
+    A perfect conductor scatters mostly backwards:
+
+    >>> qext, qsca, qback, g = rayleigh.efficiencies_mx(-1j, 0.1)
+    >>> print(f"{qsca:.4e} {qback:.4e} {g:.4f}")
+    3.3333e-04 9.0000e-04 -0.4000
+    >>> qext, qsca, qback, g = mie.efficiencies_mx(-1j, 0.1)
+    >>> print(f"{qsca:.4e} {qback:.4e} {g:.4f}")
+    3.3413e-04 8.9834e-04 -0.3973
+"""
 
 import numpy as np
 
+from .core import _check_m_x, _check_one_sphere
 from .core import normalization_factor as core_normalization_factor
 
 __all__ = (
@@ -20,7 +138,9 @@ def efficiencies_mx(m, x):
     """
     Calculate the efficiencies for a small sphere.
 
-    Based on equations 5.7 - 5.9 in Bohren and Huffman
+    Based on equations 5.7 - 5.9 in Bohren and Huffman.  A perfect conductor,
+    m.real == 0, uses the electric and magnetic dipoles instead; the module
+    docstring gives the details.
 
     Args:
         m: the complex index of refraction of the sphere
@@ -30,14 +150,43 @@ def efficiencies_mx(m, x):
         qext: the total extinction efficiency
         qsca: the scattering efficiency
         qback: the backscatter efficiency
-        g: the average cosine of the scattering phase function
+        g: the average cosine of the scattering phase function, 0 for a dielectric, -0.4 for a conductor
+
+    Raises:
+        ValueError: if m or x is not finite, x is negative, or the real part of
+            m is negative, exactly as for the full Mie functions
     """
-    ratio = (m**2 - 1) / (m**2 + 2)
-    qsca = 8 / 3 * x**4 * abs(ratio) ** 2
-    qext = 4 * x * ratio * (1 + x**2 / 15 * ratio * (m**4 + 27 * m**2 + 38) / (2 * m**2 + 3))
-    qext = abs(qext.imag + qsca)
-    qback = 4 * x**4 * abs(ratio) ** 2
-    g = 0
+    _check_m_x(m, x)
+
+    # ensure imaginary part of refractive index is negative, as core.py does
+    if np.isscalar(m):
+        m = np.conj(m) if np.imag(m) > 0 else m
+    else:
+        m = np.where(np.imag(m) > 0, np.conj(m), m)
+
+    # the dielectric expressions are evaluated for every entry and then replaced
+    # where m is a conductor; a few conductor indices, m = -1j*sqrt(2) and
+    # m = -1j*sqrt(1.5), make their denominators vanish, so silence the warnings
+    with np.errstate(divide="ignore", invalid="ignore"):
+        ratio = (m**2 - 1) / (m**2 + 2)
+        qsca = 8 / 3 * x**4 * abs(ratio) ** 2
+        # Bohren & Huffman write m = n + ik, so with m = n - ik the absorption term
+        # changes sign.  The x**4 term is Re(ratio**2), not |ratio|**2: the two only
+        # agree for a non-absorbing sphere, and the difference matters near resonance.
+        qabs = -4 * x * (ratio * (1 + x**2 / 15 * ratio * (m**4 + 27 * m**2 + 38) / (2 * m**2 + 3))).imag
+        qext = qabs + 8 / 3 * x**4 * (ratio**2).real
+        qback = 4 * x**4 * abs(ratio) ** 2
+
+    # A perfect conductor (m.real == 0) radiates a magnetic dipole half as strong
+    # as, and opposite to, its electric one: a1 = 2i x**3/3 and b1 = -a1/2.  It
+    # absorbs nothing, scatters 6/x**2 (|a1|**2 + |b1|**2) = 10/3 x**4, and the
+    # interference of the two dipoles throws light backwards, so g = -2/5.
+    conductor = np.real(m) == 0
+    qsca = np.where(conductor, 10 / 3 * x**4, qsca)[()]
+    qext = np.where(conductor, 10 / 3 * x**4, qext)[()]
+    qback = np.where(conductor, 9 * x**4, qback)[()]
+    # a dielectric's electric dipole alone scatters symmetrically fore and aft
+    g = np.where(conductor, -0.4, 0 * qsca)[()]
     return qext, qsca, qback, g
 
 
@@ -84,7 +233,8 @@ def S1_S2(m, x, mu, norm="albedo"):
     """
     Calculate the scattering amplitude functions for small spheres.
 
-    Based on equation 5.4 in Bohren and Huffman
+    Based on equation 5.4 in Bohren and Huffman.  A perfect conductor,
+    m.real == 0, adds the magnetic dipole b1 = -a1/2 to its electric one.
 
     The amplitude functions are normalized so that when integrated
     over all 4*pi solid angles, the integral will be qext*pi*x**2.
@@ -99,15 +249,29 @@ def S1_S2(m, x, mu, norm="albedo"):
 
     Returns:
         S1, S2: the scattering amplitudes at each angle mu [sr**(-0.5)]
+
+    Raises:
+        ValueError: if m or x is not finite, x is negative, or the real part of
+            m is negative, exactly as for the full Mie functions, or if m or x
+            is an array, since this describes one sphere
     """
+    _check_m_x(m, x)
+    _check_one_sphere(m, x)
     if np.imag(m) > 0:  # ensure imaginary part of refractive index is negative
         m = np.conj(m)
 
-    a1 = (2 * x**3) / 3 * (m**2 - 1) / (m**2 + 2) * 1j
-    a1 += (2 * x**5) / 5 * (m**2 - 2) * (m**2 - 1) / (m**2 + 2) ** 2 * 1j
-
-    S1 = (3 / 2) * a1 * np.ones_like(mu)
-    S2 = (3 / 2) * a1 * mu
+    if np.real(m) == 0:
+        # perfect conductor: an electric dipole and a magnetic one, b1 = -a1/2
+        a1 = 2j * x**3 / 3
+        b1 = -a1 / 2
+    else:
+        a1 = (2 * x**3) / 3 * (m**2 - 1) / (m**2 + 2) * 1j
+        a1 += (2 * x**5) / 5 * (m**2 - 2) * (m**2 - 1) / (m**2 + 2) ** 2 * 1j
+        b1 = 0
+
+    # the n = 1 terms of the Mie series, where pi_1 = 1 and tau_1 = mu
+    S1 = (3 / 2) * (a1 * np.ones_like(mu) + b1 * mu)
+    S2 = (3 / 2) * (a1 * mu + b1 * np.ones_like(mu))
 
     normalization = normalization_factor(m, x, norm)
 

{miepython-3.3.0.dist-info → miepython-3.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: miepython
-Version: 3.3.0
+Version: 3.3.1
 Summary: Mie scattering of a plane wave by a sphere
 Author-email: Scott Prahl <scott.prahl@oit.edu>
 License-Expression: MIT
@@ -14,12 +14,12 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3.15
+Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 Requires-Dist: numpy
@@ -47,7 +47,6 @@ Requires-Dist: build; extra == "dev"
 Requires-Dist: check-manifest; extra == "dev"
 Requires-Dist: libarchive-c; extra == "dev"
 Requires-Dist: pyyaml; extra == "dev"
-Requires-Dist: setuptools; extra == "dev"
 Requires-Dist: jupyterlab; extra == "dev"
 Requires-Dist: nbconvert; extra == "dev"
 Requires-Dist: nbformat; extra == "dev"
@@ -211,7 +210,7 @@ Citation
 
 If you use ``miepython`` in academic, instructional, or applied technical work, please cite:
 
-Prahl, S. (2026). *miepython: Pure python calculation of Mie scattering* (Version 3.2.0) [Computer software]. Zenodo. https://doi.org/10.5281/zenodo.7949263
+Prahl, S. (2026). *miepython: Pure python calculation of Mie scattering* (Version 3.3.0) [Computer software]. Zenodo. https://doi.org/10.5281/zenodo.7949263
 
 BibTeX:
 
@@ -223,7 +222,7 @@ BibTeX:
       url     = {https://github.com/scottprahl/miepython},
       doi     = {10.5281/zenodo.7949263},
       year    = {2026},
-      version = {3.2.0},
+      version = {3.3.0},
       publisher = {Zenodo}
     }
 

miepython-3.3.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+miepython/__init__.py,sha256=oWYwelBWxyV7Rc9DQSVKvy-Mx4Ck-k2PjfyShl-5pW0,5888
+miepython/_backend.py,sha256=l_faAa6zanygRZKA9vMVcfcutHPFFkpqZzHqwjU8QcE,1619
+miepython/bessel.py,sha256=U094wY_5RFqrVjXZgMbacmt_yqpP8GBtRZ24-MNzBsU,3647
+miepython/core.py,sha256=zv0hkVBBpcr9GA2xwNAxWHancnh7o5X1mp2xZUoz2Js,24974
+miepython/field.py,sha256=zvTf2g0qca0WRfJ9r2SL5YDGObfTYlOpcXUY9BoOQjA,26583
+miepython/mie_jit.py,sha256=kYy9UCfuEgPSL0XY7P8Qx4IqBr9BbffusF6oeZdTnvQ,21685
+miepython/mie_nojit.py,sha256=EGWqpvdnWOOV72x2wPy8TOSYXLguKXKQn-LzRXYpkrs,20315
+miepython/monte_carlo.py,sha256=1pRELa63NcZOkhSe2AviObPztPaKe7JRqMBQn3rp9Ls,8422
+miepython/rayleigh.py,sha256=6PMTNRs_0u3n9-7bBgJ9-QTB-pmGoPs29iOxj3Eub78,16939
+miepython/util.py,sha256=3jxGd0jmPFYolllQXISLDmz0jE4C1AyFD1OyD65dUGo,3648
+miepython/vsh.py,sha256=bPmEBCxbjCcNgisw3qQR-Zso46-aGPrnv9VBu7jhyTM,18114
+miepython/data/Johnson.txt,sha256=PcdEhJ3ZKUnt--86ukEvUt-w-814uOyWXtE-G3qWTNE,1337
+miepython/data/segelstein81_index.txt,sha256=aJLqcPIkw-0WDY37GRcTefLV0WGhyMt6IbOKY8JxGww,36719
+miepython-3.3.1.dist-info/licenses/LICENSE.txt,sha256=g9-BWWRLvMDMQ1Zflxliku7Sleom1_SbXHQHOLGgqqk,1055
+miepython-3.3.1.dist-info/METADATA,sha256=AlX1gk-tBQ2Z6km4sptmW2cGUx51DDAw4nEE0Gz30YE,7789
+miepython-3.3.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+miepython-3.3.1.dist-info/top_level.txt,sha256=bfkk6YwrKm_aIzInR5y03YbywpwCzUjJEHaFkEiSKxI,10
+miepython-3.3.1.dist-info/RECORD,,

{miepython-3.3.0.dist-info → miepython-3.3.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (83.0.0)
+Generator: setuptools (84.2.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

miepython-3.3.0.dist-info/RECORD

@@ -1,18 +0,0 @@
-miepython/__init__.py,sha256=DCQbT9uj3NC33GNii2P242pbCKFffe4tg7_qszNKpKE,5888
-miepython/_backend.py,sha256=l_faAa6zanygRZKA9vMVcfcutHPFFkpqZzHqwjU8QcE,1619
-miepython/bessel.py,sha256=U094wY_5RFqrVjXZgMbacmt_yqpP8GBtRZ24-MNzBsU,3647
-miepython/core.py,sha256=SxppxzCwor0qFNMTPReBM6SZTDhuhuWyrnFEdm8fiQE,22519
-miepython/field.py,sha256=3CFj0Tg764fT-BABSGjmhOGiBiUUsqDuVheXToGb7Wg,26494
-miepython/mie_jit.py,sha256=kYy9UCfuEgPSL0XY7P8Qx4IqBr9BbffusF6oeZdTnvQ,21685
-miepython/mie_nojit.py,sha256=EGWqpvdnWOOV72x2wPy8TOSYXLguKXKQn-LzRXYpkrs,20315
-miepython/monte_carlo.py,sha256=ZEccQCkqlbqFOXmVmVzgWx41nBJ-Yuj45-cxYDLZjDY,6015
-miepython/rayleigh.py,sha256=cWSmP-N5QXF2u7WPwew_QiI4gyJx4FAZNxSiKFvpCMo,8875
-miepython/util.py,sha256=3jxGd0jmPFYolllQXISLDmz0jE4C1AyFD1OyD65dUGo,3648
-miepython/vsh.py,sha256=bPmEBCxbjCcNgisw3qQR-Zso46-aGPrnv9VBu7jhyTM,18114
-miepython/data/Johnson.txt,sha256=PcdEhJ3ZKUnt--86ukEvUt-w-814uOyWXtE-G3qWTNE,1337
-miepython/data/segelstein81_index.txt,sha256=aJLqcPIkw-0WDY37GRcTefLV0WGhyMt6IbOKY8JxGww,36719
-miepython-3.3.0.dist-info/licenses/LICENSE.txt,sha256=g9-BWWRLvMDMQ1Zflxliku7Sleom1_SbXHQHOLGgqqk,1055
-miepython-3.3.0.dist-info/METADATA,sha256=e6yTtC4kocqZOZOCC7xN6XD3Ao00S2CKphQORmvesKs,7831
-miepython-3.3.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-miepython-3.3.0.dist-info/top_level.txt,sha256=bfkk6YwrKm_aIzInR5y03YbywpwCzUjJEHaFkEiSKxI,10
-miepython-3.3.0.dist-info/RECORD,,