physverify 0.1.0__py3-none-any.whl

physverify/problems/projectile.py

@@ -0,0 +1,240 @@
+"""Projectile with vacuum, linear and quadratic drag. State: [x, y, vx, vy].
+
+The reference operator follows the equations in the projectile-simulation
+README, written separately from the solver below. One parameter is taken from
+the code rather than the README: the linear drag coefficient b = 0.01 N s/m
+(the README says b = 6*pi*eta*r, which gives a much smaller value).
+"""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+
+from ..checks import Check
+from ..mms import ManufacturedODE
+from ..order import check_order
+from ..studies import close_result, ode_checks, smoke_check
+from ._common import STEPPER_BUGS, BugInfo, families, make_integrate, rk4_with_bugs
+
+NAME = "projectile"
+PARAMS = dict(m=0.45, r=0.11, Cd=0.47, rho=1.225, g=9.81, b=0.01)
+MODES = ("vacuum", "linear", "quadratic")
+
+BUGS = {
+    "gravity_sign": BugInfo(
+        "gravity accelerates the projectile upward",
+        families("mms", "reference", "invariant", "limit", "patch"),
+        "error does not shrink; energy not conserved; range wrong or never lands",
+    ),
+    "linear_drag_missing_mass": BugInfo(
+        "linear drag coefficient is b instead of b/m",
+        families("mms", "reference", "patch"),
+        "error plateaus in linear-drag mode only",
+    ),
+    "quad_drag_factor_half": BugInfo(
+        "quadratic drag is missing the factor 1/2",
+        families("mms", "reference", "patch"),
+        "error plateaus in quadratic-drag mode only",
+    ),
+    "quad_drag_speed_from_vx": BugInfo(
+        "speed in the quadratic drag uses |vx| instead of |v|",
+        families("mms", "reference", "patch"),
+        "error plateaus in quadratic-drag mode wherever vy is not zero",
+    ),
+    "quad_drag_abs_vx": BugInfo(
+        "x drag uses |vx| instead of vx, which is wrong only when the projectile moves backwards",
+        families("mms", "patch"),
+        "error plateaus only on runs where vx < 0; a forward launch never shows it",
+    ),
+    "landing_no_interp": BugInfo(
+        "range is read from the last step before landing, with no interpolation",
+        families("limit"),
+        "range converges at order 1, not 2; the integrator itself is fine",
+    ),
+    "angle_not_converted": BugInfo(
+        "launch angle in degrees is passed to sin/cos unconverted",
+        families("limit"),
+        "range wrong by a fixed amount; only the launch set-up is affected",
+    ),
+    "euler_extra_step": BugInfo(
+        "the Euler integrator takes one step more than asked for",
+        families("patch"),
+        "an O(h) error, the same order as Euler's own, so every order study passes",
+    ),
+    **STEPPER_BUGS,
+}
+
+
+def rhs_reference(mode: str, p=PARAMS):
+    m, r, Cd, rho, g, b = p["m"], p["r"], p["Cd"], p["rho"], p["g"], p["b"]
+    area = math.pi * r * r
+
+    def f(t, z):
+        vx, vy = z[2], z[3]
+        ax, ay = 0.0, -g
+        if mode == "linear":
+            ax -= (b / m) * vx
+            ay -= (b / m) * vy
+        elif mode == "quadratic":
+            c = 0.5 * rho * Cd * area / m
+            speed = math.hypot(vx, vy)
+            ax -= c * speed * vx
+            ay -= c * speed * vy
+        return np.array([vx, vy, ax, ay])
+
+    return f
+
+
+def rhs_seeded(mode: str, bugs, p=PARAMS):
+    m, r, Cd, rho, g, b = p["m"], p["r"], p["Cd"], p["rho"], p["g"], p["b"]
+    area = math.pi * r * r
+    k_lin = b if "linear_drag_missing_mass" in bugs else b / m
+    k_quad = (rho * Cd * area / m) if "quad_drag_factor_half" in bugs else 0.5 * rho * Cd * area / m
+    gravity = g if "gravity_sign" in bugs else -g
+
+    def f(t, z):
+        vx, vy = z[2], z[3]
+        ax, ay = 0.0, gravity
+        if mode == "linear":
+            ax -= k_lin * vx
+            ay -= k_lin * vy
+        elif mode == "quadratic":
+            speed = abs(vx) if "quad_drag_speed_from_vx" in bugs else math.hypot(vx, vy)
+            vx_used = abs(vx) if "quad_drag_abs_vx" in bugs else vx
+            ax -= k_quad * speed * vx_used
+            ay -= k_quad * speed * vy
+        return np.array([vx, vy, ax, ay])
+
+    return f
+
+
+def energy_vacuum(z, p=PARAMS):
+    return 0.5 * p["m"] * (z[2] ** 2 + z[3] ** 2) + p["m"] * p["g"] * z[1]
+
+
+def manufactured(mode: str) -> ManufacturedODE:
+    """x_m(t) = t lets a code with no time argument see t through x (see adapters).
+
+    vx_m changes sign near t = 0.8 so that code paths for a projectile moving
+    backwards are exercised. y_m is above ground until t = 1.5, so a code that
+    runs until landing stops soon after the measurement time t = 1. Slow
+    time dependence matters: through the x-as-time trick an error in x changes
+    the forcing, and a fast-varying vx_m amplified Euler's O(h) error until the
+    run blew up.
+    """
+
+    def u(t):
+        return np.array(
+            [
+                t,
+                7.5 * t - 5.0 * t * t,
+                1.0 - 1.4 * t + 0.3 * np.sin(t),
+                7.5 - 10.0 * t + np.sin(2.0 * t),
+            ]
+        )
+
+    return ManufacturedODE(u, rhs_reference(mode))
+
+
+MMS_T_END = 1.0
+NS_RK4 = (10, 20, 40, 80, 160)
+NS_EULER = (40, 80, 160, 320, 640)
+Y0_FREE = np.array([0.0, 0.0, 10.0, 12.0])  # moves forwards the whole time, lands after ~2.4 s
+# Linear patch solution. It starts at the origin and has x = t, as the ProjectileV2 adapter
+# needs; vx stays negative and vy changes over the run, so the drag terms are all exercised.
+PATCH = (np.array([0.0, 0.0, -1.0, 2.0]), np.array([1.0, 3.0, 0.5, -1.0]))
+SMOKE_N = 40  # a typical single-resolution test
+SMOKE_RTOL = 1e-3
+
+
+def range_seeded(v0, angle_deg, dt, bugs, mode="vacuum"):
+    """Horizontal range from a launch at the origin, integrated with RK4 until landing."""
+    rad = angle_deg if "angle_not_converted" in bugs else math.radians(angle_deg)
+    f = rhs_seeded(mode, bugs)
+    z = np.array([0.0, 0.0, v0 * math.cos(rad), v0 * math.sin(rad)])
+    t = 0.0
+    while t < 100.0:  # a launch that has not landed after 100 s is not a ballistic flight
+        z_new = rk4_with_bugs(f, t, z, dt, bugs)
+        t += dt
+        if z_new[1] < 0.0:
+            if "landing_no_interp" in bugs:
+                return z[0]
+            frac = z[1] / (z[1] - z_new[1])
+            return z[0] + frac * (z_new[0] - z[0])
+        z = z_new
+    raise RuntimeError("projectile never landed within 100 s")
+
+
+def range_vacuum_exact(v0, angle_deg, g=PARAMS["g"]):
+    return v0 * v0 * math.sin(2.0 * math.radians(angle_deg)) / g
+
+
+def range_dts(v0, angle_deg, counts=(10, 20, 40, 80, 160), g=PARAMS["g"]):
+    """Step sizes that put the landing in the middle of a step.
+
+    With the landing at a fixed phase inside a step the interpolation error is a
+    smooth function of dt. Otherwise it jumps around and an order fit is
+    meaningless.
+    """
+    flight_time = 2.0 * v0 * math.sin(math.radians(angle_deg)) / g
+    return [flight_time / (n + 0.5) for n in counts]
+
+
+def range_check(range_fn, v0=30.0, angle_deg=40.0, label="vacuum/rk4 range") -> Check:
+    """Vacuum range against v0^2 sin(2a)/g. Linear interpolation of the landing gives order 2."""
+
+    def run():
+        exact = range_vacuum_exact(v0, angle_deg)
+        dts = range_dts(v0, angle_deg)
+        errs = [abs(range_fn(v0, angle_deg, dt) - exact) for dt in dts]
+        return check_order(dts, errs, 2.0, floor=1e-12)
+
+    return Check("limit", label, run)
+
+
+def checks(bugs=frozenset()) -> list[Check]:
+    out: list[Check] = []
+    for mode in MODES:
+        for method, ns, order in (("rk4", NS_RK4, 4.0), ("euler", NS_EULER, 1.0)):
+            if method == "euler" and "euler_instead_of_rk4" in bugs:
+                continue  # the bug only replaces RK4
+            if method == "euler" and any(b in bugs for b in ("rk4_weights", "rk4_full_step_stage2")):
+                continue
+            integrate = make_integrate(rhs_seeded(mode, bugs), bugs, method)
+            trajectory = make_integrate(rhs_seeded(mode, bugs), bugs, method, trajectory=True) if method == "rk4" else None
+            out += ode_checks(
+                f"{mode}/{method}",
+                integrate,
+                rhs_ref=rhs_reference(mode),
+                mms=manufactured(mode),
+                y0_free=Y0_FREE,
+                t_end=MMS_T_END,
+                ns=ns,
+                order=order,
+                quantity=energy_vacuum if mode == "vacuum" else None,
+                patch=PATCH,
+                integrate_trajectory=trajectory,
+            )
+    out.append(range_check(lambda v0, a, dt: range_seeded(v0, a, dt, bugs)))
+    return out
+
+
+def smoke_checks(bugs=frozenset()) -> list[Check]:
+    """What plain unit tests would look like: one run per mode, one range, each within 0.1%."""
+    out = []
+    for mode in MODES:
+        for method in ("rk4", "euler"):
+            if method == "euler" and any(b in bugs for b in ("euler_instead_of_rk4", "rk4_weights", "rk4_full_step_stage2")):
+                continue
+            n = SMOKE_N if method == "rk4" else 16 * SMOKE_N  # Euler needs many more steps for 0.1%
+            integrate = make_integrate(rhs_seeded(mode, bugs), bugs, method)
+            out.append(smoke_check(f"{mode}/{method}", integrate, rhs_reference(mode), Y0_FREE, MMS_T_END, n, rtol=SMOKE_RTOL))
+
+    def run_range():
+        v0, angle = 30.0, 40.0
+        return close_result(range_seeded(v0, angle, 0.01, bugs), range_vacuum_exact(v0, angle), SMOKE_RTOL)
+
+    out.append(Check("smoke", "vacuum range, dt = 0.01", run_range))
+    return out

