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

miepython/rayleigh.py

@@ -1,7 +1,127 @@
-"""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__ = (
     "efficiencies_mx",
     "efficiencies",
@@ -18,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
@@ -28,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
 
 
@@ -62,7 +213,10 @@ def efficiencies(m, d, lambda0, n_env=1.0):
 
 def normalization_factor(m, x, norm_str):
     """
-    Figure out scattering function normalization.
+    Figure out scattering function normalization for a small sphere.
+
+    The rules are the same as for the full Mie solution, so they live in
+    ``miepython.core``; only the efficiencies feeding them are the Rayleigh ones.
 
     Args:
         m: complex index of refraction of sphere
@@ -72,45 +226,15 @@ def normalization_factor(m, x, norm_str):
     Returns:
         scaling factor needed for scattering function
     """
-    factor = None
-    norm = norm_str.lower()
-
-    if norm in ["bohren"]:
-        factor = 1 / 2
-
-    elif norm in ["wiscombe"]:
-        factor = 1
-
-    elif norm in ["qsca", "scattering_efficiency"]:
-        factor = x * np.sqrt(np.pi)
-
-    else:
-        qext, qsca, _, _ = efficiencies_mx(m, x)
-
-        if norm in ["a", "albedo"]:
-            factor = x * np.sqrt(np.pi * qext)
-
-        if norm in ["1", "one", "unity"]:
-            factor = x * np.sqrt(qsca * np.pi)
-
-        if norm in ["four_pi", "4pi"]:
-            factor = x * np.sqrt(qsca / 4)
-
-        if norm in ["qext", "extinction_efficiency"]:
-            factor = x * np.sqrt(qsca * np.pi / qext)
-
-    if factor is None:
-        raise ValueError(
-            "normalization must be one of 'albedo' (default), 'one', '4pi', 'qext', 'qsca', 'bohren', or 'wiscombe'"
-        )
-    return factor
+    return core_normalization_factor(m, x, norm_str, efficiency_source=efficiencies_mx)
 
 
 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.
@@ -125,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
+    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
 
-    S1 = (3 / 2) * a1 * np.ones_like(mu)
-    S2 = (3 / 2) * a1 * mu
+    # 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/util.py

@@ -2,10 +2,11 @@
 
 import numpy as np
 
-_all_ = (
+__all__ = (
     "cs_scalar",
     "cs_vector",
     "cs",
+    "phasor_str_scalar",
     "phasor_str",
     "cartesian_to_spherical",
     "spherical_to_cartesian",
@@ -14,10 +15,29 @@ _all_ = (
 
 
 def cartesian_to_spherical(x, y, z):
-    """Convert Cartesian coordinates (x, y, z) to spherical (r, theta, phi)."""
-    r = np.sqrt(x**2 + y**2 + z**2)
-    theta = np.arccos(z / r) if r != 0 else 0  # Polar angle (0 to pi)
-    phi = np.arctan2(y, x)  # Azimuthal angle (-pi to pi)
+    """
+    Convert Cartesian coordinates (x, y, z) to spherical (r, theta, phi).
+
+    Scalars and arrays are both accepted and the three inputs are broadcast
+    against each other.  At the origin theta is reported as 0, and z/r is clipped
+    so that rounding cannot push the arccos argument outside [-1, 1].
+
+    Args:
+        x: Cartesian x coordinate, scalar or array-like
+        y: Cartesian y coordinate, scalar or array-like
+        z: Cartesian z coordinate, scalar or array-like
+
+    Returns:
+        r, theta, phi: radius, polar angle from +z, azimuth from +x toward +y
+    """
+    xx, yy, zz = np.broadcast_arrays(np.asarray(x), np.asarray(y), np.asarray(z))
+    r = np.sqrt(xx**2 + yy**2 + zz**2)
+
+    with np.errstate(divide="ignore", invalid="ignore"):
+        cos_theta = np.where(r == 0, 1.0, np.clip(zz / r, -1.0, 1.0))
+
+    theta = np.arccos(cos_theta)  # polar angle (0 to pi)
+    phi = np.arctan2(yy, xx)  # azimuthal angle (-pi to pi)
     return r, theta, phi
 
 

miepython/vsh.py

@@ -29,18 +29,27 @@ Bessel Function Selection:
 
 Functions:
 
-    M_odd(n, k, d_sphere, r, theta, phi)
+    All four take the same arguments ``(n, lambda0, d_sphere, m_index, r, theta,
+    phi)``: the multipole order, the vacuum wavelength, the sphere diameter, the
+    refractive index of the medium the point lies in, and the spherical coordinates
+    of that point.  ``lambda0``, ``d_sphere`` and ``r`` share one length unit.
+
+    M_odd(n, lambda0, d_sphere, m_index, r, theta, phi)
         Compute the nth odd magnetic vector spherical harmonic (m=1).
 
-    M_even(n, k, d_sphere, r, theta, phi)
+    M_even(n, lambda0, d_sphere, m_index, r, theta, phi)
         Compute the nth even magnetic vector spherical harmonic (m=1).
 
-    N_odd(n, k, d_sphere, r, theta, phi)
+    N_odd(n, lambda0, d_sphere, m_index, r, theta, phi)
         Compute the nth odd electric vector spherical harmonic (m=1).
 
-    N_even(n, k, d_sphere, r, theta, phi)
+    N_even(n, lambda0, d_sphere, m_index, r, theta, phi)
         Compute the nth even electric vector spherical harmonic (m=1).
 
+    Each has an ``*_array`` counterpart -- ``M_odd_array``, ``M_even_array``,
+    ``N_odd_array``, ``N_even_array`` -- with the identical signature, taking
+    array-valued ``r``, ``theta`` and ``phi``.
+
 Additional Utility Functions:
 
     mie_pi(n, theta, deg=False)
@@ -54,8 +63,8 @@ Additional Utility Functions:
 
 import numpy as np
 from scipy.special import spherical_jn, lpmv, factorial2
-from miepython.bessel import spherical_h1, d_riccati_bessel_h1
-import miepython as mie
+from .bessel import spherical_h1, d_riccati_bessel_h1
+from ._backend import D_calc
 
 __all__ = (
     "mie_tau",
@@ -312,7 +321,7 @@ def N_base(n, m_index, kr, theta, inside):
         else:
             factor1 = spherical_jn(n, rho)
             # D_calc returns D_1..D_N; request one extra term and take D_n.
-            Dn = mie.D_calc(m_index, kr, n + 1)[n - 1]
+            Dn = D_calc(m_index, kr, n + 1)[n - 1]
             factor2 = factor1 * Dn
             factor1 /= rho
     else:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: miepython
-Version: 3.2.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
@@ -34,6 +34,7 @@ Requires-Dist: sphinx_automodapi; extra == "docs"
 Requires-Dist: sphinx_rtd_theme; extra == "docs"
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: imageio; extra == "dev"
 Requires-Dist: requests; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
@@ -46,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"
@@ -72,7 +72,7 @@ Dynamic: license-file
    :alt: DOI
 
 .. |license| image:: https://img.shields.io/github/license/scottprahl/miepython?color=68CA66
-   :target: https://github.com/scottprahl/miepython/blob/master/LICENSE.txt
+   :target: https://github.com/scottprahl/miepython/blob/main/LICENSE.txt
    :alt: License
 
 .. |test| image:: https://github.com/scottprahl/miepython/actions/workflows/test.yaml/badge.svg
@@ -208,9 +208,9 @@ JIT Enabled  0.15 s       27×
 Citation
 --------
 
-If you use ``laserbeamsize`` in academic, instructional, or applied technical work, please cite:
+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.1.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:
 
@@ -222,7 +222,7 @@ BibTeX:
       url     = {https://github.com/scottprahl/miepython},
       doi     = {10.5281/zenodo.7949263},
       year    = {2026},
-      version = {3.1.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.2.0.dist-info → miepython-3.3.1.dist-info}/WHEEL

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

miepython-3.2.0.dist-info/RECORD

@@ -1,18 +0,0 @@
-miepython/__init__.py,sha256=Hs1MtLbYN1trH8aAIT4uiZASWTtCTu3gki5MNq3HdXs,4516
-miepython/_backend.py,sha256=l_faAa6zanygRZKA9vMVcfcutHPFFkpqZzHqwjU8QcE,1619
-miepython/bessel.py,sha256=U094wY_5RFqrVjXZgMbacmt_yqpP8GBtRZ24-MNzBsU,3647
-miepython/core.py,sha256=_6bceok2AZ5-rxgLw8AZ0qR-x0dPfgjoaY7EUE12FaE,19404
-miepython/field.py,sha256=_kD5lAFJPGhBEjx33wBzqaxho2YBLBImKz5IRmlk8lY,26979
-miepython/mie_jit.py,sha256=wSxuo3Dhhm08tTcWRJeuNxwziM6mnlPwnQHZkaDFILs,16282
-miepython/mie_nojit.py,sha256=Vu5jQLr-wNWjAbNSdNfJynyizn_mWL8kX-KtowYGywU,16216
-miepython/monte_carlo.py,sha256=gemJ2vhUyiTg-hAneGRW3typd3SFM2LL4R2o1UAzLeA,3818
-miepython/rayleigh.py,sha256=P-rpa9SKVH3RaxuUUiZzQYYk6c3cFF6vDAAgo9xChz8,9401
-miepython/util.py,sha256=LQEDkJqz6GHVHYog2JzTE12Ibv2ncLeMI20S8IjZzAc,2908
-miepython/vsh.py,sha256=7uHo2o_cFJ2NzB7QfTI3ABJGEZSaO7ndUdxlY5BG3bo,17532
-miepython/data/Johnson.txt,sha256=PcdEhJ3ZKUnt--86ukEvUt-w-814uOyWXtE-G3qWTNE,1337
-miepython/data/segelstein81_index.txt,sha256=aJLqcPIkw-0WDY37GRcTefLV0WGhyMt6IbOKY8JxGww,36719
-miepython-3.2.0.dist-info/licenses/LICENSE.txt,sha256=g9-BWWRLvMDMQ1Zflxliku7Sleom1_SbXHQHOLGgqqk,1055
-miepython-3.2.0.dist-info/METADATA,sha256=LNH39wbRza2D0DymlOpJ2FBAPsy9k08zwfsxIpYTjKE,7795
-miepython-3.2.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
-miepython-3.2.0.dist-info/top_level.txt,sha256=bfkk6YwrKm_aIzInR5y03YbywpwCzUjJEHaFkEiSKxI,10
-miepython-3.2.0.dist-info/RECORD,,