warpSPHBoundaries 0.1.0__tar.gz

warpsphboundaries-0.1.0/LICENSE

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

warpsphboundaries-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+prune tests
+prune docs
+prune .tmp

warpsphboundaries-0.1.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: warpSPHBoundaries
+Version: 0.1.0
+Summary: Exact SPH boundary integrals via divergence-theorem edge reductions (2D), scene layer and delta+-SPH / DFSPH solvers on analytic boundaries
+License: MIT
+Project-URL: Repository, https://github.com/wi-re/warpSPHBoundaries
+Project-URL: Issues, https://github.com/wi-re/warpSPHBoundaries/issues
+Keywords: sph,smoothed-particle-hydrodynamics,boundary-conditions,warp,pytorch,analytic-boundaries
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: mpmath
+Requires-Dist: torch
+Requires-Dist: warp-lang
+Requires-Dist: warpSPHCore>=0.6.0
+Provides-Extra: solvers
+Requires-Dist: warpSPH>=0.6.0; extra == "solvers"
+Requires-Dist: warpSPHCore>=0.6.0; extra == "solvers"
+Provides-Extra: scripts
+Requires-Dist: matplotlib; extra == "scripts"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# curvatureBoundaries
+
+Curvature-aware closed forms for the semi-analytic SPH boundary integral of
+Winchenbach, Akhunov & Kolb (2020),
+
+```
+lambda(x) = Int_{D_B(x)} W(|x-x'|, h) dx',     W(r,h) = C_n/h^n W_hat(r/h)
+```
+
+extended beyond the paper's 3-D planar cubic-spline result to:
+
+* **2-D planar** boundaries for all four kernels — new arccos/ln closed forms
+  (`maple/01_planar.mpl`, §3 of `docs/derivation.md`);
+* **3-D planar** Wendland kernels w2/w4/w6 — single polynomials of degree 2n
+  via the monomial basis `F(n,p,x)`;
+* **curved boundaries**: solid sphere for the Wendland kernels — both
+  branches (`2R+d >= 1` and `2R+d < 1`) are rational `N(R,d)/(R+d)`, with
+  exact planar limit `R -> infinity`.
+
+Kernels and conventions follow warpSPHCore
+(`src/warpSPHCore/kernels/`, `scripts/kernels/kernel_specs.yaml`):
+`q = r/h` with `h` the support radius.
+
+## Layout
+
+```
+maple/00_setup.mpl          kernel table, normalization, F(n,p,x) basis checks
+maple/01_planar.mpl         2-D + 3-D planar, all kernels
+maple/03_sphere.mpl         solid sphere (Wendland w2/w4/w6)
+maple/run_all.sh            regenerate src/warpSPHBoundaries/data/symbolic/ (needs Maple 2026)
+src/warpSPHBoundaries/curvbound/              PLAN track: kernel table, closed-form evaluators, oracles (curvature-aware planar / sphere integrals)
+src/warpSPHBoundaries/edge/         HANDOFF track: exact 2D edge-reduction integrals (mpmath -> numpy -> torch -> Warp), FEM weights, tiers 3 / 4
+src/warpSPHBoundaries/scene/        bodies and representations, boundary operations, wall operators of the delta+-SPH solver, the boundary provider (`AnalyticBoundary`, `scene/provider.py`)
+src/warpSPHBoundaries/data/tables/  pre-tabulated tier-3 kernel tables (package data)
+src/warpSPHBoundaries/sim/          DFSPH2D and DeltaSPH2D solvers, cases, validation runners
+scripts/                    command-line runners (regression harness, profiler, validation, videos), scripts/studies, scripts/bench
+tests/                      pytest suite: tests/{edge,scene,sim,curvbound} (940 tests)
+notebooks/demo.ipynb        executed demo: geometry, curves, validation
+notebooks/examples/         nine example flows (Taylor-Green ... flow past a cylinder) on the delta+ and the DFSPH solver, against reference solutions
+docs/derivation.md          full mathematical write-up
+PLAN.md                     project status & roadmap
+src/warpSPHBoundaries/data/symbolic/  Maple exports (committed, shipped with the package; consumed by warpSPHBoundaries.curvbound)
+results/figures/            notebook figures (generated, git-ignored)
+```
+
+## Package layering
+
+`edge` <- `scene` <- `sim`: the edge machinery and the scene layer (`pip install .`, needs `warpSPHCore` only) are the boundary library `warpSPHBoundaries` (renamed from `edgebound` on 2026-10-06); `sim` (the reference
+solvers) additionally needs `warpSPH`.  A scheme consumes the analytic bodies through `warpSPHBoundaries.scene.AnalyticBoundary` (the `BoundaryProvider` protocol: integrals at the fluid particles, signed distance,
+body kinematics); see docs/audit-warpsph-boundary-hooks.md.  The layering is enforced by `tests/test_package_layering.py`.
+
+## Quick start
+
+```bash
+# 1. (re)generate the symbolic results — needs Maple 2026
+maple/run_all.sh                       # MAPLE=/path/to/maple to override
+
+# 2. install (editable) and run the validation suite; the solvers need warpSPH / warpSPHCore in the same env
+pip install -e . --no-deps          # or: pip install -e .[test]
+python -m pytest tests/ -q -n 4     # ~3 min with pytest-xdist; GPU tests use cuda:0
+
+# 3. run the demo notebook (jupyter + matplotlib)
+python -m jupyter nbconvert --to notebook --execute --inplace \
+    notebooks/demo.ipynb --ExecutePreprocessor.kernel_name=python3
+```
+
+Python API sketch:
+
+```python
+from fractions import Fraction
+from curvbound import planar2d, planar3d, sphere
+
+planar3d("w4", Fraction(1, 3))          # exact rational (polynomial in d)
+planar2d("w4", "0.3")                   # mpf (arccos/ln closed form)
+sphere("w4", Fraction(4, 10), Fraction(1, 5))   # solid ball R=0.4, d=0.2
+```
+
+## Validation
+
+Every closed form is validated three ways (details in `docs/derivation.md`
+§5): exact symbolic identities in Maple, 50-digit Maple quadrature, and
+independent 40-digit mpmath oracles in `src/warpSPHBoundaries/curvbound/oracle.py`
+(including a true 2-D Cartesian quadrature and the h-scaling identity).
+Worst observed error: ~1e-39.
+
+## Status
+
+3-D planar (cubic + Wendland) and 3-D spherical (Wendland) were completed in
+the original plan; the 2-D derivations, the promotion of the toy harnesses
+to this repository layout, and the demo notebook are done (see `PLAN.md`
+§18–§18c). Next: cylinder boundary, 2-D circle boundary, inside-solid
+(`d < 0`) cases, gradient terms.

