physicskit 0.3.0__tar.gz → 0.4.0__tar.gz

physicskit-0.4.0/MANIFEST.in

@@ -0,0 +1,7 @@
+# The sdist carries the full test suite (each subpackage's tests/) for
+# downstream packagers; the wheel does not, via exclude-package-data in
+# pyproject.toml.
+graft physicskit
+prune physicskit/rmt/tests/.physicskit.rmt_test_cache
+prune physicskit/rmt/tests/.rmtkit_test_cache
+global-exclude __pycache__ *.py[cod] *.nbi *.nbc .DS_Store

{physicskit-0.3.0 → physicskit-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: physicskit
-Version: 0.3.0
+Version: 0.4.0
 Summary: Unified scientific toolkit for computational physics: General Relativity, Quantum Mechanics, Chaos, Random Matrix Theory, Statistical Mechanics, Classical Dynamics, and Condensed Matter.
 Author-email: Charles Poli <cpoli374@gmail.com>
 Maintainer-email: Charles Poli <cpoli374@gmail.com>
@@ -61,7 +61,7 @@ Dynamic: license-file
 
 | | |
 |:--|:-:|
-| Package | [![PyPI version](https://img.shields.io/pypi/v/physicskit)](https://pypi.org/project/physicskit/) [![Python versions](https://img.shields.io/pypi/pyversions/physicskit)](https://pypi.org/project/physicskit/) |
+| Package | [![PyPI version](https://img.shields.io/pypi/v/physicskit)](https://pypi.org/project/physicskit/) [![Python versions](https://img.shields.io/pypi/pyversions/physicskit)](https://pypi.org/project/physicskit/) [![DOI](https://zenodo.org/badge/1369609308.svg)](https://zenodo.org/badge/latestdoi/1369609308) |
 | Quality | [![License](https://img.shields.io/github/license/cpoli/physicskit)](https://github.com/cpoli/physicskit/blob/main/LICENSE) [![CI](https://github.com/cpoli/physicskit/actions/workflows/ci.yml/badge.svg)](https://github.com/cpoli/physicskit/actions/workflows/ci.yml) [![Coverage](https://img.shields.io/codecov/c/github/cpoli/physicskit)](https://codecov.io/gh/cpoli/physicskit) [![Coverage (manual)](https://img.shields.io/badge/coverage-96%25-brightgreen)](#coverage) |
 | Documentation | [![Docs](https://img.shields.io/badge/docs-cpoli.github.io%2Fphysicskit-blue)](https://cpoli.github.io/physicskit/) |
 | Code style | [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff) |
@@ -235,8 +235,7 @@ MPLBACKEND=Agg pytest --doctest-modules physicskit \
 
 Both commands, plus `ruff check`/`ruff format --check`, run in CI on
 every PR (`.github/workflows/ci.yml`) across Python 3.10-3.14 on Linux and
-macOS, as does `mypy` on the typed core (`constants`, `integrators`,
-`units`, `results`, `io`). See [CONTRIBUTING.md](CONTRIBUTING.md) before
+macOS, as does `mypy` on the whole package. See [CONTRIBUTING.md](CONTRIBUTING.md) before
 opening a PR.
 
 Performance benchmarks for the shared integrators and three representative
@@ -268,7 +267,8 @@ trace into numba-compiled native code.
 ## Docs
 
 Built docs are hosted at <https://cpoli.github.io/physicskit/>, served from
-the `gh-pages` branch. To build locally:
+the `gh-pages` branch, which CI redeploys on every push to `main` and on
+each release. To build locally:
 
 ```bash
 pip install -e ".[docs]"

{physicskit-0.3.0 → physicskit-0.4.0}/README.md

@@ -2,7 +2,7 @@
 
 | | |
 |:--|:-:|
-| Package | [![PyPI version](https://img.shields.io/pypi/v/physicskit)](https://pypi.org/project/physicskit/) [![Python versions](https://img.shields.io/pypi/pyversions/physicskit)](https://pypi.org/project/physicskit/) |
+| Package | [![PyPI version](https://img.shields.io/pypi/v/physicskit)](https://pypi.org/project/physicskit/) [![Python versions](https://img.shields.io/pypi/pyversions/physicskit)](https://pypi.org/project/physicskit/) [![DOI](https://zenodo.org/badge/1369609308.svg)](https://zenodo.org/badge/latestdoi/1369609308) |
 | Quality | [![License](https://img.shields.io/github/license/cpoli/physicskit)](https://github.com/cpoli/physicskit/blob/main/LICENSE) [![CI](https://github.com/cpoli/physicskit/actions/workflows/ci.yml/badge.svg)](https://github.com/cpoli/physicskit/actions/workflows/ci.yml) [![Coverage](https://img.shields.io/codecov/c/github/cpoli/physicskit)](https://codecov.io/gh/cpoli/physicskit) [![Coverage (manual)](https://img.shields.io/badge/coverage-96%25-brightgreen)](#coverage) |
 | Documentation | [![Docs](https://img.shields.io/badge/docs-cpoli.github.io%2Fphysicskit-blue)](https://cpoli.github.io/physicskit/) |
 | Code style | [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff) |
@@ -176,8 +176,7 @@ MPLBACKEND=Agg pytest --doctest-modules physicskit \
 
 Both commands, plus `ruff check`/`ruff format --check`, run in CI on
 every PR (`.github/workflows/ci.yml`) across Python 3.10-3.14 on Linux and
-macOS, as does `mypy` on the typed core (`constants`, `integrators`,
-`units`, `results`, `io`). See [CONTRIBUTING.md](CONTRIBUTING.md) before
+macOS, as does `mypy` on the whole package. See [CONTRIBUTING.md](CONTRIBUTING.md) before
 opening a PR.
 
 Performance benchmarks for the shared integrators and three representative
@@ -209,7 +208,8 @@ trace into numba-compiled native code.
 ## Docs
 
 Built docs are hosted at <https://cpoli.github.io/physicskit/>, served from
-the `gh-pages` branch. To build locally:
+the `gh-pages` branch, which CI redeploys on every push to `main` and on
+each release. To build locally:
 
 ```bash
 pip install -e ".[docs]"

{physicskit-0.3.0 → physicskit-0.4.0}/physicskit/__init__.py

@@ -36,7 +36,7 @@ from physicskit import (
     units,
 )
 
-__version__ = "0.3.0"
+__version__ = "0.4.0"
 
 __all__ = [
     "astro",

{physicskit-0.3.0 → physicskit-0.4.0}/physicskit/astro/__init__.py

@@ -14,6 +14,11 @@ geometrized units.
   state-vector conversion, and Hohmann transfers.
 - :mod:`physicskit.astro.galactic_dynamics` -- the NFW dark matter halo
   profile and the rotation curves it produces.
+- :mod:`physicskit.astro.sph` -- smoothed-particle hydrodynamics in one
+  dimension, checked on Sod's shock tube.
+- :mod:`physicskit.astro.radiative_transfer` -- the grey plane-parallel
+  atmosphere: the Eddington approximation, the exact Hopf function and
+  limb darkening.
 - :mod:`physicskit.astro.visualizers` -- N-body, Lane-Emden, and
   rotation-curve plots.
 """
@@ -27,6 +32,13 @@ from physicskit.astro.orbital_mechanics import (
     state_from_orbital_elements,
     vis_viva_speed,
 )
+from physicskit.astro.radiative_transfer import (
+    GreyAtmosphere,
+    eddington_limb_darkening,
+    eddington_temperature,
+    emergent_intensity,
+)
+from physicskit.astro.sph import SPH1D, cubic_spline_kernel
 from physicskit.astro.stellar_structure import (
     PolytropicStar,
     chandrasekhar_mass,
@@ -63,4 +75,12 @@ __all__ = [
     "plot_nbody_trajectories",
     "plot_lane_emden",
     "plot_rotation_curve",
+    # sph
+    "SPH1D",
+    "cubic_spline_kernel",
+    # radiative_transfer
+    "GreyAtmosphere",
+    "eddington_limb_darkening",
+    "eddington_temperature",
+    "emergent_intensity",
 ]

physicskit-0.4.0/physicskit/astro/radiative_transfer.py

@@ -0,0 +1,209 @@
+"""Grey radiative transfer in a plane-parallel stellar atmosphere.
+
+Radiation crossing a stellar atmosphere obeys, at optical depth :math:`\\tau`
+and direction cosine :math:`\\mu`,
+
+.. math::
+
+    \\mu\\frac{dI}{d\\tau} = I - S.
+
+For a *grey* opacity (independent of frequency) in radiative equilibrium the
+source function equals the mean intensity, :math:`S = J`, and the flux
+:math:`F = \\sigma T_{\\text{eff}}^4` is constant with depth. The solution
+is (Milne 1921; Hopf 1930)
+
+.. math::
+
+    T^4(\\tau) = \\tfrac34 T_{\\text{eff}}^4\\,[\\tau + q(\\tau)],
+
+where the Hopf function :math:`q` rises from :math:`1/\\sqrt3` at the
+surface to :math:`0.7104` deep inside. Eddington's (1926) approximation,
+closing the moment equations with :math:`K = J/3`, gives the constant
+:math:`q = 2/3`, and with it the limb darkening :math:`I(0, \\mu)/I(0, 1) =
+(2 + 3\\mu)/5`.
+
+:class:`GreyAtmosphere` solves the problem exactly in Chandrasekhar's
+discrete-ordinates method (Astrophys. J. 100, 76 (1944); *Radiative
+Transfer*, 1950, ch. III), which converges to the exact solution as the
+number of streams grows and keeps :math:`q(0) = 1/\\sqrt3` exactly in every
+order.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+from scipy.optimize import brentq
+
+__all__ = ["GreyAtmosphere", "eddington_limb_darkening", "eddington_temperature", "emergent_intensity"]
+
+
+def eddington_temperature(tau: ArrayLike, T_eff: float = 1.0) -> NDArray[np.float64]:
+    """Eddington's grey temperature law :math:`T^4 = \\tfrac34 T_{\\text{eff}}^4(\\tau + 2/3)`.
+
+    Parameters
+    ----------
+    tau : array_like
+        Optical depth.
+    T_eff : float, default 1.0
+
+    Returns
+    -------
+    ndarray
+
+    Examples
+    --------
+    >>> float(eddington_temperature(2 / 3, T_eff=5772.0))  # T = T_eff at tau = 2/3
+    5772.0
+    """
+    tau = np.asarray(tau, dtype=float)
+    return T_eff * (0.75 * (tau + 2.0 / 3.0)) ** 0.25
+
+
+def eddington_limb_darkening(mu: ArrayLike) -> NDArray[np.float64]:
+    """Eddington limb darkening :math:`I(0,\\mu)/I(0,1) = (2 + 3\\mu)/5`.
+
+    Parameters
+    ----------
+    mu : array_like
+        Cosine of the angle from the disc normal (1 at disc centre, 0 at the limb).
+
+    Returns
+    -------
+    ndarray
+    """
+    return (2.0 + 3.0 * np.asarray(mu, dtype=float)) / 5.0
+
+
+def emergent_intensity(source, mu: ArrayLike, n: int = 64) -> NDArray[np.float64]:
+    """Formal solution :math:`I(0, \\mu) = \\int_0^\\infty S(\\tau)e^{-\\tau/\\mu}\\,d\\tau/\\mu`.
+
+    Evaluated by :math:`n`-point Gauss-Laguerre quadrature in :math:`t = \\tau/\\mu`.
+
+    Parameters
+    ----------
+    source : callable
+        Vectorized source function :math:`S(\\tau)`.
+    mu : array_like
+        Direction cosines in :math:`(0, 1]`.
+    n : int, default 64
+        Quadrature points.
+
+    Returns
+    -------
+    ndarray
+
+    Examples
+    --------
+    A linear source function :math:`S = a + b\\tau` emerges as :math:`a + b\\mu`
+    (the Eddington-Barbier relation):
+
+    >>> round(float(emergent_intensity(lambda t: 1 + 2 * t, 0.5)), 10)
+    2.0
+    """
+    mu_arr = np.asarray(mu, dtype=float)
+    t, w = np.polynomial.laguerre.laggauss(n)
+    out = np.array([np.sum(w * source(m * t)) for m in mu_arr.ravel()])
+    return out.reshape(mu_arr.shape)
+
+
+class GreyAtmosphere:
+    """Exact grey atmosphere in Chandrasekhar's :math:`n`-stream discrete-ordinates approximation.
+
+    With Gauss-Legendre nodes :math:`\\pm\\mu_i` and weights :math:`a_i`
+    (:math:`i = 1..n`), the intensities are
+
+    .. math::
+
+        I(\\tau, \\mu_i) = \\tfrac34 F\\left[\\tau + \\mu_i + Q + \\sum_{\\alpha=1}^{n-1}
+                          \\frac{L_\\alpha e^{-k_\\alpha\\tau}}{1 + k_\\alpha\\mu_i}\\right],
+
+    where the :math:`k_\\alpha` are the positive roots of
+    :math:`\\sum_i a_i/(1 - k^2\\mu_i^2) = 1` and :math:`Q`, :math:`L_\\alpha`
+    follow from no incoming radiation at :math:`\\tau = 0`. The Hopf function
+    is :math:`q(\\tau) = Q + \\sum_\\alpha L_\\alpha e^{-k_\\alpha\\tau}`.
+
+    Parameters
+    ----------
+    n_streams : int, default 32
+        Number :math:`n` of directions per hemisphere.
+
+    Attributes
+    ----------
+    Q : float
+        :math:`q(\\infty)`, which tends to Hopf's 0.710446 as :math:`n` grows.
+    k, L : ndarray
+        Decay constants and amplitudes of the transient terms.
+
+    Examples
+    --------
+    >>> atm = GreyAtmosphere()
+    >>> round(float(atm.hopf(0.0)), 6)  # 1/sqrt(3) in every approximation
+    0.57735
+    >>> round(atm.Q, 4)
+    0.7104
+    """
+
+    def __init__(self, n_streams: int = 32):
+        if n_streams < 1:
+            raise ValueError("n_streams must be at least 1")
+        nodes, weights = np.polynomial.legendre.leggauss(2 * n_streams)
+        pos = nodes > 0
+        self.mu = nodes[pos]
+        self.a = weights[pos]  # full-range weights sum to 2, so these sum to 1
+        self.n = n_streams
+
+        def characteristic(k):
+            return np.sum(self.a / (1.0 - k**2 * self.mu**2)) - 1.0
+
+        # one root between consecutive poles 1/mu_i, ordered by decreasing mu
+        poles = np.sort(1.0 / self.mu)
+        roots = [brentq(characteristic, p1 * (1 + 1e-12), p2 * (1 - 1e-12)) for p1, p2 in zip(poles[:-1], poles[1:])]
+        self.k = np.array(roots)
+        # boundary condition I(0, -mu_i) = 0:  Q + sum_a L_a / (1 - k_a mu_i) = mu_i
+        A = np.ones((self.n, self.n))
+        if self.n > 1:
+            A[:, 1:] = 1.0 / (1.0 - np.outer(self.mu, self.k))
+        sol = np.linalg.solve(A, self.mu)
+        self.Q = float(sol[0])
+        self.L = sol[1:]
+
+    def hopf(self, tau: ArrayLike) -> NDArray[np.float64]:
+        """Hopf function :math:`q(\\tau)`.
+
+        Parameters
+        ----------
+        tau : array_like
+
+        Returns
+        -------
+        ndarray
+        """
+        tau = np.asarray(tau, dtype=float)
+        return self.Q + np.sum(self.L * np.exp(-np.multiply.outer(tau, self.k)), axis=-1)
+
+    def temperature(self, tau: ArrayLike, T_eff: float = 1.0) -> NDArray[np.float64]:
+        """:math:`T(\\tau) = T_{\\text{eff}}\\,[\\tfrac34(\\tau + q(\\tau))]^{1/4}`."""
+        tau = np.asarray(tau, dtype=float)
+        return T_eff * (0.75 * (tau + self.hopf(tau))) ** 0.25
+
+    def emergent_intensity(self, mu: ArrayLike) -> NDArray[np.float64]:
+        """Emergent intensity in units of :math:`F/\\pi = \\sigma T_{\\text{eff}}^4/\\pi`.
+
+        The Laplace transform of :math:`S = \\tfrac34 F(\\tau + q)/\\pi` gives
+        :math:`I(0, \\mu) = \\tfrac34\\left[\\mu + Q + \\sum_\\alpha L_\\alpha/(1 + k_\\alpha\\mu)\\right]`.
+
+        Parameters
+        ----------
+        mu : array_like
+
+        Returns
+        -------
+        ndarray
+        """
+        mu = np.asarray(mu, dtype=float)
+        return 0.75 * (mu + self.Q + np.sum(self.L / (1.0 + np.multiply.outer(mu, self.k)), axis=-1))
+
+    def limb_darkening(self, mu: ArrayLike) -> NDArray[np.float64]:
+        """Normalized limb darkening :math:`I(0, \\mu)/I(0, 1)`."""
+        return self.emergent_intensity(mu) / self.emergent_intensity(1.0)

physicskit-0.4.0/physicskit/astro/sph.py

@@ -0,0 +1,277 @@
+"""Smoothed-particle hydrodynamics (SPH) in one dimension.
+
+SPH represents a gas by particles of fixed mass :math:`m` that move with the
+flow (Lucy, Astron. J. 82, 1013 (1977); Gingold and Monaghan, MNRAS 181, 375
+(1977)). Every field is a kernel-weighted sum over neighbours; the density
+is
+
+.. math::
+
+    \\rho_i = \\sum_j m_j W(x_i - x_j, h_i),
+
+and the Euler equations become ordinary differential equations for the
+particles (Monaghan, Annu. Rev. Astron. Astrophys. 30, 543 (1992)),
+
+.. math::
+
+    \\frac{dv_i}{dt} = -\\sum_j m_j\\left(\\frac{P_i}{\\rho_i^2} + \\frac{P_j}{\\rho_j^2}
+                       + \\Pi_{ij}\\right)\\partial_i W_{ij},
+    \\qquad
+    \\frac{du_i}{dt} = \\frac12\\sum_j m_j\\left(\\frac{P_i}{\\rho_i^2} + \\frac{P_j}{\\rho_j^2}
+                       + \\Pi_{ij}\\right) v_{ij}\\,\\partial_i W_{ij},
+
+with :math:`P = (\\gamma - 1)\\rho u`, the cubic-spline kernel, and Monaghan's
+artificial viscosity :math:`\\Pi_{ij}` to capture shocks. Because the
+particles follow the mass, resolution concentrates where the gas is dense,
+which is why SPH became the standard method for star formation, galaxy
+mergers and cosmological gas. :class:`SPH1D` evolves these equations, and
+:meth:`SPH1D.sod_shock_tube` sets up Sod's test problem.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from numba import njit
+from numpy.typing import NDArray
+
+__all__ = ["SPH1D", "cubic_spline_kernel"]
+
+
+@njit(cache=True)
+def _w(r, h):
+    q = abs(r) / h
+    sigma = 2.0 / (3.0 * h)
+    if q < 1.0:
+        return sigma * (1.0 - 1.5 * q * q + 0.75 * q**3)
+    if q < 2.0:
+        return sigma * 0.25 * (2.0 - q) ** 3
+    return 0.0
+
+
+@njit(cache=True)
+def _dw(r, h):
+    q = abs(r) / h
+    sigma = 2.0 / (3.0 * h * h)
+    s = 1.0 if r >= 0 else -1.0
+    if q < 1.0:
+        return sigma * s * (-3.0 * q + 2.25 * q * q)
+    if q < 2.0:
+        return -sigma * s * 0.75 * (2.0 - q) ** 2
+    return 0.0
+
+
+def cubic_spline_kernel(r: NDArray[np.float64], h: float) -> NDArray[np.float64]:
+    """The 1D cubic-spline (M4) kernel :math:`W(r, h)`, normalized to :math:`\\int W\\,dr = 1`.
+
+    .. math::
+
+        W = \\frac{2}{3h}\\begin{cases} 1 - \\tfrac32 q^2 + \\tfrac34 q^3, & 0 \\le q < 1, \\\\
+            \\tfrac14(2 - q)^3, & 1 \\le q < 2, \\\\ 0, & q \\ge 2, \\end{cases}
+        \\qquad q = |r|/h.
+
+    Parameters
+    ----------
+    r : ndarray of float
+        Separations.
+    h : float
+        Smoothing length.
+
+    Returns
+    -------
+    ndarray of float
+
+    Examples
+    --------
+    >>> r = np.linspace(-3, 3, 60001)
+    >>> round(float(np.trapezoid(cubic_spline_kernel(r, 1.0), r)), 6)
+    1.0
+    """
+    r = np.asarray(r, dtype=np.float64)
+    return np.array([_w(ri, h) for ri in r.ravel()]).reshape(r.shape)
+
+
+@njit(cache=True)
+def _density(x, m, h, order):
+    n = x.size
+    rho = np.zeros(n)
+    xs = x[order]
+    for a in range(n):
+        i = order[a]
+        rho[i] += m[i] * _w(0.0, h[i])
+        b = a + 1
+        while b < n and xs[b] - x[i] < 2.0 * h[i]:
+            j = order[b]
+            rho[i] += m[j] * _w(x[i] - x[j], h[i])
+            b += 1
+        b = a - 1
+        while b >= 0 and x[i] - xs[b] < 2.0 * h[i]:
+            j = order[b]
+            rho[i] += m[j] * _w(x[i] - x[j], h[i])
+            b -= 1
+    return rho
+
+
+@njit(cache=True)
+def _forces(x, v, m, h, rho, u, gamma, alpha, beta, order):
+    n = x.size
+    acc = np.zeros(n)
+    dudt = np.zeros(n)
+    P = (gamma - 1.0) * rho * u
+    c = np.sqrt(gamma * P / rho)
+    xs = x[order]
+    hmax = h.max()
+    for a in range(n):
+        i = order[a]
+        b = a + 1
+        while b < n and xs[b] - x[i] < 2.0 * hmax:
+            j = order[b]
+            xij = x[i] - x[j]
+            hij = 0.5 * (h[i] + h[j])
+            if abs(xij) < 2.0 * hij:
+                vij = v[i] - v[j]
+                dW = _dw(xij, hij)
+                pi_ij = 0.0
+                if vij * xij < 0.0:
+                    mu = hij * vij * xij / (xij * xij + 0.01 * hij * hij)
+                    pi_ij = (-alpha * 0.5 * (c[i] + c[j]) * mu + beta * mu * mu) / (0.5 * (rho[i] + rho[j]))
+                term = P[i] / rho[i] ** 2 + P[j] / rho[j] ** 2 + pi_ij
+                acc[i] -= m[j] * term * dW
+                acc[j] += m[i] * term * dW
+                dudt[i] += 0.5 * m[j] * term * vij * dW
+                dudt[j] += 0.5 * m[i] * term * vij * dW
+            b += 1
+    return acc, dudt, c
+
+
+class SPH1D:
+    """One-dimensional SPH gas with the cubic-spline kernel and Monaghan artificial viscosity.
+
+    Smoothing lengths follow the density, :math:`h_i = \\eta\\, m_i/\\rho_i`,
+    and the equations are advanced with a kick-drift-kick leapfrog at a
+    Courant-limited time step.
+
+    Parameters
+    ----------
+    x, v : ndarray of float, shape (n,)
+        Particle positions and velocities.
+    m : ndarray of float or float
+        Particle masses.
+    u : ndarray of float, shape (n,)
+        Specific internal energies.
+    gamma : float, default 1.4
+        Adiabatic index.
+    eta : float, default 1.2
+        Smoothing-length factor, in units of the local particle spacing.
+    alpha, beta : float, default 1.0, 2.0
+        Artificial-viscosity coefficients.
+    fixed : ndarray of bool, optional
+        Particles held at rest (boundaries).
+
+    Examples
+    --------
+    >>> gas = SPH1D.sod_shock_tube(n_left=200)
+    >>> gas.run(0.05)
+    >>> bool(abs(gas.total_energy() - gas.energy_history[0]) < 1e-3 * gas.energy_history[0])
+    True
+    """
+
+    def __init__(self, x, v, m, u, gamma=1.4, eta=1.2, alpha=1.0, beta=2.0, fixed=None):
+        self.x = np.asarray(x, dtype=np.float64).copy()
+        self.v = np.asarray(v, dtype=np.float64).copy()
+        self.m = np.broadcast_to(np.asarray(m, dtype=np.float64), self.x.shape).copy()
+        self.u = np.asarray(u, dtype=np.float64).copy()
+        self.gamma = float(gamma)
+        self.eta = float(eta)
+        self.alpha = float(alpha)
+        self.beta = float(beta)
+        self.fixed = np.zeros(self.x.size, dtype=bool) if fixed is None else np.asarray(fixed, dtype=bool)
+        self.t = 0.0
+        spacing = np.gradient(np.sort(self.x))[np.argsort(np.argsort(self.x))]
+        self.h = self.eta * np.abs(spacing)
+        self._update_density()
+        self.energy_history = [self.total_energy()]
+
+    @classmethod
+    def sod_shock_tube(cls, n_left=400, gamma=1.4, left=(1.0, 1.0), right=(0.125, 0.1), length=1.0, **kwargs):
+        """Equal-mass particles for Sod's shock tube, with the diaphragm at :math:`x = 0`.
+
+        The left half :math:`-L < x < 0` has density and pressure ``left``,
+        the right half ``right``; both are at rest. Particle spacing scales
+        inversely with density, and the outermost few particles on each
+        side are held fixed as walls.
+
+        Parameters
+        ----------
+        n_left : int, default 400
+            Particles in the left half.
+        gamma : float, default 1.4
+        left, right : tuple of float
+            ``(rho, P)`` of each side.
+        length : float, default 1.0
+            Half-length :math:`L` of the tube.
+        **kwargs
+            Passed to the constructor.
+
+        Returns
+        -------
+        SPH1D
+        """
+        (rL, pL), (rR, pR) = left, right
+        dxL = length / n_left
+        m = rL * dxL
+        dxR = m / rR
+        xL = -length + dxL * (np.arange(n_left) + 0.5)
+        xR = dxR * (np.arange(int(round(length / dxR))) + 0.5)
+        x = np.concatenate((xL, xR))
+        u = np.concatenate((np.full(xL.size, pL / ((gamma - 1) * rL)), np.full(xR.size, pR / ((gamma - 1) * rR))))
+        fixed = np.zeros(x.size, dtype=bool)
+        fixed[:4] = fixed[-4:] = True
+        return cls(x, np.zeros_like(x), m, u, gamma=gamma, fixed=fixed, **kwargs)
+
+    def _update_density(self):
+        order = np.argsort(self.x)
+        for _ in range(2):
+            self.rho = _density(self.x, self.m, self.h, order)
+            self.h = self.eta * self.m / self.rho
+        self.rho = _density(self.x, self.m, self.h, order)
+        return order
+
+    @property
+    def pressure(self) -> NDArray[np.float64]:
+        """Pressure :math:`P = (\\gamma - 1)\\rho u`."""
+        return (self.gamma - 1.0) * self.rho * self.u
+
+    def total_energy(self) -> float:
+        """Total kinetic plus internal energy :math:`\\sum_i m_i(v_i^2/2 + u_i)`."""
+        return float(np.sum(self.m * (0.5 * self.v**2 + self.u)))
+
+    def _derivatives(self):
+        order = self._update_density()
+        acc, dudt, c = _forces(self.x, self.v, self.m, self.h, self.rho, self.u, self.gamma, self.alpha, self.beta, order)
+        acc[self.fixed] = 0.0
+        dudt[self.fixed] = 0.0
+        return acc, dudt, c
+
+    def run(self, t_end: float, cfl: float = 0.3) -> None:
+        """Advance to ``self.t + t_end`` with kick-drift-kick leapfrog.
+
+        Parameters
+        ----------
+        t_end : float
+            Time to advance by.
+        cfl : float, default 0.3
+            Courant factor in :math:`\\Delta t = C\\min_i h_i/(c_i + |v_i|)`.
+        """
+        t_stop = self.t + t_end
+        acc, dudt, c = self._derivatives()
+        while self.t < t_stop - 1e-14:
+            dt = min(cfl * np.min(self.h / (c + np.abs(self.v) + 1e-12)), t_stop - self.t)
+            v_half = self.v + 0.5 * dt * acc
+            u_half = self.u + 0.5 * dt * dudt
+            self.x = self.x + dt * np.where(self.fixed, 0.0, v_half)
+            self.v, self.u = v_half, u_half
+            acc, dudt, c = self._derivatives()
+            self.v = self.v + 0.5 * dt * acc
+            self.u = self.u + 0.5 * dt * dudt
+            self.t += dt
+        self.energy_history.append(self.total_energy())

{physicskit-0.3.0 → physicskit-0.4.0}/physicskit/astro/stellar_structure.py

@@ -75,8 +75,8 @@ def lane_emden(n, xi_max=1000.0, n_points=2000):
     def surface_event(xi, y):
         return y[0]
 
-    surface_event.terminal = True
-    surface_event.direction = -1
+    surface_event.terminal = True  # type: ignore[attr-defined]  # solve_ivp event attribute
+    surface_event.direction = -1  # type: ignore[attr-defined]
 
     sol = solve_ivp(
         rhs,