physverify/problems/sod.py

@@ -0,0 +1,291 @@
+"""1D Euler equations of gas dynamics: Sod's shock tube and a smooth density wave.
+
+The solver is a first-order finite-volume scheme with the Rusanov (local
+Lax-Friedrichs) flux, explicit Euler in time with CFL number 0.5, and copied
+(transmissive) boundary cells or periodic boundaries.
+
+Checks:
+
+reference  Sod's problem against the exact Riemann solution (Toro, ch. 4). With
+           shocks and a contact discontinuity a first-order scheme converges in
+           L1 at about order 1/2 to 1, so the expected order is 0.5 with a wide
+           band ([0.3, 1.0]).
+reference  a density wave carried at constant velocity and pressure, which is an
+           exact smooth solution: order 1 on a periodic domain.
+invariant  discrete conservation, at t = 0.05. Before any wave reaches the ends the fluxes
+           through the ends are known exactly (only the pressure term, p_L - p_R,
+           moves momentum), so the totals of mass, momentum and energy must match
+           to round-off. This is exact for any grid, like the patch checks.
+"""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+
+from ..checks import FAIL, PASS, Check, Result
+from ..order import check_exact, check_order
+from ._common import BugInfo, families
+
+NAME = "sod"
+GAMMA = 1.4
+CFL = 0.5
+T_END = 0.2
+LEFT = (1.0, 0.0, 1.0)  # density, velocity, pressure
+RIGHT = (0.125, 0.0, 0.1)
+X0 = 0.5
+SOD_CELLS = (100, 200, 400, 800, 1600)
+WAVE_CELLS = (50, 100, 200, 400, 800)
+WAVE_T_END = 0.25
+CONSERVATION_CELLS = (50, 100, 200)
+# A first-order explicit scheme moves information one cell per step, about 0.84 of the domain
+# by t = 0.2 at CFL 0.5, so numerical diffusion would reach the ends. By t = 0.05 it has
+# moved about 0.21 from the diaphragm, and the end cells are still exactly the initial states.
+CONSERVATION_T_END = 0.05
+
+BUGS = {
+    "gamma_wrong": BugInfo(
+        "the flux computes pressure with gamma = 5/3 while the initial data use 1.4",
+        families("reference"),
+        "wrong wave speeds and plateaus in Sod's problem; the smooth wave has uniform pressure, so it may not see it",
+    ),
+    "nonconservative_momentum": BugInfo(
+        "velocity is updated in primitive form (u_t + u u_x + p_x / rho = 0) instead of conserving momentum",
+        families("invariant"),
+        "momentum not conserved. Predicted before running: the Sod reference check too, through a wrong "
+        "shock speed. Observed: its order falls from 0.63 to 0.43, still inside the wide band a "
+        "discontinuous solution needs, so only the conservation check flags it",
+    ),
+    "wave_speed_without_sound": BugInfo(
+        "the Rusanov dissipation uses |u| instead of |u| + c",
+        families(),
+        "predicted before running: oscillations at the discontinuities, flagged by the Sod reference "
+        "check. Observed: the scheme stayed stable and was slightly more accurate (less dissipation), "
+        "and it is still in conservation form, so no check flags it. A blind spot: the bug is a "
+        "stability risk, not a wrong answer on this problem",
+    ),
+    "last_step_not_clipped": BugInfo(
+        "the last time step is not shortened to end exactly at t_end",
+        families("invariant"),
+        "an O(dt) time error, the same order as the scheme's own, so the order studies pass; "
+        "the conservation check uses the intended time and sees the extra momentum",
+    ),
+    "reflective_boundary": BugInfo(
+        "the boundary cells reflect (velocity negated) instead of letting waves out",
+        families(),
+        "nothing until a wave reaches a boundary, which does not happen before t_end: a documented "
+        "blind spot of every check here",
+    ),
+}
+
+
+# --- exact Riemann solver (Toro, Riemann Solvers and Numerical Methods for Fluid Dynamics, ch. 4) ---
+
+
+def _sound(rho, p, gamma=GAMMA):
+    return math.sqrt(gamma * p / rho)
+
+
+def _f_and_df(p, rho_k, p_k, gamma):
+    c_k = _sound(rho_k, p_k, gamma)
+    if p > p_k:  # shock
+        a = 2.0 / ((gamma + 1.0) * rho_k)
+        b = (gamma - 1.0) / (gamma + 1.0) * p_k
+        q = math.sqrt(a / (p + b))
+        return (p - p_k) * q, q * (1.0 - 0.5 * (p - p_k) / (p + b))
+    ratio = p / p_k  # rarefaction
+    f = 2.0 * c_k / (gamma - 1.0) * (ratio ** ((gamma - 1.0) / (2.0 * gamma)) - 1.0)
+    df = ratio ** (-(gamma + 1.0) / (2.0 * gamma)) / (rho_k * c_k)
+    return f, df
+
+
+def star_state(left=LEFT, right=RIGHT, gamma=GAMMA):
+    """Pressure and velocity between the two outer waves, by Newton iteration."""
+    rl, ul, pl = left
+    rr, ur, pr = right
+    p = max(1e-10, 0.5 * (pl + pr))
+    for _ in range(100):
+        fl, dfl = _f_and_df(p, rl, pl, gamma)
+        fr, dfr = _f_and_df(p, rr, pr, gamma)
+        step = (fl + fr + ur - ul) / (dfl + dfr)
+        p_new = max(1e-10, p - step)
+        if abs(p_new - p) <= 1e-14 * (p_new + p):
+            p = p_new
+            break
+        p = p_new
+    fl, _ = _f_and_df(p, rl, pl, gamma)
+    fr, _ = _f_and_df(p, rr, pr, gamma)
+    return p, 0.5 * (ul + ur) + 0.5 * (fr - fl)
+
+
+def sample(s, left=LEFT, right=RIGHT, gamma=GAMMA, star=None):
+    """(density, velocity, pressure) of the exact solution at x/t = s."""
+    rl, ul, pl = left
+    rr, ur, pr = right
+    cl, cr = _sound(rl, pl, gamma), _sound(rr, pr, gamma)
+    ps, us = star or star_state(left, right, gamma)
+    g6 = (gamma - 1.0) / (gamma + 1.0)
+    if s <= us:
+        if ps > pl:
+            shock = ul - cl * math.sqrt((gamma + 1.0) / (2.0 * gamma) * ps / pl + (gamma - 1.0) / (2.0 * gamma))
+            if s <= shock:
+                return rl, ul, pl
+            return rl * (ps / pl + g6) / (g6 * ps / pl + 1.0), us, ps
+        if s <= ul - cl:
+            return rl, ul, pl
+        c_star = cl * (ps / pl) ** ((gamma - 1.0) / (2.0 * gamma))
+        if s > us - c_star:
+            return rl * (ps / pl) ** (1.0 / gamma), us, ps
+        u = 2.0 / (gamma + 1.0) * (cl + 0.5 * (gamma - 1.0) * ul + s)
+        c = 2.0 / (gamma + 1.0) * (cl + 0.5 * (gamma - 1.0) * (ul - s))
+        return rl * (c / cl) ** (2.0 / (gamma - 1.0)), u, pl * (c / cl) ** (2.0 * gamma / (gamma - 1.0))
+    if ps > pr:
+        shock = ur + cr * math.sqrt((gamma + 1.0) / (2.0 * gamma) * ps / pr + (gamma - 1.0) / (2.0 * gamma))
+        if s >= shock:
+            return rr, ur, pr
+        return rr * (ps / pr + g6) / (g6 * ps / pr + 1.0), us, ps
+    if s >= ur + cr:
+        return rr, ur, pr
+    c_star = cr * (ps / pr) ** ((gamma - 1.0) / (2.0 * gamma))
+    if s <= us + c_star:
+        return rr * (ps / pr) ** (1.0 / gamma), us, ps
+    u = 2.0 / (gamma + 1.0) * (-cr + 0.5 * (gamma - 1.0) * ur + s)
+    c = 2.0 / (gamma + 1.0) * (cr - 0.5 * (gamma - 1.0) * (ur - s))
+    return rr * (c / cr) ** (2.0 / (gamma - 1.0)), u, pr * (c / cr) ** (2.0 * gamma / (gamma - 1.0))
+
+
+def exact_sod(x, t, left=LEFT, right=RIGHT, x0=X0, gamma=GAMMA):
+    star = star_state(left, right, gamma)
+    return np.array([sample((xi - x0) / t, left, right, gamma, star) for xi in x]).T
+
+
+# --- the solver under test ---
+
+
+def conserved(rho, u, p, gamma=GAMMA):
+    return np.array([rho, rho * u, p / (gamma - 1.0) + 0.5 * rho * u * u])
+
+
+def solve(n_cells, bugs, init, t_end, periodic=False):
+    """Advance cell averages on [0, 1] to t_end. Returns cell centres, final U, and the time reached."""
+    gamma_flux = 5.0 / 3.0 if "gamma_wrong" in bugs else GAMMA
+    dx = 1.0 / n_cells
+    x = (np.arange(n_cells) + 0.5) * dx
+    U = conserved(*init(x))
+    t = 0.0
+    with np.errstate(all="ignore"):
+        while t < t_end:
+            if periodic:
+                G = np.concatenate([U[:, -1:], U, U[:, :1]], axis=1)
+            else:
+                G = np.concatenate([U[:, :1], U, U[:, -1:]], axis=1)
+                if "reflective_boundary" in bugs:
+                    G[1, 0], G[1, -1] = -G[1, 0], -G[1, -1]
+            rho, mom, E = G
+            u = mom / rho
+            p = (gamma_flux - 1.0) * (E - 0.5 * rho * u * u)
+            c = np.sqrt(gamma_flux * np.abs(p) / rho)
+            speed = np.max(np.abs(u) + c)
+            if not np.isfinite(speed) or speed <= 0.0:
+                return x, np.full_like(U, np.nan), t
+            dt = CFL * dx / speed
+            if t + dt > t_end and "last_step_not_clipped" not in bugs:
+                dt = t_end - t
+            F = np.array([mom, mom * u + p, (E + p) * u])
+            wave = np.abs(u) if "wave_speed_without_sound" in bugs else np.abs(u) + c
+            a = np.maximum(wave[:-1], wave[1:])
+            flux = 0.5 * (F[:, :-1] + F[:, 1:]) - 0.5 * a * (G[:, 1:] - G[:, :-1])
+            U_new = U - dt / dx * (flux[:, 1:] - flux[:, :-1])
+            if "nonconservative_momentum" in bugs:
+                # u_t + u u_x + p_x / rho = 0, with the same Rusanov-type dissipation on u
+                ui = u[1:-1]
+                du = 0.5 * (u[2:] - u[:-2])
+                dp = 0.5 * (p[2:] - p[:-2])
+                u_new = ui - dt / dx * (ui * du + dp / rho[1:-1]) + 0.5 * dt / dx * a.max() * (u[2:] - 2 * ui + u[:-2])
+                U_new[1] = U_new[0] * u_new
+            U = U_new
+            t += dt
+    return x, U, t
+
+
+def primitive(U, gamma=GAMMA):
+    rho, mom, E = U
+    u = mom / rho
+    return rho, u, (gamma - 1.0) * (E - 0.5 * rho * u * u)
+
+
+def sod_init(x):
+    left = x < X0
+    rho = np.where(left, LEFT[0], RIGHT[0])
+    u = np.where(left, LEFT[1], RIGHT[1])
+    p = np.where(left, LEFT[2], RIGHT[2])
+    return rho, u, p
+
+
+def wave_init(x, t=0.0):
+    return 1.0 + 0.2 * np.sin(2.0 * math.pi * (x - t)), np.ones_like(x), np.ones_like(x)
+
+
+def _l1(a, b):
+    with np.errstate(all="ignore"):
+        return float(np.mean(np.abs(a - b)))
+
+
+def checks(bugs=frozenset()) -> list[Check]:
+    def run_sod():
+        hs, errs = [], []
+        for n in SOD_CELLS:
+            x, U, _ = solve(n, bugs, sod_init, T_END)
+            hs.append(1.0 / n)
+            errs.append(_l1(U[0], exact_sod(x, T_END)[0]))
+        return check_order(hs, errs, 0.5, tol_low=0.2, tol_high=0.5)
+
+    def run_wave():
+        hs, errs = [], []
+        for n in WAVE_CELLS:
+            x, U, _ = solve(n, bugs, wave_init, WAVE_T_END, periodic=True)
+            hs.append(1.0 / n)
+            errs.append(_l1(U[0], wave_init(x, WAVE_T_END)[0]))
+        return check_order(hs, errs, 1.0)
+
+    def run_conservation():
+        # Fluxes through the ends stay those of the initial states until a wave arrives:
+        # mass and energy fluxes are zero (u = 0), the momentum flux is the pressure.
+        expected_change = np.array([0.0, -(RIGHT[2] - LEFT[2]) * CONSERVATION_T_END, 0.0])
+        hs, errs = [], []
+        for n in CONSERVATION_CELLS:
+            x, U, _ = solve(n, bugs, sod_init, CONSERVATION_T_END)
+            total0 = conserved(*sod_init(x)).sum(axis=1) / n
+            with np.errstate(all="ignore"):
+                errs.append(float(np.max(np.abs(U.sum(axis=1) / n - total0 - expected_change))))
+            hs.append(1.0 / n)
+        return check_exact(hs, errs, floor=1e-11)
+
+    return [
+        Check("reference", "Sod shock tube, density L1", run_sod),
+        Check("reference", "smooth density wave, periodic", run_wave),
+        Check("invariant", "discrete conservation of mass, momentum, energy", run_conservation),
+    ]
+
+
+SMOKE_CELLS = 400
+SMOKE_RTOL = 0.05  # an L1 density error of a few percent is typical for a first-order scheme here
+
+
+def smoke_checks(bugs=frozenset()) -> list[Check]:
+    """A plain test: Sod's density on 400 cells within 5% (L1, relative to the mean density)."""
+
+    def run():
+        x, U, _ = solve(SMOKE_CELLS, bugs, sod_init, T_END)
+        exact = exact_sod(x, T_END)[0]
+        rel = _l1(U[0], exact) / float(np.mean(exact))
+        return _within(rel, SMOKE_RTOL)
+
+    return [Check("smoke", "Sod density on 400 cells", run)]
+
+
+def _within(rel, tol):
+    if np.isfinite(rel) and rel <= tol:
+        return Result(PASS, f"relative L1 error {rel:.3g} within {tol:g}")
+    return Result(FAIL, f"relative L1 error {rel:.3g} exceeds {tol:g}")