warpsphboundaries-0.1.0/README.md

@@ -0,0 +1,92 @@
+# curvatureBoundaries
+
+Curvature-aware closed forms for the semi-analytic SPH boundary integral of
+Winchenbach, Akhunov & Kolb (2020),
+
+```
+lambda(x) = Int_{D_B(x)} W(|x-x'|, h) dx',     W(r,h) = C_n/h^n W_hat(r/h)
+```
+
+extended beyond the paper's 3-D planar cubic-spline result to:
+
+* **2-D planar** boundaries for all four kernels — new arccos/ln closed forms
+  (`maple/01_planar.mpl`, §3 of `docs/derivation.md`);
+* **3-D planar** Wendland kernels w2/w4/w6 — single polynomials of degree 2n
+  via the monomial basis `F(n,p,x)`;
+* **curved boundaries**: solid sphere for the Wendland kernels — both
+  branches (`2R+d >= 1` and `2R+d < 1`) are rational `N(R,d)/(R+d)`, with
+  exact planar limit `R -> infinity`.
+
+Kernels and conventions follow warpSPHCore
+(`src/warpSPHCore/kernels/`, `scripts/kernels/kernel_specs.yaml`):
+`q = r/h` with `h` the support radius.
+
+## Layout
+
+```
+maple/00_setup.mpl          kernel table, normalization, F(n,p,x) basis checks
+maple/01_planar.mpl         2-D + 3-D planar, all kernels
+maple/03_sphere.mpl         solid sphere (Wendland w2/w4/w6)
+maple/run_all.sh            regenerate src/warpSPHBoundaries/data/symbolic/ (needs Maple 2026)
+src/warpSPHBoundaries/curvbound/              PLAN track: kernel table, closed-form evaluators, oracles (curvature-aware planar / sphere integrals)
+src/warpSPHBoundaries/edge/         HANDOFF track: exact 2D edge-reduction integrals (mpmath -> numpy -> torch -> Warp), FEM weights, tiers 3 / 4
+src/warpSPHBoundaries/scene/        bodies and representations, boundary operations, wall operators of the delta+-SPH solver, the boundary provider (`AnalyticBoundary`, `scene/provider.py`)
+src/warpSPHBoundaries/data/tables/  pre-tabulated tier-3 kernel tables (package data)
+src/warpSPHBoundaries/sim/          DFSPH2D and DeltaSPH2D solvers, cases, validation runners
+scripts/                    command-line runners (regression harness, profiler, validation, videos), scripts/studies, scripts/bench
+tests/                      pytest suite: tests/{edge,scene,sim,curvbound} (940 tests)
+notebooks/demo.ipynb        executed demo: geometry, curves, validation
+notebooks/examples/         nine example flows (Taylor-Green ... flow past a cylinder) on the delta+ and the DFSPH solver, against reference solutions
+docs/derivation.md          full mathematical write-up
+PLAN.md                     project status & roadmap
+src/warpSPHBoundaries/data/symbolic/  Maple exports (committed, shipped with the package; consumed by warpSPHBoundaries.curvbound)
+results/figures/            notebook figures (generated, git-ignored)
+```
+
+## Package layering
+
+`edge` <- `scene` <- `sim`: the edge machinery and the scene layer (`pip install .`, needs `warpSPHCore` only) are the boundary library `warpSPHBoundaries` (renamed from `edgebound` on 2026-10-06); `sim` (the reference
+solvers) additionally needs `warpSPH`.  A scheme consumes the analytic bodies through `warpSPHBoundaries.scene.AnalyticBoundary` (the `BoundaryProvider` protocol: integrals at the fluid particles, signed distance,
+body kinematics); see docs/audit-warpsph-boundary-hooks.md.  The layering is enforced by `tests/test_package_layering.py`.
+
+## Quick start
+
+```bash
+# 1. (re)generate the symbolic results — needs Maple 2026
+maple/run_all.sh                       # MAPLE=/path/to/maple to override
+
+# 2. install (editable) and run the validation suite; the solvers need warpSPH / warpSPHCore in the same env
+pip install -e . --no-deps          # or: pip install -e .[test]
+python -m pytest tests/ -q -n 4     # ~3 min with pytest-xdist; GPU tests use cuda:0
+
+# 3. run the demo notebook (jupyter + matplotlib)
+python -m jupyter nbconvert --to notebook --execute --inplace \
+    notebooks/demo.ipynb --ExecutePreprocessor.kernel_name=python3
+```
+
+Python API sketch:
+
+```python
+from fractions import Fraction
+from curvbound import planar2d, planar3d, sphere
+
+planar3d("w4", Fraction(1, 3))          # exact rational (polynomial in d)
+planar2d("w4", "0.3")                   # mpf (arccos/ln closed form)
+sphere("w4", Fraction(4, 10), Fraction(1, 5))   # solid ball R=0.4, d=0.2
+```
+
+## Validation
+
+Every closed form is validated three ways (details in `docs/derivation.md`
+§5): exact symbolic identities in Maple, 50-digit Maple quadrature, and
+independent 40-digit mpmath oracles in `src/warpSPHBoundaries/curvbound/oracle.py`
+(including a true 2-D Cartesian quadrature and the h-scaling identity).
+Worst observed error: ~1e-39.
+
+## Status
+
+3-D planar (cubic + Wendland) and 3-D spherical (Wendland) were completed in
+the original plan; the 2-D derivations, the promotion of the toy harnesses
+to this repository layout, and the demo notebook are done (see `PLAN.md`
+§18–§18c). Next: cylinder boundary, 2-D circle boundary, inside-solid
+(`d < 0`) cases, gradient terms.

warpsphboundaries-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "warpSPHBoundaries"
+version = "0.1.0"
+description = "Exact SPH boundary integrals via divergence-theorem edge reductions (2D), scene layer and delta+-SPH / DFSPH solvers on analytic boundaries"
+readme = { file = "README.md", content-type = "text/markdown" }
+requires-python = ">=3.10"
+license = { text = "MIT" }
+keywords = ["sph", "smoothed-particle-hydrodynamics", "boundary-conditions", "warp", "pytorch", "analytic-boundaries"]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Physics",
+]
+dependencies = ["numpy", "scipy", "mpmath", "torch", "warp-lang", "warpSPHCore>=0.6.0"]
+
+[project.optional-dependencies]
+# the solvers (`sim/`: delta+-SPH and DFSPH on analytic boundaries) run on warpSPH; warpSPH in turn uses this package for `--wallRepresentation analytic` (its `boundaries` extra)
+solvers = ["warpSPH>=0.6.0", "warpSPHCore>=0.6.0"]
+scripts = ["matplotlib"]
+test = ["pytest"]
+
+[project.urls]
+Repository = "https://github.com/wi-re/warpSPHBoundaries"
+Issues = "https://github.com/wi-re/warpSPHBoundaries/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["warpSPHBoundaries*"]
+
+[tool.setuptools.package-data]
+warpSPHBoundaries = ["data/tables/*.npz", "data/symbolic/*.txt"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = ["slow: builds / installs / long runs; deselect with -m \"not slow\""]

warpsphboundaries-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

warpsphboundaries-0.1.0/src/warpSPHBoundaries/__init__.py

@@ -0,0 +1,18 @@
+"""warpSPHBoundaries -- exact 2D SPH boundary integrals via divergence-theorem edge reductions.
+
+Sub-packages: `curvbound` (closed forms and quadrature oracles of the PLAN track), `edge` (the edge machinery), `scene` (bodies, boundary operations, wall operators), `sim` (DFSPH / delta+-SPH solvers); `paths`.
+Derivations: docs/derivations/*.md.  The 2D edge reductions (`edge`) and the PLAN-track closed forms (`curvbound`) are separate tracks that share the kernels.
+"""
+__version__ = "0.1.0"          # keep equal to pyproject.toml (scripts/publish_pypi.sh checks it)
+
+from .edge.precision import ensure_default as _ensure_default      # warpSPHCore precision: warpSPHBoundaries defaults to float64 unless configured (edge/precision.py); before any warpSPHCore import
+_ensure_default()
+
+from .edge.core import gradient, moment, moment_gradient, value
+from .edge.geometry import prepare
+from .edge.kernels import KERNELS, disk_moment, kernel
+from .edge.oracle import polar_disk_gradient, polar_disk_moment, polar_disk_value, polar_gradient, polar_moment, polar_value
+
+__all__ = ["value", "gradient", "moment", "moment_gradient", "prepare",
+           "KERNELS", "kernel", "disk_moment",
+           "polar_value", "polar_gradient", "polar_moment", "polar_disk_value", "polar_disk_moment", "polar_disk_gradient"]

warpsphboundaries-0.1.0/src/warpSPHBoundaries/curvbound/__init__.py

@@ -0,0 +1,24 @@
+"""warpSPHBoundaries.curvbound — curvature-aware SPH boundary integrals (the PLAN track; formerly the top-level package `curvbound`).
+
+Closed forms (Maple-generated, data/symbolic/) plus independent
+high-precision quadrature oracles, for the semi-analytic SPH boundary
+handling of Winchenbach, Akhunov, Kolb (2020) extended to Wendland kernels
+and to curved (solid-sphere) boundaries.
+"""
+from .kernels import KERNELS, Kernel, kernel
+from .oracle import (
+    physical_planar3d,
+    quad_planar2d,
+    quad_planar2d_cartesian,
+    quad_planar3d,
+    quad_sphere,
+)
+from .symbolic import PLANAR_EXPORT, SPHERE_EXPORT, planar2d, planar3d, sphere
+
+__all__ = [
+    "KERNELS", "Kernel", "kernel",
+    "PLANAR_EXPORT", "SPHERE_EXPORT",
+    "planar2d", "planar3d", "sphere",
+    "quad_planar2d", "quad_planar2d_cartesian", "quad_planar3d",
+    "quad_sphere", "physical_planar3d",
+]

warpsphboundaries-0.1.0/src/warpSPHBoundaries/curvbound/kernels.py

@@ -0,0 +1,57 @@
+"""Kernel table for the boundary-integral derivations.
+
+Conventions match warpSPHCore (src/warpSPHCore/kernels/kernel.py and
+scripts/kernels/kernel_specs.yaml):
+
+    W(r, h) = C_n / h^n * W_hat(q),   q = r / h,   h = support radius,
+
+with W_hat compactly supported on [0, 1].  The kernel shapes are identical
+in 2D and 3D; only C_n differs (transcribed from kernel_specs.yaml):
+
+    cubic : W_hat = (1-q)^3 - 4*(1/2-q)_+^3   C2 = 80/(7*pi)  C3 = 16/pi
+    w2    : (1-q)^4  (1+4q)                   C2 = 7/pi       C3 = 21/(2*pi)
+    w4    : (1-q)^6  (1+6q+35/3*q^2)          C2 = 9/pi       C3 = 495/(32*pi)
+    w6    : (1-q)^8  (1+8q+25q^2+32q^3)       C2 = 78/(7*pi)  C3 = 1365/(64*pi)
+"""
+from dataclasses import dataclass
+from fractions import Fraction
+
+
+@dataclass(frozen=True)
+class Kernel:
+    name: str
+    kind: str            # "cubic" (knot at q=1/2) or "wendland" (single poly)
+    c2_pi: Fraction      # C2 = c2_pi / pi
+    c3_pi: Fraction      # C3 = c3_pi / pi
+    n: int = 0           # Wendland: power of (1-q)
+    poly: tuple = ()     # Wendland: ((power, coeff), ...) of P(q), c in Q
+
+    def w_hat(self, q: Fraction) -> Fraction:
+        """Exact kernel shape at a rational q (symbolic checks)."""
+        if self.kind == "cubic":
+            if q <= Fraction(1, 2):
+                return (1 - q) ** 3 - 4 * (Fraction(1, 2) - q) ** 3
+            return (1 - q) ** 3
+        v = Fraction(0)
+        for p, c in self.poly:
+            v += c * q ** p
+        return (1 - q) ** self.n * v
+
+
+KERNELS = {
+    "cubic": Kernel("cubic", "cubic", Fraction(80, 7), Fraction(16)),
+    "w2": Kernel("w2", "wendland", Fraction(7), Fraction(21, 2), 4,
+                 ((0, Fraction(1)), (1, Fraction(4)))),
+    "w4": Kernel("w4", "wendland", Fraction(9), Fraction(495, 32), 6,
+                 ((0, Fraction(1)), (1, Fraction(6)), (2, Fraction(35, 3)))),
+    "w6": Kernel("w6", "wendland", Fraction(78, 7), Fraction(1365, 64), 8,
+                 ((0, Fraction(1)), (1, Fraction(8)),
+                  (2, Fraction(25)), (3, Fraction(32)))),
+}
+
+
+def kernel(name: str) -> Kernel:
+    try:
+        return KERNELS[name]
+    except KeyError:
+        raise KeyError(f"unknown kernel {name!r}; expected one of {sorted(KERNELS)}")

warpsphboundaries-0.1.0/src/warpSPHBoundaries/curvbound/oracle.py

@@ -0,0 +1,133 @@
+"""Independent high-precision quadrature oracles.
+
+These re-derive lambda directly from the defining integrals (no shared code
+with symbolic.py) so they can validate the exported closed forms:
+
+  3-D planar : lambda = Int_d^1 C3 W(q) 2 pi q (q-d) dq
+  2-D planar : lambda = Int_d^1 C2 W(q) 2 q arccos(d/q) dq
+  sphere     : lambda = Int_d^{qmax} C3 W(q) pi q/D (R^2-D^2+2Dq-q^2) dq,
+               D = R+d, qmax = min(1, 2R+d)
+  2-D Cartesian: true double integral over the support disk cut by the
+               chord (no 1-D reduction) -- the most independent check.
+
+Unit support h=1, particle outside the boundary, d in [0,1].
+"""
+from fractions import Fraction
+
+import mpmath as mp
+
+from .kernels import kernel
+
+
+def _to_mpf(x) -> mp.mpf:
+    """int / Fraction / str / mpf -> mp.mpf (this mpmath build rejects Fraction)."""
+    if isinstance(x, Fraction):
+        return mp.mpf(x.numerator) / mp.mpf(x.denominator)
+    return mp.mpf(x)
+
+
+def _c2(kd) -> mp.mpf:
+    return (mp.mpf(kd.c2_pi.numerator) / mp.mpf(kd.c2_pi.denominator)) / mp.pi
+
+
+def _c3(kd) -> mp.mpf:
+    return (mp.mpf(kd.c3_pi.numerator) / mp.mpf(kd.c3_pi.denominator)) / mp.pi
+
+
+def _w_hat_mp(kd, q: mp.mpf) -> mp.mpf:
+    if kd.kind == "cubic":
+        if q <= mp.mpf(1) / 2:
+            return (1 - q) ** 3 - 4 * (mp.mpf(1) / 2 - q) ** 3
+        return (1 - q) ** 3
+    v = mp.mpf(0)
+    for p, c in kd.poly:
+        v += (mp.mpf(c.numerator) / mp.mpf(c.denominator)) * q ** p
+    return (1 - q) ** kd.n * v
+
+
+def quad_planar3d(kernel_name: str, d, dps: int = 40) -> mp.mpf:
+    kd = kernel(kernel_name)
+    c3 = _c3(kd)
+    d = _to_mpf(d)
+    f = lambda q: c3 * _w_hat_mp(kd, q) * 2 * mp.pi * q * (q - d)
+    if kd.kind == "cubic" and d < mp.mpf(1) / 2:
+        return mp.quad(f, [d, mp.mpf(1) / 2, 1])
+    return mp.quad(f, [d, 1])
+
+
+def quad_planar2d(kernel_name: str, d, dps: int = 40) -> mp.mpf:
+    kd = kernel(kernel_name)
+    c2 = _c2(kd)
+    d = _to_mpf(d)
+    f = lambda q: c2 * _w_hat_mp(kd, q) * 2 * q * mp.acos(d / q)
+    if kd.kind == "cubic" and d < mp.mpf(1) / 2:
+        return mp.quad(f, [d, mp.mpf(1) / 2, 1])
+    return mp.quad(f, [d, 1])
+
+
+def quad_sphere(kernel_name: str, R, d, dps: int = 40) -> mp.mpf:
+    kd = kernel(kernel_name)
+    c3 = _c3(kd)
+    R = _to_mpf(R)
+    d = _to_mpf(d)
+    D = R + d
+    qmax = min(mp.mpf(1), 2 * R + d)
+    f = (lambda q: c3 * _w_hat_mp(kd, q)
+         * mp.pi * q / D * (R ** 2 - D ** 2 + 2 * D * q - q ** 2))
+    return mp.quad(f, [d, qmax])
+
+
+def quad_planar2d_cartesian(kernel_name: str, d, dps: int = 30) -> mp.mpf:
+    """True 2-D Cartesian quadrature (no 1-D shell reduction).
+
+    Particle at the origin, boundary line y = d, boundary side y > d:
+        lambda = Int_{x} Int_{y=d}^{sqrt(1-x^2)} C2 W_hat(sqrt(x^2+y^2)) dy dx
+    over |x| <= sqrt(1-d^2).  For the cubic spline the knot circle r = 1/2 is
+    added as a breakpoint wherever it crosses the inner interval.
+    """
+    kd = kernel(kernel_name)
+    c2 = _c2(kd)
+    d = _to_mpf(d)
+    xmax = mp.sqrt(1 - d ** 2)
+
+    def inner(x: mp.mpf) -> mp.mpf:
+        ytop = mp.sqrt(1 - x ** 2)
+        pts = [d]
+        if kd.kind == "cubic" and x ** 2 < mp.mpf(1) / 4:
+            yk = mp.sqrt(mp.mpf(1) / 4 - x ** 2)
+            if d < yk < ytop:
+                pts.append(yk)
+        pts.append(ytop)
+        g = lambda y: c2 * _w_hat_mp(kd, mp.sqrt(x ** 2 + y ** 2))
+        return mp.quad(g, pts)
+
+    # dense outer breakpoints: inner(x) ~ sqrt(xmax - |x|) at the endpoints
+    # (the chord degenerates), which a 3-way split resolves only to ~3e-15
+    # for the cubic spline kernel (observed)
+    n = 16
+    return mp.quad(inner, [-xmax + 2 * xmax * mp.mpf(i) / n for i in range(n + 1)])
+
+
+def physical_planar3d(kernel_name: str, d, h, dps: int = 30) -> mp.mpf:
+    """The PHYSICAL 3-D integral with explicit support radius h:
+
+        Int_{r=d}^{h} (C3/h^3) W_hat(r/h) 2 pi r (r-d) dr
+
+    which by the substitution r = h q must equal lambda_3(d/h).  Used for the
+    h-scaling test.
+    """
+    kd = kernel(kernel_name)
+    c3 = _c3(kd)
+    d = _to_mpf(d)
+    h = _to_mpf(h)
+    f = (lambda r: (c3 / h ** 3) * _w_hat_mp(kd, r / h)
+         * 2 * mp.pi * r * (r - d))
+    if kd.kind == "cubic" and d < h / 2:
+        return mp.quad(f, [d, h / 2, h])
+    return mp.quad(f, [d, h])
+
+
+__all__ = [
+    "quad_planar3d", "quad_planar2d", "quad_sphere",
+    "quad_planar2d_cartesian", "physical_planar3d",
+]