physverify/pytest_plugin.py

@@ -0,0 +1,75 @@
+"""pytest plugin: every check in a `verify_*.py` file becomes a test.
+
+A `verify_*.py` file defines `checks()`, returning a list of physverify.Check
+(the same spec format as `physverify run`). With physverify installed, plain
+`pytest` collects them; do not also pass `-p physverify.pytest_plugin`, because
+pytest then stops with "Plugin already registered". Without installing, use
+`pytest -p physverify.pytest_plugin`.
+Files named verify_*.py that do not define checks() are skipped. Turn the
+plugin off with `-p no:physverify`.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from .checks import OrderResult, run_check
+
+
+def pytest_collect_file(file_path, parent):
+    if file_path.suffix == ".py" and file_path.name.startswith("verify_"):
+        return VerifyFile.from_parent(parent, path=file_path)
+    return None
+
+
+class CheckFailed(Exception):
+    pass
+
+
+class VerifyFile(pytest.File):
+    def collect(self):
+        from .report import load_spec
+
+        try:
+            checks = load_spec(self.path)
+        except AttributeError as exc:
+            if "does not define checks()" in str(exc):
+                return
+            raise
+        seen = {}
+        for check in checks:
+            name = f"{check.family}: {check.label}"
+            seen[name] = seen.get(name, 0) + 1
+            if seen[name] > 1:
+                name = f"{name} [{seen[name]}]"
+            yield CheckItem.from_parent(self, name=name, check=check)
+
+
+class CheckItem(pytest.Item):
+    def __init__(self, *, check, **kwargs):
+        super().__init__(**kwargs)
+        self.check = check
+        self.add_marker(pytest.mark.physverify)
+
+    def runtest(self):
+        result = run_check(self.check)
+        self.user_properties.append(("status", result.status))
+        if not result.ok:
+            raise CheckFailed(result)
+
+    def repr_failure(self, excinfo):
+        if isinstance(excinfo.value, CheckFailed):
+            result = excinfo.value.args[0]
+            lines = [f"{result.status}: {result.message}"]
+            if isinstance(result, OrderResult) and result.hs:
+                lines.append(f"{'h':>12s} {'error':>12s}")
+                lines += [f"{h:12.4g} {e:12.4g}" for h, e in zip(result.hs, result.errors)]
+            return "\n".join(lines)
+        return super().repr_failure(excinfo)
+
+    def reportinfo(self):
+        return self.path, None, f"{self.check.family}: {self.check.label}"
+
+
+def pytest_configure(config):
+    config.addinivalue_line("markers", "physverify: a check collected from a verify_*.py file")