test: shear-wave modal-extinction handling; TG mock verify_source flow arg

- shear_wave.fit_rate: finite late R=0 returns rate_fit_valid=false with
  null fit quantities (no clipping, no invented rate); own screens and
  budgets treat it as a failure (CONTROL_SCREEN_FAIL / refined FAIL),
  other finite metrics retained, JSON-safe.
- test_projected_pairs: dry-run/execution mocks expect the explicit
  'taylor_green' flow argument now passed to verify_source.
- run_case: SHEAR_WAVE_SHA256 repinned; extinction test added.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

docs/compatibility.md

@@ -1,35 +0,0 @@
-# Compatibility and API changes
-
-Changes that can make a previously accepted setup or call behave differently.
-Each entry names the commit, the affected entry points and the observable result.
-
-## 87c3a31: cut-link ownership is validated for every body
-
-`validate_cut_link_ownership` (`body/preprocess/flag_overlay.py`) now runs for
-passive bodies as well as Jet/aperture bodies. Every cut link must have an
-active fluid receiver (FLUID set, SOLID clear), and each `(receiver, direction)`
-population may have only one writer.
-
-Rejected with `ValueError`, before flags, populations or device buffers change:
-
-1. Overlapping or touching passive solids whose cut links write the same
-   population ("Boundary requires unique cut-link writers").
-2. A body whose cut-link receiver is a non-fluid cell, e.g. a channel wall row
-   or the inlet/outlet column ("Cut links must have active fluid receivers").
-
-Both were previously accepted silently for passive bodies; the interpolated
-boundary then had undefined results. The rules apply to the cut links of all
-bodies together, so a passive body overlapping a Jet body is rejected as well.
-The check runs in `Simulation.initialize`, runtime body sync (`sync_bodies`),
-checkpoint save and checkpoint load (`common/checkpoint.py`). Load validates
-before restoring anything, so a checkpoint whose saved geometry violates either
-rule no longer restores; rebuild the geometry with separated bodies.
-
-## 87c3a31: `Simulation.read_surface_exchange` accepts Jet-driven bodies
-
-`read_surface_exchange(id)` previously required `SurfaceActuation` on the body.
-It now also accepts bodies that own Jet aperture links, including Jets with zero
-or negative amplitude (the aperture test is geometric). Bodies with neither
-`SurfaceActuation` nor aperture links still raise
-`ValueError("Body has no surface actuation")`. The value is unchanged: the latest
-step's wall/aperture exchange, not total nozzle force.

docs/validation/dfg_re20.md

@@ -1,49 +0,0 @@
-# DFG 2D-1 (Re 20) against the official reference intervals
-
-`tests/validation/run_dfg_re20.py` runs the steady DFG 2D-1 case on the refined
-channel root (D40 root, D80 wide fine patch) and on the uniform D80 grid. Geometry,
-inflow, initial state, layout and observation are those of the pinned Re100 runner
-(`run_refined_dfg.py`, `re100_helpers.py`, both unchanged); only the lattice
-viscosity is set for Re 20 (root tau 0.56, fine 0.62, uniform 0.62, lattice speed 0.01).
-
-Label: "compared against the official reference bands", not a full benchmark
-certification: the outlet is pressure-NEQ (`neq_extrap`), not do-nothing, and the
-inlet is local Zou-He.
-
-## Quantities
-
-- Cd = 2 Fx / (rho U^2 D), Cl = 2 Fy / (rho U^2 D), interval means over each sample.
-- p_diff = p(0.15, 0.2) - p(0.25, 0.2), linear extrapolation to the exact surface
-  points (`re100_helpers.pressure_probes`). The helper returns dp / (rho U^2) in
-  scaled units; p_diff = dp * 0.04 for U = 0.2 m/s, rho = 1. Both are reported.
-- Official intervals (Schaefer & Turek 1996): Cd [5.57, 5.59], Cl [0.0104, 0.0110],
-  p_diff [0.1172, 0.1176].
-
-## Bounds and steady rule (frozen before any run)
-
-- End time t* = 60 (30 s physical): 240,000 refined root steps, 480,000 uniform steps.
-- One sample every t* = 0.5 (0.25 s) at the end of a synchronized root step; Cd and
-  Cl are interval means. Trailing window t* 50..60 inclusive (21 samples).
-- Steady rule (our engineering choice, not official): in the window, for each of Cd,
-  Cl, p_diff, max - min <= 10 % and |least-squares slope x window| <= 2 % of its
-  official interval width (range 2e-3 / 6e-5 / 4e-5; slope 4e-4 / 1.2e-5 / 8e-6).
-  Absolute limits, so the small Cl is never a divisor. Never relaxed after a run.
-- The verdict uses the window mean; the distance to the nearest interval edge is
-  reported for each quantity (negative outside).
-- Force sign: fluid on cylinder, x along the inflow, y up from the bottom wall; Cd > 0
-  and the official Cl > 0 (`cd_positive` is reported).
-- Not steady at t* = 60: status `NOT_STEADY`, no interval verdict. Health limits
-  (Mach <= 0.2, rho in [0.5, 1.5]) stop the run with `UNHEALTHY`.
-- Steady: `WITHIN_INTERVALS` or `OUTSIDE_INTERVALS`, with the per-quantity verdict.
-
-## Run
-
-```
-python tests/validation/run_dfg_re20.py --output <new-dir> --plan
-CUDA_VISIBLE_DEVICES=<n> python tests/validation/run_dfg_re20.py --case both \
-    --collision SRT --output <new-dir> --max-wall-seconds <cap>
-```
-
-The uniform D80 control separates method error from refinement error. `--plan` writes `plan.json` only. A GPU run writes `plan.json` and `result.json`
-(per case: lattice parameters, every sample, window ranges, status, verdict).
-Host contract tests: `tests/unit/test_dfg_re20.py`.

docs/validation/refined_dfg_window.md

@@ -56,62 +56,3 @@ Root must independently review and admit any execution. An admitted paired pilot
 the existing watchdog, device selection, `--gpu-gates-approved`, positive
 `--max-wall-seconds` and a new output directory, adding only `--exchange-window` to the
 selected collision's pilot command. No GPU or remote action was performed for this patch.
-
-## Public Jet diagnostic option
-
-`--collision MRT --exchange-window --jet-scenario zero|fixed|reverse` selects
-unshifted FP32, no LES, constant transfer on both existing public backends. Default
-`none` and the historical manifests remain unchanged. `zero` registers both Jets at
-zero amplitude and retains every existing DFG verdict, including pressure. `fixed`
-uses outward radial parabolic sectors at pi/2 and 3pi/2, half-width pi/12, peaks
-(+.001,-.001). Both use the existing D40/D80 geometry and U=.01. Sector origins are
-(80.5,81) in root edge coordinates and (160,160.5) in uniform node coordinates;
-radial extent is [0,1.005R]. `reverse` keeps those peaks through t*=300, updates both
-public setters at that completed boundary, and continues to 305 with opposite signs.
-
-Fixed diagnostic windows are 250–260, 260–270, 270–280, 280–290 and 290–300; reversal
-adds 300–305. Histories retain exact interval endpoints and root/uniform lattice
-impulses. The refined window uses total exchange; uniform uses public `read_force`
-batch averages. Driven windows report mean/min/max/RMS Cd/Cl without applying DFG
-reference or periodicity gates. Exit zero means healthy execution, not qualification;
-`matched_case_pass` remains false. No independent CV or stress-load claim is made.
-
-This opt-in records current source/helper hashes with the existing manifest format,
-checkout revision/dirty state and runner hash. Pilot/full must match that snapshot
-and the exact scenario. It does not relabel current source as historical evidence.
-Use the existing bounded plan/pilot/full commands with the three option flags above;
-full requires the matching completed t*=5 paired pilot. `step_seconds` includes force
-readback; observation/overhead and total wall time are separate, not kernel throughput.
-
-Add `--observe-cv` to record independent scalar control-volume samples from the
-already downloaded public macros. The pilot exercises this path at t*=.02..5;
-full records 501 endpoints at 290..300. Each `cv_history.jsonl` row contains actual
-root time, preceding interval start/duration/impulse, and two inventories/outward
-fluxes ordered [mass,Px,Py]. Exclude the first row's preceding impulse: that row
-supplies the initial inventory. Uniform native impulse converts by .5² to root
-units; refined ledger impulse is already in root units. Explicit native-aligned
-contours differ by .25 root cells in x and are recorded in the plan. Cropping
-retains the two-cell face-gradient stencils. No fields or per-link arrays are saved.
-`cv_observation_seconds` is the CV portion of observation/overhead time. Helper hash
-and the observation flag must match pilot/full. Time integration, temporal
-coarsening and any physical assessment remain separate offline work.
-
-## Bounded resolution and placement controls
-
-Defaults remain `--case both --uniform-diameter 80 --placement wide`. Single-case
-runs use `--case uniform` or `--case refined` and never report a matched-case pass.
-Their own reference/periodicity or driven-diagnostic results remain available.
-A single zero-Jet full run exits successfully only when its periodicity and the
-unchanged complete DFG reference verdict pass; driven completion is not qualification.
-
-The D160 option requires `--case uniform --uniform-diameter 160` and an explicit
-public Jet scenario. U and Jet speeds stay .01 and ±.001; viscosity is .016,
-grid 3521×658, center (320,320.5), radius80. CV uses root spacing/time factor .25,
-origin (.375,.75), impulse factor .0625, root viscosity .004, and x-face shift .125.
-
-`--case refined --placement compact` selects root bounds (48,48,128,128), fine
-168×168 and origin (46,46), with the same D40/fineD80 body/Jet resolution. Its CV
-contours are (52,52,112,112) and (50,50,120,120); complete face-gradient stencils
-are clear of both solids and the transfer footprint. Compact is refined-only.
-CV metadata gives each grid's spacing/origin/contours explicitly. Case, uniform
-diameter and placement must match the newly completed pilot in every receipt.

docs/validation/taylor_green.md

@@ -159,3 +159,139 @@ theoretical stress-consistency certification or production-kernel change.
 ## Repository integration
 
 The four Python harness files remain together under tests/validation/taylor_green, so runtime provenance hashes precisely this harness directory. Formatting changes produce a new harness identity; preparation and integrated receipts must not be mixed. All analytic definitions, numerical floors, assessment gates, sample times, and source-import assertions are unchanged. Production source is unchanged from the cd3 snapshot; these periodic tests do not waive the separate channel GPU gate.
+
+## Oblique shear wave (test-only diagnostic, not GPU-qualified)
+
+`shear_wave.py` reuses the frozen oracle's constants, cell centers and
+geometry. `oracle.py` is byte-identical, and `test_shear_wave.py` pins its
+eec4677 SHA-256. `run_case.py --flow shear_wave` selects the shear wave;
+the default flow and its receipt are the unchanged Taylor–Green path.
+
+### Convention
+
+Integer mode (2,1) on the L=N periodic root domain:
+- the wavevector `k = (2*pi/L)*(2,1)` points 26.565° from +x;
+- mode (1,2) would point 63.435°, and a wrong-mode test catches a swap.
+
+Polarization is `E = (-1,2)/sqrt(5)`, perpendicular to k:
+
+    u = U*E*sin(k.x + phi)*exp(-nu*|k|^2*t),  phi = 0,  p = const,  rho0 = 1
+
+`nu = U*N/100`, the Taylor–Green Re100 viscosity at the same N. This is an
+exact incompressible Navier–Stokes solution. The initial condition is FP64
+second-order equilibrium at the actual leaf centers, with no
+non-equilibrium part.
+
+### Physical caveats
+
+1. *Scope of the cubic-term argument.* The second-order D2Q9 equilibrium
+   lacks the cubic third moment `rho*u_a*u_b*u_g` of the Maxwellian (Dellar,
+   https://people.maths.ox.ac.uk/dellar/papers/Galilean.pdf, eq. 3). At
+   Navier–Stokes order this produces a stress error proportional to
+   `d_g(rho u_a u_b u_g)`.
+
+   For the ideal constant-density, zero-background transverse wave, k.E = 0
+   makes that contracted derivative vanish. That is the only claim made.
+   It does not remove other discrete or finite-Mach errors. It is not
+   guaranteed once AMR introduces density, longitudinal or higher-mode
+   contamination. The analytic NS field itself is exact.
+2. *Startup.* Equilibrium initialization is not the discrete shear
+   eigenmode (Mei et al., https://doi.org/10.1016/j.compfluid.2005.08.008).
+   - The decay rate is a free-intercept least-squares fit of ln R over the
+     samples with t* >= 0.12, where `R = hypot(a_hat, b_hat)`.
+   - The intercept cancels only a constant amplitude prefactor, and only
+     once a single exponential dominates.
+   - Per-interval rates and the maximum log-fit residual are kept, so a
+     lingering transient stays visible.
+   - Late sampling alone does not show that transients have gone.
+
+### Metrics
+
+Computed on ACTIVE leaf cells, each weighted by its area `4**-level` in
+root-cell units. The partition must cover the domain exactly once, and one
+global pressure gauge is used.
+
+- `a_hat`, `b_hat`: weighted least-squares fit of `u.E` onto sin/cos, using
+  the 2x2 Gram matrix of the actual composite quadrature. A wrong Fourier
+  mode need not project to exactly zero on this quadrature.
+- `amplitude_error = R/A_exact - 1`.
+- `phase_drift = atan2(b_hat, a_hat)`, in radians, reported separately.
+- Rates are positive (minus the fitted slope).
+  - Per root step they are compared with `nu*|k|^2`. Uniform 2N uses its
+    own `nu = 0.0768` at N=256 and doubled step counts.
+  - In t* they are compared with `5*(2*pi)^2/Re = 1.97392088`.
+  - `rate_error = |rate/exact - 1|`.
+- `velocity_l2`, `residual_l2` (velocity left after removing the fitted
+  mode) and `longitudinal_l2` (the `u.k_hat` part), all relative to the
+  exact-field norm. A longitudinal perturbation also raises the
+  full-vector residual and the velocity L2.
+- `spurious_pressure_rms`: the raw gauged rms of `p = (rho-1)/3`.
+- `spurious_pressure_scaled`: that rms divided by `A_exact(t)^2/4`, a
+  continuum reference scale. It is *not* the discrete, globally gauged
+  Taylor–Green norm on the composite grid. Exact pressure is constant, so
+  no relative-to-exact claim is made. Max and per-level values are kept.
+
+### Preregistered screens (`shear_wave.assess`)
+
+Run set: uniform N, uniform 2N, and refined depth-2 runs at root N.
+
+- `eps(N) = (|k| h_root)^2 = 5*(2*pi/N)^2`: dimensionless, coefficient
+  one, 0.01205 at N=128. This is a chosen screen, not a proven error bound.
+- Absolute screens:
+  - rate_error, max |phase_drift| (radians) and max residual_l2 must each
+    be <= eps;
+  - velocity_l2 <= 0.05, mass <= 1e-5, spurious_pressure_scaled <= 0.02.
+- Budgets keep the `assess.py` form, `refined <= max(2*control_N, floor)`:
+  - floors are 0.002 for rate and residual, 0.02 for pressure;
+  - the comparative pressure budget is always redundant:
+    `max(2*control, 0.02)` is never below the 0.02 absolute ceiling;
+  - raw ratios to both the root and finest controls, including raw
+    pressure rms, are always reported.
+- Every record is validated before any screen is applied:
+  - exact scheduled steps and t*, with no duplicates;
+  - every numeric field finite, including list fields and density;
+  - error quantities nonnegative and rho_min > 0;
+  - signed quantities (amplitudes, `amplitude_error`, `phase_drift`,
+    per-interval rate errors) keep their sign.
+- Outcomes are kept distinct:
+  - INVALID_CONTROL: a control or refined run is missing, a control is
+    incomplete or invalid, or the records come from mixed sources;
+  - INVALID_RUN: a refined record fails validation;
+  - CONTROL_SCREEN_FAIL: complete, valid controls fail their own screens.
+    Each refined run's `own_screens_pass` is still reported, but
+    `controlled_pass` is false, so it is never a controlled-comparison pass;
+  - PASS/FAIL: every refined run's `controlled_pass` (own screens and
+    budgets against valid, passing controls).
+  - Finite modal extinction (late R = 0) is a physical failure, not
+    malformed data. The run gets `rate_fit_valid=false` with null fit
+    quantities, and its other metrics are kept. Nothing is clipped and no
+    rate is invented. The result is CONTROL_SCREEN_FAIL for a control, or
+    FAIL for a refined run.
+  - Screens are never retuned.
+
+### Limitations
+
+One flow, one phase and one rectangle, SRT only. The rectangle's vertical
+faces span 0.625 tangential periods and its horizontal faces 1.5, so this
+is not placement robustness. Two resolutions show a trend, not an order.
+
+### Receipt assessment and runner integrity
+
+- Fixed four-case N128 contract:
+  `python assess_shear_wave.py U128.json U256.json R128_constant.json R128_projected.json --output report.json --expected-revision <sha>`.
+  It reuses the shared provenance, build, workload and sample-time checks
+  from `assess_projected_pairs.py`, and adds shear metadata checks (flow,
+  mode, polarization, angle, phase, eps, limits, disabled early trace, and
+  pinned `shear_wave.py` hash).
+  - Missing, extra, duplicate or mixed-source records give `INVALID_SET`,
+    as does any failed shared check.
+  - Otherwise the result comes from `shear_wave.assess`, which separates
+    `INVALID_CONTROL` from `CONTROL_SCREEN_FAIL`.
+- `run_case.verify_source(..., flow="shear_wave")` requires the imported
+  `shear_wave.py` to be the selected harness file with the pinned
+  `SHEAR_WAVE_SHA256`. The default TG flow does not import it.
+- Sample and READY finiteness use `finite_row`, which accepts scalar and
+  list diagnostics. For TG's all-scalar rows it behaves the same as before.
+- Merge note: native 92b8afe adds a `scaled_n256` receipt block. When the
+  two are merged, keep both blocks and make `--flow shear_wave` and
+  `scaled_n256` mutually exclusive. Not merged here.

src/CelerisLab/body/jets.py

@@ -216,8 +216,11 @@ def surface_link_velocity(objects, cfg, flags, fluid_idx, dir, body_id, rx, ry,
     enabled = [obj for obj in objects if obj.surface_actuation is not None]
     if not enabled and not jets:
         return None, None
-    from .preprocess.flag_overlay import validate_cut_link_ownership
-    validate_cut_link_ownership(flags, fluid_idx, dir, cfg.nq)
+    from ..lbm.descriptors import FLUID, SOLID
+    if np.any((flags[fluid_idx] & FLUID) == 0) or np.any(flags[fluid_idx] & SOLID):
+        raise ValueError("Surface cut links must have active fluid receivers")
+    if len(np.unique(fluid_idx.astype(np.uint64)*cfg.nq+dir)) != len(dir):
+        raise ValueError("Surface boundary requires unique cut-link writers")
     surface_velocity = np.zeros((len(dir), 2), np.float32)
     surface_aperture = np.zeros(len(dir), bool)
     for obj in enabled:

src/CelerisLab/body/manager.py

@@ -27,7 +27,7 @@ import pycuda.driver as cuda
 
 from .objects import SimObject
 from .registry import BodyRegistry
-from .preprocess.flag_overlay import merge_flag_masks, validate_cut_link_ownership
+from .preprocess.flag_overlay import merge_flag_masks
 from ..cuda.compiler_v2 import obs_layout
 from ..cuda.obs_layout import ObsLayout
 from ..lbm.descriptors import (
@@ -369,9 +369,9 @@ class ObjectManager:
 
         Args:
             objects: List of SimObject instances to process.
-            domain_flags: Optional uint16 flags for receiver/donor classification.
+            domain_flags: Optional uint16 flags for donor-cell classification.
             sensor_cell_counts_out: Int array to fill with per-object sensor
-                cell counts after the full geometry has passed validation.
+                cell counts.  If provided, ``fill(0)`` is called first.
             hits_out: List that receives one FP64 (n, 2) array of true hit
                 points row-aligned with the cut-link columns (for Jets).
 
@@ -394,8 +394,8 @@ class ObjectManager:
         active_fluid = ((domain_flags & FLUID) != 0) & ((domain_flags & SOLID) == 0)
         force_owners: set[int] = set()
 
-        sensor_counts = (np.zeros_like(sensor_cell_counts_out)
-                         if sensor_cell_counts_out is not None else None)
+        if sensor_cell_counts_out is not None:
+            sensor_cell_counts_out.fill(0)
 
         ez = None
         if self.cfg and self.cfg.is_d3q19:
@@ -430,9 +430,9 @@ class ObjectManager:
                 if len(cells) > 0:
                     s_cells.append(cells)
                     s_ids.append(ids)
-                    if (sensor_counts is not None
-                            and 0 <= obj.obj_id < sensor_counts.size):
-                        sensor_counts[obj.obj_id] = int(len(cells))
+                    if (sensor_cell_counts_out is not None
+                            and 0 <= obj.obj_id < sensor_cell_counts_out.size):
+                        sensor_cell_counts_out[obj.obj_id] = int(len(cells))
             if obj.is_force_region and hasattr(obj, 'get_sensor_list'):
                 cells, ids = obj.get_sensor_list(self.nx, self.ny, self.nz)
                 keep = active_fluid[cells]
@@ -461,9 +461,8 @@ class ObjectManager:
         r_fr_ids = np.concatenate(fr_ids) if fr_ids else np.zeros(0, dtype=np.int32)
 
         r_hit = np.concatenate(cl_hit) if cl_hit else np.zeros((0, 2))
-        # Passive walls need the same ownership guarantees as driven walls.
-        # Overlapping solids are not a supported union-boundary operation.
-        validate_cut_link_ownership(domain_flags, r_idx, r_dir, self.nq)
+        if hits_out is not None:
+            hits_out.append(r_hit)
         if self.jets or any(obj.surface_actuation is not None for obj in objects):
             # Reject unresolved apertures/ownership before sync or restart mutates state.
             from ..lbm.curved_links import CurvedLinkSoA
@@ -471,11 +470,6 @@ class ObjectManager:
             links.assign_host(r_idx, r_dir, r_q, r_bid, r_rx, r_ry, r_rz, r_fallback)
             links.assign_surface(objects, self.cfg, domain_flags, jets=self.jets, hits=r_hit)
 
-        if sensor_cell_counts_out is not None:
-            sensor_cell_counts_out[:] = sensor_counts
-        if hits_out is not None:
-            hits_out.append(r_hit)
-
         return (
             r_idx, r_dir, r_q, r_bid,
             r_rx, r_ry, r_rz, r_fallback,
@@ -493,6 +487,8 @@ class ObjectManager:
                 the caller has already prepared and uploaded the final flag field
                 for this geometry, such as during initialization.
         """
+        self._telemetry_field = field
+
         next_flags = self.build_flags(field.build_channel_flags()) if rebuild_flags else field.flag
         hits = []
 
@@ -503,7 +499,6 @@ class ObjectManager:
             fr_cells, fr_obj_id,
         ) = self.build_compact_lists(domain_flags=next_flags, hits_out=hits)
 
-        self._telemetry_field = field
         if rebuild_flags:
             field.flag = next_flags
             field.upload_flags()

src/CelerisLab/body/preprocess/flag_overlay.py

@@ -1,6 +1,6 @@
 # CelerisLab/body/preprocess/flag_overlay.py
 """
-Flag overlay and cut-link ownership checks against the merged domain.
+Flag overlay: merge per-object flag masks onto a clean domain base.
 """
 
 from __future__ import annotations
@@ -12,15 +12,6 @@ import numpy as np
 from ...lbm.descriptors import FLUID, SOLID, SENSOR_FLAG, FRC_REGION
 
 
-def validate_cut_link_ownership(flags, fluid_idx, directions, nq):
-    """Reject solid receivers and multiple writers to one population."""
-    if np.any((flags[fluid_idx] & FLUID) == 0) or np.any(flags[fluid_idx] & SOLID):
-        raise ValueError("Cut links must have active fluid receivers")
-    writers = fluid_idx.astype(np.uint64) * nq + directions
-    if len(np.unique(writers)) != len(directions):
-        raise ValueError("Boundary requires unique cut-link writers")
-
-
 def merge_flag_masks(
     base: np.ndarray,
     masks: List[np.ndarray],

src/CelerisLab/simulation.py

@@ -336,19 +336,13 @@ class Simulation:
     def read_surface_exchange(self, id: int):
         """Latest step's wall/aperture (Fx,Fy,Tz) exchange, not total nozzle force.
 
-        Supports SurfaceActuation and Jet-driven bodies, including zero-amplitude
-        apertures. Passive bodies without an aperture are rejected.
         Unlike read_body this is not accumulated/time-averaged. It resets after
         geometry sync or checkpoint load; advance before interpreting it.
         """
-        obj = self.bodies.get(id)
-        curved = self.field.curved
-        has_aperture = (curved.aperture is not None
-                        and np.any(curved.aperture & (curved.body_id == id)))
-        if obj.surface_actuation is None and not has_aperture:
+        if self.bodies.get(id).surface_actuation is None:
             raise ValueError("Body has no surface actuation")
         self.stream.synchronize()
-        return curved.surface_exchange(id)
+        return self.field.curved.surface_exchange(id)
 
     @context_bound
     def read_body(self, id: int, *,
@@ -457,21 +451,18 @@ class Simulation:
     @context_bound
     def initialize(self):
         """Initialize flow field and sync objects to GPU."""
-        self._assert_allocation_contract()
-        # Validate the complete geometry before flags, populations or modules
-        # change. Compact-list construction publishes no outputs on failure.
-        next_flags = self.bodies.build_flags(self.field.build_channel_flags())
-        if self.bodies.jets and self.bodies.count == 0:
-            raise ValueError("Jets need bodies with cut links")
-        self.bodies.build_compact_lists_for(self.bodies.objects, next_flags)
-
         # Recompile if objects were added after construction.
+        self._assert_allocation_contract()
         if self._read_generated_n_objects() != self.bodies.count:
             self.recompile()
 
-        self.field.flag = next_flags
+        self.field.flag = self.field.build_channel_flags()
+        if self.bodies.count > 0:
+            self.field.flag = self.bodies.build_flags(self.field.flag)
         self.field.upload_flags()
 
+        if self.bodies.jets and self.bodies.count == 0:
+            raise ValueError("Jets need bodies with cut links")
         self.stepper.initialize()
         if self.bodies.count > 0:
             self.bodies.sync_to_gpu(self.field, rebuild_flags=False)

tests/unit/test_annulus_ledger.py

@@ -1,101 +0,0 @@
-"""Synthetic checks of the annulus mass ledger. Host-only, stdlib; not solver evidence."""
-
-import random
-import sys
-from pathlib import Path
-import unittest
-
-sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "validation"))
-import annulus_ledger as al  # noqa: E402
-
-NX = NY = 24
-# Annulus 4 <= r <= 8 around (12, 12); dyadic values keep every sum exact.
-A = {(x, y) for x in range(NX) for y in range(NY) if 16 <= (x - 12) ** 2 + (y - 12) ** 2 <= 64}
-DELTA = 0.375
-
-
-def owner(seed=1):
-    rng = random.Random(seed)
-    return [[[rng.randint(1, 1024) / 1024 for _ in range(NX)] for _ in range(NY)] for _ in range(9)]
-
-
-def collide(P, source=None):
-    """Mass-conserving stand-in: rotate populations within each cell (+ optional source)."""
-    D = [[[P[(q + 1) % 9][y][x] for x in range(NX)] for y in range(NY)] for q in range(9)]
-    if source:
-        (x, y), s = source
-        D[0][y][x] += s
-    return D
-
-
-def link(interior):
-    """(x, y, q) with x in A and x - c_q inside (seam) or outside (edge) A."""
-    for (x, y) in sorted(A):
-        for q in range(1, 9):
-            src = ((x - al.CX[q]) % NX, (y - al.CY[q]) % NY)
-            if (src in A) == interior:
-                return x, y, q
-    raise AssertionError
-
-
-class Ledger(unittest.TestCase):
-    def setUp(self):
-        self.O = owner()
-        self.P = al.pull(self.O, NX, NY)
-
-    def run_ledger(self, P, D):
-        return al.ledger(self.O, P, D, A, NX, NY)
-
-    def test_ideal_pull_has_no_h_and_closes(self):
-        r = self.run_ledger(self.P, collide(self.P))
-        self.assertEqual((r["H_seam"], r["H_edge"], r["C"], r["residual"]), (0, 0, 0, 0))
-        self.assertEqual(r["dM"], -r["Q_exact"])
-        self.assertNotEqual(r["Q_exact"], 0)
-
-    def test_collision_source_is_c(self):
-        x, y = sorted(A)[3]
-        r = self.run_ledger(self.P, collide(self.P, ((x, y), DELTA)))
-        self.assertEqual((r["C"], r["H"], r["residual"]), (DELTA, 0, 0))
-
-    def test_interior_seam_perturbation(self):
-        x, y, q = link(interior=True)
-        self.P[q][y][x] += DELTA
-        r = self.run_ledger(self.P, collide(self.P))
-        self.assertEqual((r["H_seam"], r["H_edge"], r["residual"]), (DELTA, 0, 0))
-        # Invisible to any flux through the edge of A; only H explains the mass change.
-        self.assertEqual(al.staged_flux(self.O, self.P, A, NX, NY), r["Q_exact"])
-        self.assertEqual(r["dM"] + r["Q_exact"], DELTA)
-
-    def test_edge_perturbation_and_staged_flux_double_count(self):
-        x, y, q = link(interior=False)
-        self.P[q][y][x] += DELTA
-        r = self.run_ledger(self.P, collide(self.P))
-        self.assertEqual((r["H_seam"], r["H_edge"], r["residual"]), (0, DELTA, 0))
-        staged = al.staged_flux(self.O, self.P, A, NX, NY)
-        self.assertEqual(staged, r["Q_exact"] - DELTA)
-        # Staged flux + full H counts the staging change twice.
-        self.assertEqual(r["dM"] + staged - r["C"] - r["H"], -DELTA)
-        # Staged flux alone closes only without the edge part of H.
-        self.assertEqual(r["dM"] + staged - r["C"] - r["H_seam"], 0)
-
-    def test_owner_snapshot_after_staging_hides_the_change(self):
-        # Snapshot taken after staging wrote the same slot into the owner image.
-        x, y, q = link(interior=False)
-        sx, sy = (x - al.CX[q]) % NX, (y - al.CY[q]) % NY
-        self.P[q][y][x] += DELTA
-        late = [[row[:] for row in plane] for plane in self.O]
-        late[q][sy][sx] += DELTA
-        r = al.ledger(late, self.P, collide(self.P), A, NX, NY)
-        self.assertEqual((r["H"], r["residual"]), (0, 0))
-
-    def test_wrong_pull_direction_is_flagged(self):
-        # Indexing error (push instead of pull): H is nonzero with no physical cause.
-        bad = [[[self.O[q][(y + al.CY[q]) % NY][(x + al.CX[q]) % NX] for x in range(NX)]
-                for y in range(NY)] for q in range(9)]
-        r = self.run_ledger(bad, collide(bad))
-        self.assertNotEqual(r["H"], 0)
-        self.assertEqual(r["residual"], 0)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/unit/test_dfg_re20.py

@@ -1,79 +0,0 @@
-"""CPU-only contract tests for run_dfg_re20. Not CUDA or DFG acceptance evidence."""
-
-import sys
-from pathlib import Path
-import unittest
-
-sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "validation"))
-import run_dfg_re20 as v  # noqa: E402
-import run_refined_dfg as rr  # noqa: E402
-
-h, _ = rr.helpers(rr.DEFAULT_SOURCE)
-
-
-def rows(values, tstar_end=v.TSTAR_MAX):
-    n = int(round(tstar_end / v.SAMPLE_TSTAR))
-    return [dict(tstar=(i + 1) * v.SAMPLE_TSTAR, **values(i)) for i in range(n)]
-
-
-class Re20Contract(unittest.TestCase):
-    def test_lattice_parameters_and_bounds(self):
-        root, uniform = v.lattice_parameters(40), v.lattice_parameters(80)
-        self.assertAlmostEqual(root["tau"], 0.56, places=12)
-        self.assertAlmostEqual(uniform["tau"], 0.62, places=12)
-        self.assertEqual((root["steps"], root["interval"]), (240000, 2000))
-        self.assertEqual((uniform["steps"], uniform["interval"]), (480000, 4000))
-        self.assertAlmostEqual(v.plan()["refined_fine_tau"], 0.62, places=12)
-
-    def test_config_only_changes_viscosity(self):
-        base = v._re100_config(h, 40, "SRT", "none")
-        cfg, body, p = v.config(h, 40, "SRT")
-        self.assertAlmostEqual(cfg["physics"]["viscosity"], 0.01 * 40 / 20, places=15)
-        self.assertEqual((p["re"], p["viscosity"]), (20.0, cfg["physics"]["viscosity"]))
-        base[0]["physics"]["viscosity"] = cfg["physics"]["viscosity"]
-        self.assertEqual(base[0], cfg)
-        self.assertEqual(base[1], body)
-        with self.assertRaisesRegex(ValueError, "no Jets"):
-            v.config(h, 40, "MRT", "zero")
-
-    def test_units(self):
-        s = v.sample([2.0, -0.5], 4, 40, 3.0)
-        den = rr.SPEED**2 * 40 / 2
-        self.assertAlmostEqual(s["cd"], 2.0 / 4 / den)
-        self.assertAlmostEqual(s["cl"], -0.5 / 4 / den)
-        self.assertAlmostEqual(s["p_diff"], 3.0 * 0.04)
-        self.assertEqual(s["dp_scaled"], 3.0)
-
-    def test_steady_and_verdict(self):
-        inside = dict(cd=5.58, cl=0.0106, p_diff=0.1174)
-        out = v.summarize(rows(lambda i: inside))
-        self.assertEqual((out["status"], out["steady"], out["window_samples"]),
-                         ("WITHIN_INTERVALS", True, 21))
-        self.assertTrue(out["cd_positive"])
-        self.assertAlmostEqual(out["edge_distance"]["cl"], 0.0002)
-        self.assertTrue(all(out["verdict"].values()))
-        low = v.summarize(rows(lambda i: dict(inside, cl=0.0100)))
-        self.assertEqual(low["status"], "OUTSIDE_INTERVALS")
-        self.assertFalse(low["verdict"]["cl"])
-
-    def test_slow_drift_gives_no_verdict(self):
-        # Range 2e-5 passes (limit 6e-5); slope * window 2e-5 exceeds 1.2e-5.
-        out = v.summarize(rows(lambda i: dict(cd=5.58, cl=0.0106 + 1e-6 * i, p_diff=0.1174)))
-        self.assertEqual((out["status"], out["verdict"]), ("NOT_STEADY", None))
-        self.assertLessEqual(out["ranges"]["cl"], out["range_limits"]["cl"])
-        self.assertGreater(out["drifts"]["cl"], out["slope_limits"]["cl"])
-
-    def test_noise_range(self):
-        quiet = v.summarize(rows(lambda i: dict(cd=5.58, cl=0.0106 + 2e-5 * (i % 2), p_diff=0.1174)))
-        self.assertTrue(quiet["steady"])  # within the range limit, no trend
-        noisy = v.summarize(rows(lambda i: dict(cd=5.58, cl=0.0106 + 1e-4 * (i % 2), p_diff=0.1174)))
-        self.assertEqual(noisy["status"], "NOT_STEADY")
-        self.assertGreater(noisy["ranges"]["cl"], noisy["range_limits"]["cl"])
-
-    def test_incomplete_run_gives_no_verdict(self):
-        out = v.summarize(rows(lambda i: dict(cd=5.58, cl=0.0106, p_diff=0.1174), tstar_end=30))
-        self.assertEqual((out["status"], out["verdict"]), ("INCOMPLETE", None))
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/unit/test_jet_circle_cv.py

@@ -16,7 +16,6 @@ from run_jet_circle_cv import (
     case,
     state,
     cv,
-    cv_from_macros,
     aperture_probe,
     measured_aperture_flux,
     verify,
@@ -29,39 +28,6 @@ def eq(rho, u, v):
 
 
 class Host(unittest.TestCase):
-    def test_public_macros_pressure_advection_and_cropped_frames(self):
-        for h, origin, shape, rect in (
-            (.5, (0., 0.), (48, 64), (5., 4., 25., 20.)),
-            (.5, (.25, .5), (48, 64), (5.25, 4., 25.25, 20.)),
-            (.25, (.375, .75), (96, 128), (5.125, 4., 25.125, 20.)),
-        ):
-            y, x = np.indices(shape)
-            x = origin[0] + h * (x + .5)
-            k, u, v = 1e-5, .02, -.01
-            rho = 1 + 3 * k * x  # p=(rho-1)/3=k*x
-            ux, uy, fluid = np.full(shape, u), np.full(shape, v), np.ones(shape, bool)
-            result = cv_from_macros(rho, ux, uy, fluid, origin, rect, .004, h)
-            expected = 320 * np.array([3*k*u, k + 3*k*u*u, 3*k*u*v])
-            np.testing.assert_allclose(result[1], expected, rtol=1e-11, atol=1e-13)
-            np.testing.assert_allclose(result, cv(eq(rho, u, v), fluid, origin, rect, .004, h), atol=1e-12)
-            x0, y0, x1, y1 = np.rint((np.array(rect)-np.tile(origin, 2))/h).astype(int)
-            selection = np.s_[y0-2:y1+2, x0-2:x1+2]
-            cropped_origin = np.asarray(origin) + h*np.array([x0-2, y0-2])
-            cropped = cv_from_macros(rho[selection], ux[selection], uy[selection],
-                                    fluid[selection], cropped_origin, rect, .004, h)
-            np.testing.assert_array_equal(cropped, result)
-
-    def test_public_macros_full_normal_viscous_stress(self):
-        y, x = np.indices((48, 64))
-        x = (x + .5) * .5
-        rho, ux, uy, fluid = np.ones_like(x), 1e-4*x*x, np.zeros_like(x), np.ones(x.shape, bool)
-        args = (rho, ux, uy, fluid, (0., 0.), (5., 4., 25., 20.))
-        _, viscous = cv_from_macros(*args, .004)
-        _, inviscid = cv_from_macros(*args, 0.)
-        np.testing.assert_allclose(viscous-inviscid, [0, -4*.004*1e-4*320, 0], atol=1e-13)
-        with self.assertRaisesRegex(ValueError, "matching 2D"):
-            cv_from_macros(rho, ux, uy[:-1], fluid, (0, 0), (5, 4, 25, 20), .004)
-
     def test_descriptor_and_uniform_closed_flux(self):
         from CelerisLab.lbm.descriptors import D2Q9_EX, D2Q9_EY
 

tests/unit/test_jets.py

@@ -188,55 +188,6 @@ def jet_case(device, jets):
     return field, bodies
 
 
-def test_public_surface_exchange_for_jet_preserves_aperture_at_zero_and_reverse(device):
-    from CelerisLab.simulation import Simulation
-    jet = Jet(Sector(CENTER, 0., .6, 3.), Radial(CENTER, inward=False), "quartic", 2e-3)
-    field, bodies = jet_case(device, [jet])
-    sim = SimpleNamespace(bodies=bodies, field=field, _initialized=True,
-                          stream=SimpleNamespace(synchronize=device.synchronize))
-    cl = field.curved
-    assert bodies.get(0).surface_actuation is None
-    aperture, velocity = cl.aperture, cl.surface_velocity.copy()
-    assert aperture.any() and (~aperture).any()
-    # Synthetic per-link exchanges test readback/splitting, not kernel physics.
-    values = np.arange(cl.count * 3, dtype=np.float32).reshape(-1, 3)
-    device.htod(cl.link_exchange_gpu, values)
-    for amplitude in (2e-3, 0., -1e-3):
-        Simulation.set_jet_amplitude(sim, 0, amplitude)
-        result = Simulation.read_surface_exchange(sim, 0)
-        assert cl.aperture is aperture
-        np.testing.assert_array_equal(aperture, cl.jet_id >= 0)
-        np.testing.assert_allclose(cl.surface_velocity, velocity * (amplitude / 2e-3))
-        for name, mask in (("wall", ~aperture), ("aperture", aperture)):
-            np.testing.assert_array_equal(result[name], values[mask].sum(axis=0, dtype=np.float64))
-
-
-def test_public_surface_exchange_keeps_legacy_and_passive_guards(device):
-    from CelerisLab.simulation import Simulation
-    field = make_field(device)
-    bodies = manager(field, [circle(SurfaceActuation(0., .6, .002), radius=2.)])
-    bodies.sync_to_gpu(field)
-    sim = SimpleNamespace(bodies=bodies, field=field,
-                          stream=SimpleNamespace(synchronize=device.synchronize))
-    for value in Simulation.read_surface_exchange(sim, 0).values():
-        np.testing.assert_array_equal(value, 0.)
-    field.curved.free_gpu_columns()
-    with pytest.raises(RuntimeError, match="diagnostic is allocated"):
-        Simulation.read_surface_exchange(sim, 0)
-
-    # An exchange buffer elsewhere in the scene must not admit a passive body.
-    for jets in ([], [Jet(Sector(CENTER, 0., .6, 3.), Radial(CENTER))]):
-        field, bodies = jet_case(device, jets)
-        passive = bodies.add(circle(center=(2., 3.), radius=.6))
-        bodies.sync_to_gpu(field)
-        sim.bodies, sim.field = bodies, field
-        with pytest.raises(ValueError, match="Body has no surface actuation"):
-            Simulation.read_surface_exchange(sim, passive)
-        if not jets:
-            with pytest.raises(ValueError, match="Body has no surface actuation"):
-                Simulation.read_surface_exchange(sim, 0)
-
-
 def test_manager_passes_true_hits_and_reuploads_only_velocity(device):
     # CPU memory double only: checks host/device bookkeeping, not GPU numerics.
     jet = Jet(Sector(CENTER, 0., .6, 3.), Radial(CENTER, inward=False), "quartic", 2e-3)

tests/unit/test_refined_dfg.py

@@ -146,26 +146,23 @@ def test_full_requires_completed_pilot():
         r.verify_pilot(None, r.verify_source(r.DEFAULT_SOURCE, "MRT", "window"))
 
 
-def pilot_fixture(path, observation_mode="window", jet_scenario="none", case_selection="both", uniform_diameter=80, placement="wide"):
+def pilot_fixture(path, observation_mode="window"):
     """Synthetic contract fixture only; never a physical result or run receipt."""
-    manifest = (r.verify_source(r.DEFAULT_SOURCE, "MRT", "window", jet_scenario)
+    manifest = (r.verify_source(r.DEFAULT_SOURCE, "MRT", "window")
                 if observation_mode == "window" else
                 json.loads((r.HERE / "data/refined_dfg/source_manifest_mrt.json").read_text()))
-    selection = dict(case_selection=case_selection, uniform_diameter=uniform_diameter, placement=placement)
     (path / "plan.json").write_text(
         json.dumps(
             dict(
                 source_manifest=manifest,
-                **selection,
                 collision="MRT",
-                jet_scenario=jet_scenario,
                 observation_mode=observation_mode,
-                bounds_root_edge=list(r.PLACEMENTS[placement]),
+                bounds_root_edge=list(r.BOUNDS),
                 runner_sha256=r.runner_hash(),
             )
         )
     )
-    for case, diameter in r.selected_cases(case_selection, uniform_diameter):
+    for case, diameter in (("uniform", 80), ("refined", 40)):
         dest = path / case
         dest.mkdir()
         interval = round(0.02 * diameter / r.SPEED)
@@ -192,9 +189,7 @@ def pilot_fixture(path, observation_mode="window", jet_scenario="none", case_sel
             json.dumps(
                 dict(
                     case=case,
-                    **selection,
                     collision="MRT",
-                    jet_scenario=jet_scenario,
                     observation_mode=observation_mode,
                     mode="pilot",
                     status="pilot_complete",
@@ -211,9 +206,7 @@ def pilot_fixture(path, observation_mode="window", jet_scenario="none", case_sel
             json.dumps(
                 dict(
                     case=case,
-                    **selection,
                     collision="MRT",
-                    jet_scenario=jet_scenario,
                     observation_mode=observation_mode,
                     mode="pilot",
                     step=interval,
@@ -458,169 +451,6 @@ def test_window_contract_rejection():
     assert not backend.events
 
 
-def test_public_jet_configuration_and_geometry():
-    for diameter, center, radius in ((40, (80.5, 81), 20), (80, (160, 160.5), 40)):
-        cfg, _, _ = r.config(h, diameter, "MRT", "fixed")
-        assert not cfg["method"]["ddf_shifting"] and not cfg["method"]["les"]["enabled"]
-        jets = r.public_jets(center, radius, "fixed")
-        assert [j.amplitude for j in jets] == [.001, -.001]
-        assert all(j.field.inward is False and j.profile == "parabolic" for j in jets)
-        assert all(j.region.r_max == radius * 1.005 for j in jets)
-        assert all(j.amplitude == 0 for j in r.public_jets(center, radius, "zero"))
-    cfg, _, _, host = r.host_geometry(r.DEFAULT_SOURCE, h, "MRT", "fixed")
-    assert not cfg.ddf_shifting and len(host.boundary_cells) > 0
-    assert r.public_jets((0, 0), 1, "none") == ()
-    with unittest.TestCase().assertRaises(ValueError):
-        r.config(h, 40, "SRT", "fixed")
-
-
-def test_public_jet_reversal_boundary_and_windows():
-    from types import SimpleNamespace
-
-    calls = []
-    handle = SimpleNamespace(set_jet_amplitude=lambda i, a: calls.append((i, a)))
-    for diameter in (40, 80):
-        boundary = round(250 * diameter / r.SPEED)
-        assert r.jet_interval(handle, "fixed", boundary - 3, 80, diameter) == (3, None)
-        switch = round(300 * diameter / r.SPEED)
-        assert r.jet_interval(handle, "reverse", switch - 3, 80, diameter) == (3, None)
-        assert not calls
-        n, event = r.jet_interval(handle, "reverse", switch, 80, diameter)
-        assert n == 80 and event["step"] == switch and event["tstar"] == 300
-        assert calls == [(0, -.001), (1, .001)]
-        calls.clear()
-        assert r.jet_interval(handle, "reverse", switch + 80, 80, diameter) == (80, None)
-        assert r.jet_interval(handle, "fixed", switch, 80, diameter) == (80, None)
-        assert not calls
-    rows = [dict(tstar=t, tstar_force=t - .5, cd=2.0, cl=-.1) for t in range(251, 306)]
-    windows = r.jet_diagnostics(rows, "reverse")
-    assert len(windows) == 6 and all(w["complete"] for w in windows)
-    assert all(w["cd"]["mean"] == 2 and np.isclose(w["cl"]["mean"], -.1) for w in windows)
-    assert windows[-1]["covered_tstar"] == 5
-    with unittest.TestCase().assertRaisesRegex(ValueError, "crosses"):
-        r.jet_diagnostics([dict(tstar=250.5, tstar_force=250, cd=1, cl=0)], "fixed")
-    assert r.plan(h, "MRT", "window", "reverse")["modes"]["full_tstar"] == 305
-
-
-def test_public_jet_source_and_pilot_separation():
-    from tempfile import TemporaryDirectory
-
-    with TemporaryDirectory() as tmp:
-        path = Path(tmp)
-        manifest = pilot_fixture(path, jet_scenario="fixed")
-        assert manifest["source_capture"].startswith("current checkout")
-        assert len(manifest["checkout_revision"]) == 40
-        assert r.verify_pilot(path, manifest, "MRT", "window", "fixed") == 3606.0
-        for scenario in ("none", "zero", "reverse"):
-            with unittest.TestCase().assertRaisesRegex(ValueError, "Jet scenario"):
-                r.verify_pilot(path, manifest, "MRT", "window", scenario)
-        for relative in ("uniform/summary.json", "refined/ready.json"):
-            receipt = path / relative
-            record = json.loads(receipt.read_text())
-            receipt.write_text(json.dumps(dict(record, jet_scenario="zero")))
-            with unittest.TestCase().assertRaises(ValueError):
-                r.verify_pilot(path, manifest, "MRT", "window", "fixed")
-            receipt.write_text(json.dumps(record))
-    with unittest.TestCase().assertRaises(ValueError):
-        r.verify_source(r.DEFAULT_SOURCE, "MRT", "last_base_step", "fixed")
-
-
-def test_cv_snapshot_common_units_and_window_endpoints():
-    records = []
-    for refined, shape, origin, diameter, impulse in (
-        (True, (240, 568), (38., 22.), 40, [4., -8.]),
-        (False, (330, 1761), (.25, .5), 80, [16., -32.]),
-        (False, (658, 3521), (.375, .75), 160, [64., -128.]),
-    ):
-        rho, ux, uy, fluid = np.ones(shape), np.full(shape, .01), np.zeros(shape), np.ones(shape, bool)
-        begin, n = round(290*diameter/r.SPEED), round(.02*diameter/r.SPEED)
-        record = r.cv_snapshot(rho, ux, uy, fluid, origin, refined, begin, n, diameter, impulse)
-        records.append(record)
-        np.testing.assert_allclose(record["outward_flux"], 0, atol=1e-12)
-        assert r.cv_selected(begin, diameter, "full") and not r.cv_selected(begin-n, diameter, "full")
-        end = round(300*diameter/r.SPEED)
-        assert r.cv_selected(end, diameter, "full") and not r.cv_selected(end+n, diameter, "full")
-        assert r.cv_selected(n, diameter, "pilot")
-        assert sum(r.cv_selected(step, diameter, "full") for step in range(begin-n, end+n+1, n)) == 501
-    for key in ("time_root", "interval_start_root", "interval_dt_root", "interval_impulse_root", "inventory"):
-        for record in records[1:]:
-            np.testing.assert_allclose(records[0][key], record[key], rtol=0, atol=1e-10)
-    assert records[0]["interval_dt_root"] == 80 and np.isclose(records[0]["tstar"], 290.02)
-    np.testing.assert_array_equal(records[0]["interval_impulse_root"], [4, -8])
-
-
-def test_cv_pilot_mode_and_helper_provenance():
-    from tempfile import TemporaryDirectory
-
-    manifest = r.verify_source(r.DEFAULT_SOURCE, "MRT", "window", "fixed", True)
-    assert "tests/validation/run_jet_circle_cv.py" in manifest["sha256"]
-    with TemporaryDirectory() as tmp:
-        path = Path(tmp)
-        old = pilot_fixture(path, jet_scenario="fixed")
-        with unittest.TestCase().assertRaisesRegex(ValueError, "CV observation mode"):
-            r.verify_pilot(path, old, "MRT", "window", "fixed", True)
-        for relative in ("plan.json", "uniform/summary.json", "refined/summary.json",
-                         "uniform/ready.json", "refined/ready.json"):
-            file = path / relative
-            record = json.loads(file.read_text())
-            record.update(observe_cv=True, cv_samples=250)
-            if relative == "plan.json":
-                record["source_manifest"] = manifest
-            file.write_text(json.dumps(record))
-        assert r.verify_pilot(path, manifest, "MRT", "window", "fixed", True) == 3606
-
-
-def test_compact_geometry_and_cv_stencils():
-    from CelerisLab.lbm.refinement import ACTIVE
-    from CelerisLab.lbm.descriptors import SOLID
-
-    _, pair, _, host = r.host_geometry(r.DEFAULT_SOURCE, h, "MRT", "fixed", "compact")
-    assert pair.fine_shape == (168, 168) and tuple(pair.fine_origin) == (46, 46)
-    fluid = (pair.fine_kind == ACTIVE) & ((host.flags.reshape(pair.fine_shape) & SOLID) == 0)
-    rho, ux, uy = np.ones(pair.fine_shape), np.full(pair.fine_shape, .01), np.zeros(pair.fine_shape)
-    record = r.cv_snapshot(rho, ux, uy, fluid, pair.fine_origin, True, 1160000, 80, 40, [1, 2], "compact")
-    np.testing.assert_allclose(record["outward_flux"], 0, atol=1e-12)
-    stencil = np.zeros(pair.fine_shape, bool)
-    for rect in r.cv_contours(True, 40, "compact"):
-        x0, y0, x1, y1 = np.rint((rect - np.tile(pair.fine_origin, 2))/.5).astype(int)
-        stencil[y0-2:y1+2, x0-2:x0+2] = stencil[y0-2:y1+2, x1-2:x1+2] = True
-        stencil[y0-2:y0+2, x0-2:x1+2] = stencil[y1-2:y1+2, x0-2:x1+2] = True
-    assert fluid[stencil].all() and not stencil.ravel()[host.transfer_fine_cells].any()
-
-
-def test_d160_config_and_single_case_receipts():
-    from tempfile import TemporaryDirectory
-    from unittest.mock import patch
-
-    cfg, _, p = r.config(h, 160, "MRT", "fixed")
-    assert (p["nx"], p["ny"], p["center"], p["radius"]) == (3521, 658, [320, 320.5], 80)
-    assert p["viscosity"] == .016 and p["mean_speed"] == .01 and not cfg["method"]["ddf_shifting"]
-    assert r.uniform_origin(160) == (.375, .75)
-    np.testing.assert_array_equal(r.cv_contours(False, 160), r.CV_CONTOURS + [.125, 0, .125, 0])
-    for scenario, expected_exit in (("fixed", 0), ("zero", 2)):
-        with TemporaryDirectory() as tmp:
-            path = Path(tmp)
-            manifest = pilot_fixture(path, jet_scenario=scenario, case_selection="uniform", uniform_diameter=160)
-            assert r.verify_pilot(path, manifest, "MRT", "window", scenario, False, "uniform", 160) == 1803
-            for selection, diameter, placement in (("both", 160, "wide"), ("uniform", 80, "wide"), ("uniform", 160, "compact")):
-                with unittest.TestCase().assertRaises(ValueError):
-                    r.verify_pilot(path, manifest, "MRT", "window", scenario, False, selection, diameter, placement)
-            # Synthetic dispatch/result check: no CUDA imports or execution.
-            output = path / "full"
-            argv = ["runner", "--collision", "MRT", "--exchange-window", "--jet-scenario", scenario,
-                    "--case", "uniform", "--uniform-diameter", "160", "--mode", "full",
-                    "--pilot-results", str(path), "--output", str(output), "--max-wall-seconds", "10", "--gpu-gates-approved"]
-            result = dict(case="uniform", healthy=True, periodic=scenario == "zero", jet_diagnostic_windows=[],
-                          status="driven_diagnostics_complete" if scenario == "fixed" else "periodic",
-                          reference_comparison=dict(reference_agreement=False))
-            with patch.object(sys, "argv", argv), patch.dict(r.os.environ, CUDA_VISIBLE_DEVICES="mock-no-gpu"), \
-                    patch.object(r, "run_case", return_value=result) as run:
-                assert r.main() == expected_exit and run.call_count == 1
-            comparison = json.loads((output / "comparison.json").read_text())
-            assert comparison["matched_case_pass"] is False and "refined_vs_uniform" not in comparison
-            assert comparison["status"].startswith("single_case_")
-
-
 if __name__ == "__main__":
     suite = unittest.TestSuite(
         unittest.FunctionTestCase(fn)

tests/unit/test_state_regressions.py

@@ -238,81 +238,6 @@ def test_overlapping_force_regions_rejected(device):
         bodies.build_compact_lists(bodies.build_flags(field.flag))
 
 
-@pytest.mark.parametrize("second_x,error", [(14., "unique cut-link writers"),
-                                           (17., "active fluid receivers")])
-def test_passive_overlap_rejected_before_publishing_lists(second_x, error):
-    cfg = LBMConfig(nx=32, ny=24)
-    cfg.validate()
-    bodies = ObjectManager(cfg.nx, cfg.ny, cfg.nz, cfg.nq, cfg)
-    for x in (14., second_x):
-        bodies.add(obj(x=x, y=12., r=4.3))
-    bodies.add(obj(x=4., y=4., r=2., is_sensor=True))
-    counts = np.full(bodies.count, 91, np.int32)
-    hits = []
-    flags = bodies.build_flags(np.full(cfg.nx * cfg.ny, FLUID, np.uint16))
-    for domain_flags in (flags, None):
-        with pytest.raises(ValueError, match=error):
-            bodies.build_compact_lists_for(bodies.objects, domain_flags,
-                                          sensor_cell_counts_out=counts, hits_out=hits)
-        np.testing.assert_array_equal(counts, 91)
-        assert hits == []
-
-
-@pytest.mark.parametrize("centers", [((10., 12.), (22., 12.)),
-                                    ((10.5, 12.), (19.5, 12.))])
-def test_separated_passive_bodies_keep_valid_writers(centers):
-    # The second case has a subcell physical gap with a resolved fluid column.
-    cfg = LBMConfig(nx=32, ny=24)
-    cfg.validate()
-    bodies = ObjectManager(cfg.nx, cfg.ny, cfg.nz, cfg.nq, cfg)
-    for x, y in centers:
-        bodies.add(obj(x=x, y=y, r=4.3))
-    flags = bodies.build_flags(np.full(cfg.nx * cfg.ny, FLUID, np.uint16))
-    indices, directions, _, ids, *_ = bodies.build_compact_lists(flags)
-    assert set(ids) == {0, 1}
-    assert np.all(flags[indices] & FLUID) and not np.any(flags[indices] & SOLID)
-    assert len(np.unique(indices.astype(np.uint64) * cfg.nq + directions)) == len(indices)
-
-
-@pytest.mark.parametrize("entry", ["sync", "initialize", "runtime_edit"])
-@pytest.mark.parametrize("second_x", [5., 6.])
-def test_passive_overlap_failure_keeps_live_state(device, entry, second_x):
-    from CelerisLab.simulation import Simulation
-    field = make_field(device)
-    bodies = manager(field, [obj(), obj(x=9., y=3., r=1., is_sensor=True)])
-    bodies.sync_to_gpu(field)
-    overlapping = obj(x=second_x)
-    if entry == "runtime_edit":
-        bodies.stage_add(overlapping)
-    else:
-        bodies.add(overlapping)
-    objects = bodies.objects
-    flags, curved, counts = field.flag.copy(), field.curved.fluid_idx.copy(), bodies.sensor_cell_counts.copy()
-    action = bodies.action.copy()
-    buffers = [(block, bytes(block.data), block.freed) for block in device.blocks]
-    writes = device.writes
-    sim = SimpleNamespace(bodies=bodies, field=field, lbm_cfg=field.cfg,
-                          _initialized=entry == "runtime_edit",
-                          _assert_allocation_contract=lambda: None,
-                          stream=SimpleNamespace(synchronize=device.synchronize))
-    with pytest.raises(ValueError, match="active fluid receivers|unique cut-link writers"):
-        if entry == "sync":
-            bodies.sync_to_gpu(field)
-        elif entry == "initialize":
-            Simulation.initialize(sim)
-        else:
-            Simulation.sync_bodies(sim)
-    assert bodies.objects == objects
-    assert bodies.has_pending_edit() == (entry == "runtime_edit")
-    assert sim._initialized == (entry == "runtime_edit")
-    assert device.writes == writes and len(device.blocks) == len(buffers)
-    assert all(bytes(block.data) == data and block.freed == freed for block, data, freed in buffers)
-    np.testing.assert_array_equal(field.flag, flags)
-    np.testing.assert_array_equal(field.curved.fluid_idx, curved)
-    np.testing.assert_array_equal(bodies.sensor_cell_counts, counts)
-    np.testing.assert_array_equal(bodies.action, action)
-
-
 def test_action_upload_and_scratch_are_pinned(device):
     field = make_field(device, streaming="esopull")
     bodies = manager(field, [obj(is_force_region=True)])

tests/validation/annulus_ledger.py

@@ -1,75 +0,0 @@
-"""Per-hop mass ledger of a fluid cell set A (host-only, stdlib, D2Q9 pull scheme).
-
-Diagnostic definition only; no solver code, no GPU. Arrays are indexed [q][y][x] on a
-periodic nx x ny lattice; A is a set of (x, y) ACTIVE cells.
-
-  O  owner populations before any staging (canonical owner slots, start of the hop)
-  P  populations each cell actually pulls: P[q](x) is what x reads for direction q
-     (after halo copy, BFL/coalesce staging, ...)
-  D  populations written by the cell after collision
-
-With M0 = sum_{A,q} O and M1 = sum_{A,q} D (both owner snapshots of A):
-
-  M1 - M0 + Q_exact = C + H                                            (exact)
-
-  C       = sum_{x in A, q} (D_q(x) - P_q(x))              collision source
-  H       = sum_{x in A, q} (P_q(x) - O_q(x - c_q))        actual minus ideal owner input,
-            split into H_seam (x - c_q in A: internal pulls, e.g. tile seams) and
-            H_edge (x - c_q not in A: inputs crossing the edge of A)
-  Q_exact = sum_{y in A, y+c_q not in A} O_q(y) - sum_{y not in A, y+c_q in A} O_q(y)
-            owner-based net outward flux (outgoing minus incoming)
-
-Proof: sum_{A,q} O_q(x - c_q) - M0 = -Q_exact (relabel y = x - c_q per direction), and
-sum_{A,q} D = C + H + sum_{A,q} O_q(x - c_q). Q_exact must use O, not staged values: a
-flux built from staged inputs already contains H_edge, so adding the full H counts it
-twice (see staged_flux). The edge of A must not cross cut links, otherwise O at the solid
-end enters Q_exact.
-"""
-
-CX = (0, 1, -1, 0, 0, 1, -1, 1, -1)
-CY = (0, 0, 0, 1, -1, 1, -1, -1, 1)
-
-
-def _src(x, y, q, nx, ny):
-    return (x - CX[q]) % nx, (y - CY[q]) % ny
-
-
-def pull(O, nx, ny):
-    """Ideal pulled input: P[q](x) = O[q](x - c_q)."""
-    return [[[O[q][_src(x, y, q, nx, ny)[1]][_src(x, y, q, nx, ny)[0]]
-              for x in range(nx)] for y in range(ny)] for q in range(9)]
-
-
-def ledger(O, P, D, A, nx, ny):
-    A = set(A)
-    out = dict(dM=0.0, C=0.0, H_seam=0.0, H_edge=0.0, Q_exact=0.0)
-    for (x, y) in A:
-        for q in range(9):
-            out["dM"] += D[q][y][x] - O[q][y][x]
-            out["C"] += D[q][y][x] - P[q][y][x]
-            sx, sy = _src(x, y, q, nx, ny)
-            key = "H_seam" if (sx, sy) in A else "H_edge"
-            out[key] += P[q][y][x] - O[q][sy][sx]
-            if (sx, sy) not in A:
-                out["Q_exact"] -= O[q][sy][sx]          # incoming owner population
-            tx, ty = (x + CX[q]) % nx, (y + CY[q]) % ny
-            if (tx, ty) not in A:
-                out["Q_exact"] += O[q][y][x]            # outgoing owner population
-    out["H"] = out["H_seam"] + out["H_edge"]
-    out["residual"] = out["dM"] + out["Q_exact"] - out["C"] - out["H"]
-    return out
-
-
-def staged_flux(O, P, A, nx, ny):
-    """Outward flux with incoming terms from the staged inputs P (the wrong combination)."""
-    A = set(A)
-    q_out = 0.0
-    for (x, y) in A:
-        for q in range(9):
-            sx, sy = _src(x, y, q, nx, ny)
-            if (sx, sy) not in A:
-                q_out -= P[q][y][x]
-            tx, ty = (x + CX[q]) % nx, (y + CY[q]) % ny
-            if (tx, ty) not in A:
-                q_out += O[q][y][x]
-    return q_out

tests/validation/multigrid/test_refinement_three_level.py

@@ -80,12 +80,11 @@ class ThreeLevelCPU(unittest.TestCase):
         f, g = run._levels[1:]
         b = g.boundary
         events, feeds = [], []
-        advance, gather = run._advance, run._gather_halo
-        def record_feed(index, buffer, **kw):  # index 2: L1 hop feeds L2
-            if index == 2:
-                self.assertIs(buffer, (f.current, f.spare)[len(feeds)])
-                feeds.append(buffer)
-            advance(index, buffer, **kw)
+        advance, gather = run._advance_child, run._gather_halo
+        def record_feed(buffer, **kw):
+            self.assertIs(buffer, (f.current, f.spare)[len(feeds)])
+            feeds.append(buffer)
+            advance(buffer, **kw)
         def record_halo(level, buffer, **kw):
             if level is g:
                 events.append(("halo", buffer))
@@ -96,7 +95,7 @@ class ThreeLevelCPU(unittest.TestCase):
             self.assertIs(kind, g.kind)
             events.append(("step", src))
         g.kernel.side_effect = record_step
-        with patch.object(run, "_advance", side_effect=record_feed), \
+        with patch.object(run, "_advance_child", side_effect=record_feed), \
                 patch.object(run, "_gather_halo", side_effect=record_halo):
             run.step()
         self.assertEqual(feeds, [f.current, f.spare])
@@ -106,8 +105,8 @@ class ThreeLevelCPU(unittest.TestCase):
         self.assertGreater(len(np.unique(b.tables["block"])), 1)
         # Negative control: reusing L1's old source at the midpoint must fail.
         feeds.clear()
-        with patch.object(run, "_advance", side_effect=lambda index, buffer, **kw:
-                          record_feed(index, f.current if index == 2 else buffer, **kw)):
+        with patch.object(run, "_advance_child", side_effect=lambda buffer, **kw:
+                          record_feed(f.current, **kw)):
             with self.assertRaises(AssertionError):
                 run.step()
         run.close()
@@ -173,12 +172,11 @@ class ThreeLevelGPU(unittest.TestCase):
             p1, p2 = run.patch, run.child_patch
             run.initialize(state(16, 16, 1), state(*p1.fine_shape, 2), state(*p2.fine_shape, 3))
             f = run._levels[1]
-            feeds, original = [], run._advance
-            def record(index, buffer, **kw):  # index 2: L1 hop feeds L2
-                if index == 2:
-                    feeds.append(int(buffer))
-                original(index, buffer, **kw)
-            with patch.object(run, "_advance", side_effect=record):
+            feeds, original = [], run._advance_child
+            def record(buffer, **kw):
+                feeds.append(int(buffer))
+                original(buffer, **kw)
+            with patch.object(run, "_advance_child", side_effect=record):
                 cur, spare = int(f.current), int(f.spare)
                 run.step(1)
             self.assertEqual(feeds, [cur, spare])  # current G, then the new G of hop 1

tests/validation/run_dfg_re20.py

@@ -1,222 +0,0 @@
-"""Steady DFG 2D-1 (Re 20): refined and uniform runs against the official reference intervals.
-
-Not a full benchmark certification. Declared deviations from the official setup:
-pressure-NEQ outlet (``neq_extrap``) instead of do-nothing, local Zou-He inlet.
-Geometry, inflow profile, initial state, refined layout and observation reuse the
-pinned Re100 runner (``run_refined_dfg``) and ``re100_helpers`` unchanged; only the
-lattice viscosity is set for Re 20 (nu = U_lattice * D / 20 at the root level).
-
-Units. The helpers use scaled DFG units with mean inflow speed 1, so
-Cd = 2 Fx / (rho U^2 D) and Cl = 2 Fy / (rho U^2 D) are scale-free, and
-``pressure_probes`` returns dp / (rho U^2). The official p_diff = p(0.15, 0.2) -
-p(0.25, 0.2) uses U = 0.2 m/s, rho = 1, so p_diff = dp * 0.04. Both are reported;
-only p_diff is compared with the official interval. Forces use the existing sign
-convention: F is the force of the fluid on the cylinder, i.e. the refined raw
-exchange impulse (window ledger, ``total.impulse``) or the uniform ``read_force``,
-with x along the inflow and y up from the bottom wall. Cd must be positive, and the
-official Cl is positive (centre 0.20 below the centreline 0.205), so a flipped sign
-shows up as Cl outside its interval.
-
-Sampling. One sample every SAMPLE_TSTAR (t* = U t / D; 0.25 s), taken at the end of
-a completed root step with all levels synchronized; the step index is recorded. Cd
-and Cl are means over the sample interval (window exchange ledger refined, per-batch
-forces uniform), which filters acoustic and step-parity oscillation; p_diff is the
-end-of-interval value at the exact surface points.
-
-Steady rule (our engineering choice, frozen before any run; not official). Over the
-trailing WINDOW_TSTAR (t* 50..60 inclusive, 21 samples), for each of Cd, Cl and
-p_diff: range (max - min) <= 10 % and |least-squares slope * window| <= 2 % of the
-width of its official interval. Absolute limits, so the small Cl is never a divisor;
-the slope term bounds slow monotone drift that the range alone would pass. If the
-rule fails at TSTAR_MAX the run reports "not steady" and gives no interval verdict;
-limits are never relaxed after a run. The verdict uses the window mean, and the
-distance of each mean to its nearest interval edge is reported (negative outside).
-"""
-
-import argparse
-import json
-import math
-import os
-from pathlib import Path
-import sys
-import time
-from tempfile import TemporaryDirectory
-
-import numpy as np
-
-HERE = Path(__file__).resolve().parent
-sys.path.insert(0, str(HERE))
-import run_refined_dfg as rr  # noqa: E402
-
-RE = 20.0
-U_PHYS = 0.2                   # m/s mean inflow; rho = 1
-TSTAR_MAX = 60.0               # 30 s physical
-SAMPLE_TSTAR = 0.5             # 0.25 s
-WINDOW_TSTAR = 10.0            # trailing 5 s, 21 samples
-# Schaefer & Turek (1996), 2D-1 lower/upper bounds.
-BANDS = dict(cd=(5.57, 5.59), cl=(0.0104, 0.0110), p_diff=(0.1172, 0.1176))
-STEADY_RANGE = {k: (hi - lo) / 10 for k, (lo, hi) in BANDS.items()}
-STEADY_SLOPE = {k: (hi - lo) / 50 for k, (lo, hi) in BANDS.items()}
-DEVIATIONS = ("pressure-NEQ outlet (neq_extrap), not do-nothing", "local Zou-He inlet")
-
-_re100_config = rr.config
-
-
-def config(h, diameter, collision="SRT", jet_scenario="none"):
-    """The pinned Re100 configuration with the lattice viscosity set for Re 20."""
-    if jet_scenario != "none":
-        raise ValueError("DFG 2D-1 runs have no Jets")
-    cfg, body, p = _re100_config(h, diameter, collision, jet_scenario)
-    nu = p["mean_speed"] * p["diameter"] / RE
-    cfg["physics"]["viscosity"] = nu
-    return cfg, body, dict(p, viscosity=nu, re=RE)
-
-
-def lattice_parameters(diameter, speed=rr.SPEED):
-    nu = speed * diameter / RE
-    return dict(viscosity=nu, tau=0.5 + 3 * nu, steps=math.ceil(TSTAR_MAX * diameter / speed),
-                interval=round(SAMPLE_TSTAR * diameter / speed))
-
-
-def sample(impulse, n, diameter, dp):
-    den = rr.SPEED**2 * diameter / 2
-    return dict(cd=float(impulse[0] / n / den), cl=float(impulse[1] / n / den),
-                dp_scaled=float(dp), p_diff=float(dp) * U_PHYS**2)
-
-
-def summarize(rows):
-    """Steady rule over the trailing window, then the interval verdict (or none)."""
-    if not rows or rows[-1]["tstar"] < TSTAR_MAX - 1e-9:
-        return dict(status="INCOMPLETE", steady=False, verdict=None)
-    window = [r for r in rows if r["tstar"] >= TSTAR_MAX - WINDOW_TSTAR - 1e-9]
-    t = np.array([r["tstar"] for r in window])
-    ranges = {k: max(r[k] for r in window) - min(r[k] for r in window) for k in BANDS}
-    drifts = {k: abs(np.polyfit(t, [r[k] for r in window], 1)[0]) * WINDOW_TSTAR for k in BANDS}
-    steady = all(ranges[k] <= STEADY_RANGE[k] and drifts[k] <= STEADY_SLOPE[k] for k in BANDS)
-    final = {k: float(np.mean([r[k] for r in window])) for k in BANDS}
-    edge = {k: min(final[k] - BANDS[k][0], BANDS[k][1] - final[k]) for k in BANDS}
-    result = dict(window_samples=len(window), ranges=ranges, drifts=drifts,
-                  range_limits=STEADY_RANGE, slope_limits=STEADY_SLOPE, steady=steady,
-                  window_mean=final, edge_distance=edge, bands=BANDS,
-                  deviations=DEVIATIONS, cd_positive=final["cd"] > 0)
-    if not steady:
-        return dict(result, status="NOT_STEADY", verdict=None)
-    inside = {k: BANDS[k][0] <= final[k] <= BANDS[k][1] for k in BANDS}
-    return dict(result, status="WITHIN_INTERVALS" if all(inside.values()) else "OUTSIDE_INTERVALS",
-                verdict=inside)
-
-
-def healthy(row):
-    return row["max_mach"] <= 0.2 and row["rho_min"] >= 0.5 and row["rho_max"] <= 1.5
-
-
-def run_case(a, h, case):
-    from contextlib import ExitStack
-    from CelerisLab.cuda.context import CudaContext
-    from CelerisLab.lbm.descriptors import FLUID
-    from CelerisLab.lbm.refinement_stepper import FixedPatchStepper
-    from CelerisLab.simulation import Simulation
-
-    refined = case == "refined"
-    cfgdict, bodydict, p = config(h, 40 if refined else 80, a.collision)
-    lp = lattice_parameters(p["diameter"])
-    rows = []
-    with ExitStack() as stack:
-        if refined:
-            cfg, pair, body, host = rr.host_geometry(a.source, h, a.collision)
-            context = stack.enter_context(CudaContext(0))
-            backend = stack.enter_context(FixedPatchStepper(
-                cfg, rr.PLACEMENTS["wide"], context=context, coarse_boundary="channel",
-                base_block=rr.BASE_BLOCK, fine_block=rr.FINE_BLOCK, fine_objects=(body,),
-                observe_raw_exchange=True, observe_window_exchange=True))
-            from CelerisLab.lbm.channel import channel_masks
-            from CelerisLab.lbm.refinement import ACTIVE
-            from CelerisLab.lbm.descriptors import SOLID
-            masks = [channel_masks(pair.coarse_shape)[0] & ~pair.covered,
-                     (pair.fine_kind == ACTIVE)
-                     & ((host.flags.reshape(pair.fine_shape) & SOLID) == 0)]
-            backend.initialize(rr.initial_state(pair.coarse_shape, (0.0, 0.0), 1.0, root=True),
-                               rr.initial_state(pair.fine_shape, pair.fine_origin, 0.5))
-            probe_p = dict(p, center=[(80.5 - pair.fine_origin[0]) / 0.5 - 0.5,
-                                      (81.0 - pair.fine_origin[1]) / 0.5 - 0.5], radius=40.0)
-        else:
-            tmp = Path(stack.enter_context(TemporaryDirectory()))
-            (tmp / "lbm.json").write_text(json.dumps(cfgdict))
-            (tmp / "body.json").write_text(json.dumps(bodydict))
-            sim = stack.enter_context(Simulation(str(tmp / "lbm.json"), str(tmp / "body.json"),
-                                                 device_id=0))
-            sim.initialize()
-            probe_p = p
-            fluid = (sim.field.flag.reshape(p["ny"], p["nx"]) & FLUID) != 0
-        begin = 0
-        while begin < lp["steps"]:
-            rr.check_deadline(a.deadline)
-            n = min(lp["interval"], lp["steps"] - begin)
-            if refined:
-                impulse = rr.advance_refined_interval(backend, n, a.deadline, "window")
-                fields = [rr.macros(g) for g in backend.download()]
-                rho, ux, uy = fields[1]
-                fluid = masks[1]
-                vals = [tuple(v[m] for v in f) for m, f in zip(masks, fields)]
-            else:
-                impulse, done = np.zeros(2), 0
-                while done < n:
-                    batch = min(100, n - done)
-                    sim.run(batch)
-                    impulse += sim.read_force(0).astype(np.float64) * batch
-                    done += batch
-                m = sim.get_macroscopic()
-                rho, ux, uy = [np.asarray(m[k], np.float64).reshape(p["ny"], p["nx"])
-                               for k in ("rho", "ux", "uy")]
-                vals = [(rho[fluid], ux[fluid], uy[fluid])]
-            begin += n
-            row = dict(step=begin, tstar=begin * rr.SPEED / p["diameter"],
-                       **sample(impulse, n, p["diameter"],
-                                h.pressure_probes(rho, fluid, probe_p)["dp"]),
-                       rho_min=float(min(v[0].min() for v in vals)),
-                       rho_max=float(max(v[0].max() for v in vals)),
-                       max_mach=float(max(np.sqrt(3 * (v[1]**2 + v[2]**2)).max() for v in vals)))
-            rr.ensure_finite(row)
-            rows.append(row)
-            if not healthy(row):
-                break
-    summary = summarize(rows) if healthy(rows[-1]) else dict(status="UNHEALTHY", steady=False,
-                                                             verdict=None)
-    return dict(case=case, collision=a.collision, lattice=lp, rows=rows, **summary)
-
-
-def plan(collision="SRT"):
-    return dict(re=RE, collision=collision, tstar_max=TSTAR_MAX, sample_tstar=SAMPLE_TSTAR,
-                window_tstar=WINDOW_TSTAR, bands=BANDS, range_limits=STEADY_RANGE, slope_limits=STEADY_SLOPE,
-                deviations=DEVIATIONS, pressure_scale=U_PHYS**2,
-                refined_root=lattice_parameters(40), refined_fine_tau=0.5 + 3 * 2 * rr.SPEED * 40 / RE,
-                uniform=lattice_parameters(80),
-                label="compared against the official reference bands (non-canonical neq_extrap outlet, zou_he_local inlet); not a full benchmark certification")
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
-    parser.add_argument("--case", choices=["refined", "uniform", "both"], default="refined")
-    parser.add_argument("--collision", choices=["SRT", "MRT"], default="SRT")
-    parser.add_argument("--source", type=Path, default=rr.DEFAULT_SOURCE)
-    parser.add_argument("--output", type=Path, required=True)
-    parser.add_argument("--plan", action="store_true", help="Write the frozen plan; no CUDA")
-    parser.add_argument("--max-wall-seconds", type=float)
-    a = parser.parse_args()
-    a.source = a.source.resolve()
-    a.output.mkdir(parents=True, exist_ok=False)
-    (a.output / "plan.json").write_text(json.dumps(plan(a.collision), indent=2, allow_nan=False))
-    if a.plan:
-        return
-    if not a.max_wall_seconds or a.max_wall_seconds <= 0 or not os.environ.get("CUDA_VISIBLE_DEVICES"):
-        raise SystemExit("GPU run needs --max-wall-seconds > 0 and explicit CUDA_VISIBLE_DEVICES")
-    h, _ = rr.helpers(a.source)
-    rr.config = config  # host_geometry builds its root configuration through this name
-    a.deadline = time.monotonic() + a.max_wall_seconds
-    cases = ["refined", "uniform"] if a.case == "both" else [a.case]
-    results = [run_case(a, h, case) for case in cases]
-    (a.output / "result.json").write_text(json.dumps(results, indent=2, allow_nan=False))
-
-
-if __name__ == "__main__":
-    main()

tests/validation/run_jet_circle_cv.py

@@ -74,25 +74,7 @@ def cv(g, fluid, origin, rectangle, nu, h=0.5):
     Cauchy stress from centred velocity gradients, NOT postcollision non-equilibrium.
     Rectangle faces lie on cell edges; fluid mask excludes the staircase cylinder.
     """
-    return _cv_quantities(*moments(g), fluid, origin, rectangle, nu, h)
-
-
-def cv_from_macros(rho, ux, uy, fluid, origin, rectangle, nu, h=0.5):
-    """Same CV calculation from public macros, in one common length/time frame.
-
-    ``origin`` is the lower cell edge, ``h`` the cell width, and ``nu`` uses
-    that frame. Returns [mass, Px, Py] inventory and outward total flux.
-    Crop fields/mask together and translate origin before calling if desired.
-    No boundary-exchange observation enters this independent estimator.
-    """
-    rho = np.asarray(rho, np.float64)
-    if rho.ndim != 2 or any(np.shape(v) != rho.shape for v in (ux, uy, fluid)):
-        raise ValueError("CV macros and fluid mask must have matching 2D shapes")
-    vel = np.asarray([ux, uy], np.float64)
-    return _cv_quantities(rho, rho[None] * vel, vel, fluid, origin, rectangle, nu, h)
-
-
-def _cv_quantities(rho, mom, vel, fluid, origin, rectangle, nu, h):
+    rho, mom, vel = moments(g)
     x0, y0, x1, y1 = np.rint((np.array(rectangle) - np.tile(origin, 2)) / h).astype(int)
     np.testing.assert_allclose(
         np.array([x0, y0, x1, y1]) * h + np.tile(origin, 2), rectangle, atol=1e-12

tests/validation/run_refined_dfg.py

@@ -17,109 +17,8 @@ HERE = Path(__file__).resolve().parent
 DEFAULT_SOURCE = HERE.parents[1]
 BOUNDS = (40, 24, 320, 140)
 BASE_BLOCK = (2, 881)  # Exact 166 x 881 domain; no geometric padding.
-FINE_BLOCK = (8, 8)  # Wide 240 x 568 or compact 168 x 168, including fine halos.
+FINE_BLOCK = (8, 8)  # 240 x 568 including four fine halo cells.
 SPEED = 0.01
-JET_PEAK = 0.001
-JET_WINDOWS = [(t, t + 10) for t in range(250, 300, 10)]
-CV_CONTOURS = np.array([(48., 44., 160., 120.), (44., 36., 180., 128.)])
-PLACEMENTS = {"wide": BOUNDS, "compact": (48, 48, 128, 128)}
-COMPACT_CV_CONTOURS = np.array([(52., 52., 112., 112.), (50., 50., 120., 120.)])
-
-
-def selected_cases(selection="both", uniform_diameter=80):
-    return [(case, diameter) for case, diameter in (("uniform", uniform_diameter), ("refined", 40))
-            if selection in ("both", case)]
-
-
-def uniform_origin(diameter):
-    h = 40 / diameter
-    return (.5 - .5*h, 1 - h)
-
-
-def cv_contours(refined, diameter, placement="wide"):
-    contours = CV_CONTOURS if placement == "wide" else COMPACT_CV_CONTOURS
-    return contours if refined else contours + [20/diameter, 0., 20/diameter, 0.]
-
-
-def cv_selected(step, diameter, mode):
-    return mode == "pilot" or round(290 * diameter / SPEED) <= step <= round(300 * diameter / SPEED)
-
-
-def cv_snapshot(rho, ux, uy, fluid, origin, refined, begin, n, diameter, impulse, placement="wide"):
-    """Cropped public macros only; all inventories, fluxes and impulses use root units."""
-    from run_jet_circle_cv import cv_from_macros
-
-    rectangles = cv_contours(refined, diameter, placement)
-    h_cell = .5 if refined else 40 / diameter
-    origin = np.asarray(origin, dtype=float)
-    x0, y0, x1, y1 = np.rint((rectangles[-1] - np.tile(origin, 2)) / h_cell).astype(int)
-    selection = np.s_[y0-2:y1+2, x0-2:x1+2]
-    cropped_origin = origin + h_cell * np.array([x0-2, y0-2])
-    fields = [v[selection] for v in (rho, ux, uy, fluid)]
-    values = [cv_from_macros(*fields, cropped_origin, rect, .004, h=h_cell)
-              for rect in rectangles]
-    h_native = 1.0 if refined else 40 / diameter
-    return dict(step=begin+n, tstar=(begin+n)*SPEED/diameter,
-                time_root=(begin+n)*h_native, interval_start_root=begin*h_native,
-                interval_dt_root=n*h_native,
-                interval_impulse_root=(np.asarray(impulse)*h_native**2).tolist(),
-                inventory=[inventory.tolist() for inventory, _ in values],
-                outward_flux=[flux.tolist() for _, flux in values])
-
-
-def public_jets(center, radius, scenario):
-    """Same physical apertures; caller supplies its public geometry frame."""
-    if scenario == "none":
-        return ()
-    from CelerisLab.body.jets import Jet, Sector, Radial
-
-    peak = 0.0 if scenario == "zero" else JET_PEAK
-    return tuple(
-        Jet(Sector(center, angle, math.pi / 12, radius * 1.005),
-            Radial(center, inward=False), "parabolic", amplitude)
-        for angle, amplitude in ((math.pi / 2, peak), (3 * math.pi / 2, -peak))
-    )
-
-
-def jet_interval(handle, scenario, begin, n, diameter):
-    """Apply a reversal only at a completed interval boundary, before advancing."""
-    if scenario != "none":
-        boundaries = [round(t * diameter / SPEED) for t in (250, 260, 270, 280, 290, 300, 305)]
-        n = min([n] + [step - begin for step in boundaries if step > begin])
-    if scenario != "reverse":
-        return n, None
-    switch = round(300 * diameter / SPEED)
-    if begin < switch:
-        return min(n, switch - begin), None
-    if begin == switch:
-        handle.set_jet_amplitude(0, -JET_PEAK)
-        handle.set_jet_amplitude(1, JET_PEAK)
-        return n, dict(step=begin, tstar=300.0, amplitudes=[-JET_PEAK, JET_PEAK])
-    return n, None
-
-
-def jet_diagnostics(rows, scenario):
-    """Raw interval-weighted diagnostics only; no driven-flow qualification gate."""
-    windows = JET_WINDOWS + ([(300, 305)] if scenario == "reverse" else [])
-    result = []
-    for start, end in windows:
-        selected = [r for r in rows if start <= r["tstar_force"] < end]
-        if not selected:
-            continue
-        if any(2 * r["tstar_force"] - r["tstar"] < start - 1e-9
-               or r["tstar"] > end + 1e-9 for r in selected):
-            raise ValueError("Jet diagnostic interval crosses a window boundary")
-        weights = np.array([2 * (r["tstar"] - r["tstar_force"]) for r in selected])
-        record = dict(start_tstar=start, end_tstar=end, samples=len(selected),
-                      covered_tstar=float(weights.sum()),
-                      complete=bool(np.isclose(weights.sum(), end - start, rtol=0, atol=1e-9)))
-        for key in ("cd", "cl"):
-            values = np.array([r[key] for r in selected])
-            record[key] = dict(mean=float(np.average(values, weights=weights)),
-                               min=float(values.min()), max=float(values.max()),
-                               rms=float(np.sqrt(np.average(values**2, weights=weights))))
-        result.append(record)
-    return result
 
 
 def helpers(source):
@@ -140,34 +39,26 @@ def helpers(source):
     return h, periodic
 
 
-def config(h, diameter, collision="SRT", jet_scenario="none"):
+def config(h, diameter, collision="SRT"):
     cfg, body, p = h.make_config(diameter, SPEED, collision, "neq_extrap", "zou_he_local")
     cfg["method"]["outlet"]["srt_neq_damp"] = 0.5
-    if jet_scenario != "none":
-        if collision != "MRT":
-            raise ValueError("Public Jet scenarios require MRT")
-        cfg["method"]["ddf_shifting"] = False
     return cfg, body, p
 
 
-def plan(h, collision="SRT", observation_mode="last_base_step", jet_scenario="none", uniform_diameter=80, placement="wide"):
-    _, _, c = config(h, 40, collision, jet_scenario)
-    _, _, f = config(h, uniform_diameter, collision, jet_scenario)
-    bounds = PLACEMENTS[placement]
-    x0, y0, x1, y1 = bounds
+def plan(h, collision="SRT", observation_mode="last_base_step"):
+    _, _, c = config(h, 40, collision)
+    _, _, f = config(h, 80, collision)
+    x0, y0, x1, y1 = BOUNDS
     fine_active = 4 * (x1 - x0) * (y1 - y0)
     coarse_uncovered = c["nx"] * c["ny"] - fine_active // 4
     return dict(
         status="prepared_not_run",
         collision=collision,
-        jet_scenario=jet_scenario,
-        ddf_shifting=jet_scenario == "none",
         observation_mode=observation_mode,
         root_gpu_gates_required=True,
         root=c,
         uniform=f,
-        bounds_root_edge=list(bounds),
-        fine_origin_root_edge=[x0 - 2, y0 - 2],
+        bounds_root_edge=list(BOUNDS),
         physical_patch_m=[
             (x0 - 0.5) * c["dx"],
             (y0 - 1) * c["dx"],
@@ -187,31 +78,19 @@ def plan(h, collision="SRT", observation_mode="last_base_step", jet_scenario="no
         physical_viscosity_m2_s=0.001,
         finest_dx_m=f["dx"],
         finest_dt_s=f["dt"],
-        refined_finest_dx_m=c["dx"]/2,
-        refined_finest_dt_s=c["dt"]/2,
         approximate_leaf_cell_ratio=(coarse_uncovered + fine_active)
         / (f["nx"] * f["ny"]),
         approximate_collision_work_ratio=(coarse_uncovered + 2 * fine_active)
-        / ((uniform_diameter/40) * f["nx"] * f["ny"]),
+        / (2 * f["nx"] * f["ny"]),
         cost_caveat="Geometry-only estimates include ghosts/solids; exclude block halos, transfers, observation and launch overhead. Not measured speedup.",
-        sampling_offset="Uniform nodes map to root edges X=.5+i*(40/D), Y=1+(j-.5)*(40/D). Refined centers are fine_origin_root_edge+(index+.5)*.5. Body, wall and source planes coincide; compare observables, not pointwise arrays.",
+        sampling_offset="For origin (38,22), fine physical x=(j+75.5)*dx80 versus uniform i*dx80: half-fine-cell x offset. Fine physical y=(k+42.5)*dx80 equals uniform (l-.5)*dx80 at l=k+43: y samples align. Body, wall and source planes coincide.",
         outlet=(
             "SRT pressure NEQ, all nine fneq damped by .5, no backflow clamp; noncanonical DFG outlet"
             if collision == "SRT" else
             "MRT pressure NEQ, unknowns q2/6/8 extrapolated; no backflow clamp; noncanonical DFG outlet"
         ),
-        modes={"pilot_tstar": 5.0, "full_tstar": 305.0 if jet_scenario == "reverse" else 300.0},
+        modes={"pilot_tstar": 5.0, "full_tstar": 300.0},
         observation_dense_tstar=0.02,
-        **(dict(jets=dict(
-            uniform_origin_node=f["center"], refined_origin_root_edge=[80.5, 81.0],
-            angles_rad=[math.pi / 2, 3 * math.pi / 2], half_width_rad=math.pi / 12,
-            radial_extent_over_radius=[0.0, 1.005],
-            field="Radial(outward)", profile="parabolic", condition="velocity",
-            initial_amplitudes=[0.0, 0.0] if jet_scenario == "zero" else [JET_PEAK, -JET_PEAK],
-            reversal_tstar=300.0 if jet_scenario == "reverse" else None,
-            diagnostic_windows_tstar=JET_WINDOWS + ([(300, 305)] if jet_scenario == "reverse" else []),
-            transfer="constant", driven_qualification="not assessed",
-        )) if jet_scenario != "none" else {}),
     )
 
 
@@ -247,7 +126,7 @@ def initial_state(shape, origin, spacing, height=164.0, speed=SPEED, root=False)
     return w * (1 + 3 * cu + 4.5 * cu * cu - 1.5 * velocity * velocity)
 
 
-def host_geometry(source, h, collision="SRT", jet_scenario="none", placement="wide"):
+def host_geometry(source, h, collision="SRT"):
     """Production donor/transfer and complete cut-link checks, without CUDA."""
     from CelerisLab.config import load_lbm_config
     from CelerisLab.lbm.refinement import FixedPatch2D, prepare_fine_boundary
@@ -260,12 +139,12 @@ def host_geometry(source, h, collision="SRT", jet_scenario="none", placement="wi
     from CelerisLab.body.geometry.circle import CircleGeometry
     from CelerisLab.body.objects import SimObject
 
-    cfgdict, _, _ = config(h, 40, collision, jet_scenario)
+    cfgdict, _, _ = config(h, 40, collision)
     with TemporaryDirectory() as tmp:
         p = Path(tmp) / "cfg.json"
         p.write_text(json.dumps(cfgdict))
         cfg = load_lbm_config(str(p))
-    pair = FixedPatch2D.from_config(cfg, PLACEMENTS[placement])
+    pair = FixedPatch2D.from_config(cfg, BOUNDS)
     layout = BlockLayout2D.build(cfg.ny, cfg.nx, *BASE_BLOCK)
     validate_channel_config(cfg, [BASE_BLOCK, FINE_BLOCK])
     targets = blocked_base_tables(pair, layout, np.argsort(pair.coalesce_coarse))[1]
@@ -274,41 +153,18 @@ def host_geometry(source, h, collision="SRT", jet_scenario="none", placement="wi
     body = SimObject(
         0, geometry=CircleGeometry(80.5, 81.0, 20.0), center=(80.5, 81.0), radius=20.0
     )
-    host = prepare_fine_boundary(
-        cfg, pair, (body,), jets=public_jets((80.5, 81.0), 20.0, jet_scenario),
-        _shifted_blocked=jet_scenario == "none",
-    )
+    host = prepare_fine_boundary(cfg, pair, (body,), _shifted_blocked=True)
     return cfg, pair, body, host
 
 
-def verify_source(source, collision="SRT", observation_mode="last_base_step", jet_scenario="none", observe_cv=False):
+def verify_source(source, collision="SRT", observation_mode="last_base_step"):
     if collision not in ("SRT", "MRT"):
         raise ValueError("Matched collision must be SRT or MRT")
     if observation_mode not in ("last_base_step", "window"):
         raise ValueError("Unknown refined observation mode")
-    if observe_cv and jet_scenario == "none":
-        raise ValueError("--observe-cv requires an explicit public Jet scenario")
     name = ("source_manifest_window.json" if observation_mode == "window" else
             "source_manifest.json" if collision == "SRT" else "source_manifest_mrt.json")
     expected = json.loads((HERE / "data/refined_dfg" / name).read_text())
-    if jet_scenario != "none":
-        if collision != "MRT" or observation_mode != "window":
-            raise ValueError("Public Jet scenarios require MRT and --exchange-window")
-        import subprocess
-        sys.path.insert(0, str(HERE))
-        from source_provenance import checkout_provenance
-
-        paths = set(expected["sha256"])
-        if observe_cv:
-            paths.add("tests/validation/run_jet_circle_cv.py")
-        paths.update(subprocess.check_output(
-            ["git", "-C", str(source), "ls-files", "src"], text=True).splitlines())
-        return dict(
-            source_capture="current checkout, not historical DFG qualification",
-            **checkout_provenance(source), observation_mode=observation_mode,
-            sha256={name: hashlib.sha256((source / name).read_bytes()).hexdigest()
-                    for name in sorted(paths)},
-        )
     for name, digest in expected["sha256"].items():
         if hashlib.sha256((source / name).read_bytes()).hexdigest() != digest:
             raise RuntimeError("Source mismatch: " + name)
@@ -363,33 +219,29 @@ def run_case(a, h, periodic, case):
     from contextlib import ExitStack
 
     refined = case == "refined"
-    cfgdict, bodydict, p = config(h, 40 if refined else a.uniform_diameter, a.collision, a.jet_scenario)
-    cap = 5.0 if a.mode == "pilot" else (305.0 if a.jet_scenario == "reverse" else 300.0)
+    cfgdict, bodydict, p = config(h, 40 if refined else 80, a.collision)
+    cap = 5.0 if a.mode == "pilot" else 300.0
     max_steps = math.ceil(cap * p["diameter"] / SPEED)
     rows = []
     healthy = True
     step_seconds = 0.0
-    cv_seconds, cv_samples = 0.0, 0
-    amplitude_changes = []
     started = time.monotonic()
     check_deadline(a.deadline)
     dest = a.output / case
     dest.mkdir()
     with ExitStack() as stack:
-        cv_out = stack.enter_context((dest / "cv_history.jsonl").open("w")) if a.observe_cv else None
         if refined:
-            cfg, pair, body, host = host_geometry(a.source, h, a.collision, a.jet_scenario, a.placement)
+            cfg, pair, body, host = host_geometry(a.source, h, a.collision)
             context = stack.enter_context(CudaContext(0))
             backend = stack.enter_context(
                 FixedPatchStepper(
                     cfg,
-                    PLACEMENTS[a.placement],
+                    BOUNDS,
                     context=context,
                     coarse_boundary="channel",
                     base_block=BASE_BLOCK,
                     fine_block=FINE_BLOCK,
                     fine_objects=(body,),
-                    jets=public_jets((80.5, 81.0), 20.0, a.jet_scenario),
                     observe_raw_exchange=True,
                     **({"observe_window_exchange": True} if a.observation_mode == "window" else {}),
                 )
@@ -422,9 +274,6 @@ def run_case(a, h, periodic, case):
             sim = stack.enter_context(
                 Simulation(str(tmp / "lbm.json"), str(tmp / "body.json"), device_id=0)
             )
-            for index, jet in enumerate(public_jets(p["center"], p["radius"], a.jet_scenario)):
-                if sim.add_jet(jet) != index:
-                    raise RuntimeError("Unexpected public Jet registration index")
             sim.initialize()
             probe_p = p
             fluid = (sim.field.flag.reshape(p["ny"], p["nx"]) & FLUID) != 0
@@ -441,10 +290,6 @@ def run_case(a, h, periodic, case):
                     else 0.5
                 )
                 n = min(max(1, round(width * p["diameter"] / SPEED)), max_steps - begin)
-                n, change = jet_interval(backend if refined else sim, a.jet_scenario,
-                                         begin, n, p["diameter"])
-                if change is not None:
-                    amplitude_changes.append(change)
                 impulse = np.zeros(2)
                 tick = time.monotonic()
                 if refined:
@@ -514,19 +359,6 @@ def run_case(a, h, periodic, case):
                     / SPEED,
                     **h.pressure_probes(rho, fluid, probe_p),
                 )
-                if a.jet_scenario != "none":
-                    row.update(step_start=begin, tstar_start=begin * SPEED / p["diameter"],
-                               interval_steps=n, impulse_x=float(impulse[0]),
-                               impulse_y=float(impulse[1]))
-                if a.observe_cv and cv_selected(begin+n, p["diameter"], a.mode):
-                    tick = time.monotonic()
-                    record = cv_snapshot(rho, ux, uy, fluid,
-                                         pair.fine_origin if refined else uniform_origin(p["diameter"]),
-                                         refined, begin, n, p["diameter"], impulse, a.placement)
-                    cv_out.write(json.dumps(record, allow_nan=False) + "\n")
-                    cv_out.flush()
-                    cv_samples += 1
-                    cv_seconds += time.monotonic() - tick
                 check_deadline(a.deadline)
                 ensure_finite(row)
                 rows.append(row)
@@ -570,24 +402,14 @@ def run_case(a, h, periodic, case):
         steps=begin,
         startup_seconds=startup,
         step_seconds=step_seconds,
-        observation_and_overhead_seconds=time.monotonic() - started - startup - step_seconds,
         wall_seconds=time.monotonic() - started,
         force="raw stationary-body link momentum reaction, per-unit-depth; average over entire observation interval; normalized in each base lattice",
         mass_units="rho_reference * m^2 per unit depth",
         flux_units="rho_reference * m^2/s per unit depth",
         pressure="postcollision end-sample; physical pressure difference / (rho_reference * 1 m/s squared)",
         suite_validated=False,
-        **(periodic.assess(rows) if a.jet_scenario in ("none", "zero") else
-           dict(periodic=False, checks={}, cycles=[])),
+        **periodic.assess(rows),
     )
-    if a.jet_scenario != "none":
-        result.update(jet_diagnostic_windows=jet_diagnostics(rows, a.jet_scenario),
-                      amplitude_changes=amplitude_changes,
-                      pressure_classification=("DFG reference verdict retained, including pressure"
-                          if a.jet_scenario == "zero" else "diagnostic only; no official DFG reference gate"))
-    if a.observe_cv:
-        result.update(cv_observation_seconds=cv_seconds, cv_samples=cv_samples,
-                      cv_qualification="not assessed; scalar observations only")
     if not healthy:
         result["periodic"] = False
     reference = json.loads(
@@ -603,8 +425,7 @@ def run_case(a, h, periodic, case):
         else (
             "pilot_complete"
             if a.mode == "pilot"
-            else ("driven_diagnostics_complete" if a.jet_scenario in ("fixed", "reverse") else
-                  "periodic" if result["periodic"] else "incomplete_periodicity")
+            else ("periodic" if result["periodic"] else "incomplete_periodicity")
         )
     )
     (dest / "summary.json").write_text(json.dumps(result, indent=2, allow_nan=False))
@@ -643,39 +464,27 @@ def check_deadline(deadline):
         )
 
 
-def verify_pilot(path, manifest, collision="SRT", observation_mode="last_base_step", jet_scenario="none", observe_cv=False,
-                 case_selection="both", uniform_diameter=80, placement="wide"):
+def verify_pilot(path, manifest, collision="SRT", observation_mode="last_base_step"):
     if path is None:
         raise ValueError(
             "Full comparison requires --pilot-results from a completed matched pilot"
         )
     previous = read_finite_json(path / "plan.json")
-    options = dict(case_selection=(case_selection, "both"), uniform_diameter=(uniform_diameter, 80), placement=(placement, "wide"))
-    if any(previous.get(k, default) != expected for k, (expected, default) in options.items()):
-        raise ValueError("Pilot case, resolution or placement differs")
-    if previous.get("observe_cv", False) != observe_cv:
-        raise ValueError("Pilot CV observation mode differs")
-    if previous.get("jet_scenario", "none") != jet_scenario:
-        raise ValueError("Pilot Jet scenario differs")
     if previous.get("observation_mode") != observation_mode:
         raise ValueError("Pilot observation mode differs")
     if previous.get("collision") != collision:
         raise ValueError("Pilot collision differs")
     if previous["source_manifest"] != manifest or previous["bounds_root_edge"] != list(
-        PLACEMENTS[placement]
+        BOUNDS
     ):
         raise ValueError("Pilot source or frozen geometry differs")
     if previous.get("runner_sha256") != runner_hash():
         raise ValueError("Pilot runner differs")
     calibrated_seconds = 0.0
-    for case, diameter in selected_cases(case_selection, uniform_diameter):
+    for case, diameter in (("uniform", 80), ("refined", 40)):
         summary = read_finite_json(path / case / "summary.json")
         if (
-            any(summary.get(k, default) != expected for k, (expected, default) in options.items())
-            or summary.get("observe_cv", False) != observe_cv
-            or (observe_cv and summary.get("cv_samples") != 250)
-            or summary.get("jet_scenario", "none") != jet_scenario
-            or summary.get("observation_mode") != observation_mode
+            summary.get("observation_mode") != observation_mode
             or summary.get("collision") != collision
             or summary.get("case") != case
             or summary.get("mode") != "pilot"
@@ -728,10 +537,7 @@ def verify_pilot(path, manifest, collision="SRT", observation_mode="last_base_st
                 raise ValueError("Unhealthy pilot observations")
         ready = read_finite_json(path / case / "ready.json")
         if (
-            any(ready.get(k, default) != expected for k, (expected, default) in options.items())
-            or ready.get("observe_cv", False) != observe_cv
-            or ready.get("jet_scenario", "none") != jet_scenario
-            or ready.get("observation_mode") != observation_mode
+            ready.get("observation_mode") != observation_mode
             or ready.get("collision") != collision
             or ready.get("case") != case
             or ready.get("mode") != "pilot"
@@ -749,9 +555,9 @@ def verify_pilot(path, manifest, collision="SRT", observation_mode="last_base_st
             or not 0 < stepping <= wall
         ):
             raise ValueError("Invalid pilot calibration timings")
-        # Full duration is 60 (or 61 with reversal) times pilot; dense sampling makes
+        # Full physical duration is 60 times pilot; dense pilot sampling makes
         # this conservative for the sparser early full observations. Not a guarantee.
-        calibrated_seconds += startup + (61 if jet_scenario == "reverse" else 60) * (wall - startup)
+        calibrated_seconds += startup + 60 * (wall - startup)
     return 3 * calibrated_seconds
 
 
@@ -760,13 +566,6 @@ def main():
     parser.add_argument("--exchange-window", action="store_true",
                         help="Opt in to refined window-ledger observations on the pinned candidate")
     parser.add_argument("--collision", choices=["SRT", "MRT"], default="SRT")
-    parser.add_argument("--case", choices=["both", "uniform", "refined"], default="both")
-    parser.add_argument("--uniform-diameter", type=int, choices=[80, 160], default=80)
-    parser.add_argument("--placement", choices=list(PLACEMENTS), default="wide")
-    parser.add_argument("--jet-scenario", choices=["none", "zero", "fixed", "reverse"],
-                        default="none", help="Opt in to public unshifted MRT Jets; reverse switches at t*=300 and ends at 305")
-    parser.add_argument("--observe-cv", action="store_true",
-                        help="Record independent cropped-macro CV samples during pilot or full t*=290..300")
     parser.add_argument("--source", type=Path, default=DEFAULT_SOURCE)
     parser.add_argument("--output", type=Path, required=True)
     parser.add_argument("--mode", choices=["plan", "pilot", "full"], default="plan")
@@ -778,26 +577,15 @@ def main():
         help="Required explicit campaign wall-time ceiling for GPU execution",
     )
     a = parser.parse_args()
-    if a.uniform_diameter == 160 and a.case != "uniform":
-        raise ValueError("D160 requires --case uniform; no matched-resolution claim")
-    if a.placement == "compact" and a.case != "refined":
-        raise ValueError("Compact placement requires --case refined")
-    if (a.uniform_diameter != 80 or a.placement != "wide") and a.jet_scenario == "none":
-        raise ValueError("Resolution/placement variants require an explicit public Jet scenario")
     a.source = a.source.resolve()
     a.observation_mode = "window" if a.exchange_window else "last_base_step"
-    manifest = verify_source(a.source, a.collision, a.observation_mode, a.jet_scenario, a.observe_cv)
+    manifest = verify_source(a.source, a.collision, a.observation_mode)
     h, periodic = helpers(a.source)
     from source_provenance import checkout_provenance
 
     a.provenance = checkout_provenance(a.source)
-    a.provenance.update(jet_scenario=a.jet_scenario, ddf_shifting=a.jet_scenario == "none")
-    a.provenance.update(case_selection=a.case, uniform_diameter=a.uniform_diameter, placement=a.placement)
-    if a.observe_cv:
-        a.provenance["observe_cv"] = True
     calibration = (
-        verify_pilot(a.pilot_results, manifest, a.collision, a.observation_mode, a.jet_scenario, a.observe_cv,
-                     a.case, a.uniform_diameter, a.placement)
+        verify_pilot(a.pilot_results, manifest, a.collision, a.observation_mode)
         if a.mode == "full" else None
     )
     if a.mode != "plan" and (
@@ -814,31 +602,17 @@ def main():
     if a.output.exists() and any(a.output.iterdir()):
         raise ValueError("Output must be empty/new")
     a.output.mkdir(parents=True, exist_ok=True)
-    specification = plan(h, a.collision, a.observation_mode, a.jet_scenario, a.uniform_diameter, a.placement)
+    specification = plan(h, a.collision, a.observation_mode)
     specification.update(
         source_manifest=manifest,
         **a.provenance,
-        gates=periodic.GATES if a.jet_scenario in ("none", "zero") else None,
-        reference_gates=periodic.REFERENCE_GATES if a.jet_scenario in ("none", "zero") else None,
+        gates=periodic.GATES,
+        reference_gates=periodic.REFERENCE_GATES,
         runner_sha256=runner_hash(),
         wall_time_budget_seconds=budget,
         full_pilot_calibration_seconds=calibration,
     )
-    if a.observe_cv:
-        specification["cv_observation"] = dict(
-            full_tstar=[290, 300], pilot_tstar=[.02, 5], spacing_tstar=.02,
-            refined_contours_root=cv_contours(True, 40, a.placement).tolist(),
-            uniform_contours_root=cv_contours(False, a.uniform_diameter, a.placement).tolist(),
-            uniform_grid_origin_root=uniform_origin(a.uniform_diameter),
-            refined_grid_origin_root=specification["fine_origin_root_edge"],
-            cell_width_root={"uniform": 40/a.uniform_diameter, "refined": .5},
-            viscosity_root=.004, components=["mass", "Px", "Py"],
-            units="root lattice per unit depth; outward flux per root time",
-            interval="Impulse belongs to the interval ending at each snapshot; first retained endpoint (pilot .02, full 290) supplies initial inventory only: exclude its preceding impulse",
-            qualification="not assessed; trapezoidal integration and time-coarsening are offline",
-        )
-    if a.case != "uniform":
-        host_geometry(a.source, h, a.collision, a.jet_scenario, a.placement)
+    host_geometry(a.source, h, a.collision)
     (a.output / "plan.json").write_text(json.dumps(specification, indent=2))
     if a.mode == "plan":
         return 0
@@ -847,9 +621,8 @@ def main():
             "GPU execution blocked: root GPU gates approval and explicit device selection required"
         )
     results = []
-    cases = selected_cases(a.case, a.uniform_diameter)
     a.deadline = time.monotonic() + budget
-    for case, _ in cases:
+    for case in ("uniform", "refined"):
         try:
             result = run_case(a, h, periodic, case)
         except TimeoutError as exc:
@@ -877,12 +650,7 @@ def main():
         status="pilot_only" if a.mode == "pilot" else "incomplete",
         matched_case_pass=False,
     )
-    if a.jet_scenario in ("fixed", "reverse"):
-        comparison.update(status=("pilot_only" if a.mode == "pilot" else "driven_diagnostics_complete")
-                          if len(results) == len(cases) and all(r["healthy"] for r in results) else "invalid_state",
-                          qualification="not assessed; execution completion is not physical acceptance",
-                          jet_diagnostic_windows={r["case"]: r["jet_diagnostic_windows"] for r in results})
-    if a.case == "both" and len(results) == 2 and all(r["healthy"] and r["periodic"] for r in results):
+    if len(results) == 2 and all(r["healthy"] and r["periodic"] for r in results):
         comparison.update(
             status="periodic_comparison",
             refined_vs_uniform=periodic.compare(
@@ -892,20 +660,14 @@ def main():
         comparison["matched_case_pass"] = comparison["refined_vs_uniform"][
             "reference_agreement"
         ]
-    if a.case != "both":
-        comparison.update(status="single_case_" + results[0]["status"],
-                          own_reference_comparison=results[0].get("reference_comparison"))
     (a.output / "comparison.json").write_text(
         json.dumps(comparison, indent=2, allow_nan=False)
     )
     return (
         0
-        if len(results) == len(cases)
+        if len(results) == 2
         and all(r["healthy"] for r in results)
-        and (a.mode == "pilot" or comparison["matched_case_pass"]
-             or a.jet_scenario in ("fixed", "reverse")
-             or (a.case != "both" and results[0]["periodic"]
-                 and results[0].get("reference_comparison", {}).get("reference_agreement", False)))
+        and (a.mode == "pilot" or comparison["matched_case_pass"])
         else 2
     )
 

tests/validation/taylor_green/assess_shear_wave.py

@@ -0,0 +1,81 @@
+"""Fixed N128 four-case shear-wave contract: U128, U256, constant R128, projected R128.
+
+Shared provenance, build, workload and sample-time checks are reused from
+assess_projected_pairs (same cases, source pins and geometry); only the
+Taylor-Green-specific checks are replaced by shear-wave metadata and physics.
+"""
+
+import argparse
+import json
+from pathlib import Path
+
+import assess_projected_pairs as tg
+import shear_wave as sw
+from run_case import SHEAR_WAVE_SHA256
+
+SHARED = ("complete_matrix", "no_extra_cases", "no_duplicate_cases", "finite_receipts",
+          "same_source_and_harness", "clean_a135252_numerical_source",
+          "same_recorded_runtime", "same_explicit_device", "same_early_sampling")
+PER_CASE = ("complete_times", "scales", "actual_builds", "reference", "runtime_source",
+            "patch", "workload")
+
+
+def metadata_ok(record, n):
+    return (record.get("flow") == "shear_wave" and record.get("mode") == list(sw.MODE)
+            and record.get("polarization") == sw.E.tolist()
+            and record.get("angle_deg") == sw.ANGLE_DEG and record.get("phase") == sw.PHI
+            and record.get("eps") == sw.eps(n)
+            and record.get("numerics") == tg.NUMERICS
+            and record.get("initialization") == sw.INITIALIZATION
+            and record.get("limits") == sw.LIMITS
+            and record.get("early_pressure") == dict(enabled=False, rows=[],
+                                                     sampled_max_pressure_l2=None)
+            and (record.get("source") or {}).get("shear_wave_sha256") == SHEAR_WAVE_SHA256)
+
+
+def assess(records, expected_revision=None):
+    if not isinstance(records, list) or not all(isinstance(r, dict) for r in records):
+        raise ValueError("records must be a list of receipt objects")
+    base_checks = tg.assess(records, expected_revision)["checks"]
+    checks = {name: base_checks.get(name, False) for name in SHARED}
+    indexed = {}
+    for r in records:
+        indexed.setdefault(tuple(r.get(k) for k in ("re_L", "n", "depth", "explosion")), r)
+    for key in tg.CASES:
+        _, n, depth, scheme = key
+        label = f"{n}/{depth}/{scheme}"
+        for name in PER_CASE:
+            checks[f"{label} {name}"] = base_checks.get(f"{label} {name}", False)
+        checks[f"{label} shear_metadata"] = key in indexed and metadata_ok(indexed[key], n)
+    contract_valid = all(checks.values())
+    result = dict(checks=checks, contract_valid=contract_valid,
+                  cases=[list(k) for k in tg.CASES], expected_revision=expected_revision,
+                  scope="2D periodic Re100 oblique (2,1) shear wave; one phase and one "
+                        "rectangle; no placement robustness or convergence order")
+    if not contract_valid:
+        result.update(status="INVALID_SET", passed=False)
+        return result
+    try:
+        physics = sw.assess(indexed[tg.CASES[0]], indexed[tg.CASES[1]],
+                            [indexed[tg.CASES[2]], indexed[tg.CASES[3]]])
+    except (KeyError, ValueError) as error:
+        result.update(status="INVALID_SET", passed=False, reason=str(error))
+        return result
+    result.update(physics=physics, status=physics["status"],
+                  passed=physics["status"] == "PASS")
+    return result
+
+
+if __name__ == "__main__":
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("files", type=Path, nargs=4)
+    p.add_argument("--output", type=Path, required=True)
+    p.add_argument("--expected-revision", required=True)
+    args = p.parse_args()
+    if args.output.exists():
+        p.error("Output already exists; choose a new path to retain prior evidence")
+    result = assess([json.loads(path.read_text()) for path in args.files], args.expected_revision)
+    text = json.dumps(result, indent=2, allow_nan=False) + "\n"
+    args.output.write_text(text)
+    print(text, end="")
+    raise SystemExit(0 if result["passed"] else 1)

tests/validation/taylor_green/run_case.py

@@ -18,6 +18,30 @@ SOURCE_SHA256 = "a5dbfd804befce868067d79a23e5fd47dce7f505b3f9b1bb2145fb57cb5f217
 BUILD_CAPTURE_SHA256 = "3dbaa6547cb0a4cb1541054f3b64ad8b6e18cc70527ac6166e56b944e9bd464a"
 REFERENCE_HARNESS = "11901a7f77557a901e017a171eeae1758d584fa5"
 INITIALIZATION = "physical FP64 equilibrium G at actual cell centers; rho=1+3p"
+SHEAR_WAVE_SHA256 = "81d5c8ee60864372887cddf9239580c82fb6750d956038f1e3ee9de61aa4e877"
+
+
+def flow_functions(flow="taylor_green"):
+    """(initial, metrics, limits, initialization); the default is the frozen TG oracle."""
+    if flow == "taylor_green":
+        return initial, metrics, LIMITS, INITIALIZATION
+    if flow == "shear_wave":
+        import shear_wave
+        return shear_wave.initial, shear_wave.metrics, shear_wave.LIMITS, shear_wave.INITIALIZATION
+    raise ValueError(f"unknown flow {flow!r}")
+
+
+def finite_row(row):
+    """Every scalar or list-valued diagnostic is finite (TG rows are all scalars)."""
+    return all(np.isfinite(np.asarray(value, dtype=float)).all() for value in row.values())
+
+
+def sample(run, masks, step, n, viscosity, initial_mass, metrics, depth, label="sample"):
+    arrays = (run.download(),) if depth == 1 else run.download()
+    row = metrics(arrays, masks, step, n, viscosity, initial_mass)
+    if not finite_row(row):
+        raise FloatingPointError(f"nonfinite {label} diagnostics")
+    return row
 
 
 def sample_steps(n, early_pressure=False):
@@ -64,7 +88,7 @@ def provenance(repo):
     )
 
 
-def verify_source(repo, revision):
+def verify_source(repo, revision, flow="taylor_green"):
     """Exact clean harness commit, fixed production tree, and reviewed capture helper."""
     import oracle
     from tests.validation.multigrid import check_projected_pairs as gate
@@ -83,6 +107,13 @@ def verify_source(repo, revision):
     if result["source_tree_sha256"] != SOURCE_SHA256:
         raise RuntimeError("Wrong numerical source fingerprint")
     result["build_capture_sha256"] = BUILD_CAPTURE_SHA256
+    if flow == "shear_wave":
+        import shear_wave
+        module = harness / "shear_wave.py"
+        if (Path(shear_wave.__file__).resolve() != module
+                or hashlib.sha256(module.read_bytes()).hexdigest() != SHEAR_WAVE_SHA256):
+            raise RuntimeError("Wrong shear_wave module checkout or content")
+        result["shear_wave_sha256"] = SHEAR_WAVE_SHA256
     return result
 
 
@@ -151,7 +182,11 @@ def main():
     p.add_argument("--explosion", choices=["constant", "projected_linear"], default="constant")
     p.add_argument("--early-pressure", action="store_true",
                    help="also save 65 scalar pressure samples at t*=k*.001875, k=0..64")
+    p.add_argument("--flow", choices=["taylor_green", "shear_wave"], default="taylor_green")
     args = p.parse_args()
+    if args.flow == "shear_wave" and (args.re != 100 or args.depth == 3 or args.early_pressure):
+        p.error("shear_wave requires --re 100, depth 1 or 2 and no --early-pressure")
+    initial, metrics, limits, initialization = flow_functions(args.flow)
     if args.output.exists():
         p.error("Output already exists; choose a new path to retain prior evidence")
     if args.explosion != "constant" and args.depth != 2:
@@ -161,7 +196,7 @@ def main():
         p.error("--run-gpu and exactly one explicit CUDA_VISIBLE_DEVICES are required")
     repo = args.repo.resolve()
     sys.path[:0] = [str(repo / "src"), str(repo)]
-    source = verify_source(repo, args.expected_revision)
+    source = verify_source(repo, args.expected_revision, args.flow)
     runtime = runtime_source(repo)
     if args.dry_run:
         print(json.dumps(dict(source=source, runtime_source=runtime, dry_run=True)))
@@ -197,7 +232,7 @@ def main():
         mach=U * np.sqrt(3),
         viscosity=cfg.viscosity,
         tau_by_level=[0.5 + 3 * c.viscosity for c in h.configs],
-        initialization=INITIALIZATION,
+        initialization=initialization,
         numerics=dict(lattice_model=cfg.lattice_model, collision=cfg.collision,
                       store_precision=cfg.store_precision, ddf_shifting=cfg.ddf_shifting,
                       streaming=cfg.streaming, les_enabled=cfg.les_enabled,
@@ -205,13 +240,18 @@ def main():
                       sample_phase="postcollision G at root synchronization"),
         cuda_visible_devices=selected,
         device_id=0,
-        limits=LIMITS,
+        limits=limits,
         workload=workload(masks, round(TIMES[-1] * args.n / U)),
         rows=[],
         early_pressure=dict(enabled=args.early_pressure, rows=[],
                             sampled_max_pressure_l2=None),
         completed=False,
     )
+    if args.flow != "taylor_green":
+        import shear_wave
+        report.update(flow=args.flow, mode=list(shear_wave.MODE),
+                      polarization=shear_wave.E.tolist(), angle_deg=shear_wave.ANGLE_DEG,
+                      phase=shear_wave.PHI, eps=shear_wave.eps(args.n))
     args.output.parent.mkdir(parents=True, exist_ok=True)
     def save():
         temporary = args.output.with_suffix(args.output.suffix + ".tmp")
@@ -248,10 +288,8 @@ def main():
             initial_mass = None
             for step in sorted(set(main_steps + early_steps)):
                 run.step(step - run.step_count)
-                arrays = (run.download(),) if args.depth == 1 else run.download()
-                row = metrics(arrays, masks, step, args.n, cfg.viscosity, initial_mass)
-                if not all(np.isfinite(value) for value in row.values()):
-                    raise FloatingPointError("nonfinite sample diagnostics")
+                row = sample(run, masks, step, args.n, cfg.viscosity, initial_mass,
+                             metrics, args.depth)
                 row["step"] = step
                 if initial_mass is None:
                     initial_mass = row["mass"]
@@ -278,10 +316,8 @@ def main():
                     # Exercise real kernels/halos/transfers on every level before READY.
                     # This is the first measured trajectory step, not discarded warmup.
                     run.step(1)
-                    probe = (run.download(),) if args.depth == 1 else run.download()
-                    probe_metrics = metrics(probe, masks, 1, args.n, cfg.viscosity, initial_mass)
-                    if not all(np.isfinite(value) for value in probe_metrics.values()):
-                        raise FloatingPointError("nonfinite READY diagnostics")
+                    sample(run, masks, 1, args.n, cfg.viscosity, initial_mass,
+                           metrics, args.depth, "READY")
                     report["ready_after_step"] = 1
                     save()
                     print(
@@ -301,7 +337,7 @@ def main():
         completed=True,
         seconds=time.monotonic() - started,
         screening_pass=all(
-            row[key] <= limit for row in report["rows"] for key, limit in LIMITS.items()
+            row[key] <= limit for row in report["rows"] for key, limit in limits.items()
         ),
     )
     save()

tests/validation/taylor_green/shear_wave.py

@@ -0,0 +1,312 @@
+"""CPU-only oblique shear-wave reference and composite-leaf diagnostics.
+
+Convention: integer mode MODE=(2,1) on the L x L periodic root domain, so the
+wavevector k = (2*pi/L)*(2,1) points 26.565 deg from +x (mode (1,2) would be
+63.435 deg). Velocity is polarized along E = (-1,2)/sqrt(5), perpendicular to k.
+The frozen Taylor-Green oracle is reused for constants and geometry only.
+"""
+
+import math
+
+import numpy as np
+from oracle import CX, CY, W, U, TIMES, centers
+
+MODE = (2, 1)
+PHI = 0.0
+E = np.array([-MODE[1], MODE[0]], dtype=float) / math.hypot(*MODE)
+ANGLE_DEG = math.degrees(math.atan2(MODE[1], MODE[0]))
+RE = 100  # Re = U L / nu, the same nu as Taylor-Green Re100 at equal N
+FIT_FROM_TSTAR = 0.12  # late-time samples only; reduces startup sensitivity
+INITIALIZATION = (
+    "physical FP64 equilibrium G at actual cell centers; rho=1 (exact p const)"
+)
+# Per-row screens. phase_drift_abs, residual_l2 and the run-level rate screen
+# use eps(n) and are preregistered diagnostic choices, not error bounds.
+LIMITS = dict(velocity_l2=0.05, spurious_pressure_scaled=0.02, mass_relative=1e-5)
+# The comparative pressure budget max(2*control, 0.02) is never below the 0.02
+# absolute ceiling, so it is always redundant; raw control ratios are kept.
+FLOORS = dict(rate_error=0.002, residual_l2=0.002, spurious_pressure_scaled=0.02)
+BASELINE_FACTOR = 2.0
+
+
+def wavevector(length):
+    return 2 * np.pi / length * np.array(MODE, dtype=float)
+
+
+def decay_rate(length, viscosity):
+    """Exact amplitude decay rate per root step: nu |k|^2."""
+    k = wavevector(length)
+    return viscosity * float(k @ k)
+
+
+def eps(n):
+    """(|k| h_root)^2 with h_root = 1: dimensionless, coefficient one."""
+    k = wavevector(n)
+    return float(k @ k)
+
+
+def exact(x, y, t, length, viscosity, amplitude=U):
+    k = wavevector(length)
+    a = amplitude * np.exp(-decay_rate(length, viscosity) * t)
+    s = np.sin(k[0] * x + k[1] * y + PHI)
+    p = np.zeros_like(s)
+    return a * E[0] * s, a * E[1] * s, p  # kinematic pressure, constant
+
+
+def equilibrium(rho, ux, uy):
+    # Same second-order D2Q9 equilibrium as oracle.initial.
+    cu = CX[:, None, None] * ux + CY[:, None, None] * uy
+    return (
+        W[:, None, None]
+        * rho
+        * (1 + 3 * cu + 4.5 * cu * cu - 1.5 * (ux * ux + uy * uy))
+    )
+
+
+def initial(shape, level, length, viscosity):
+    x, y = centers(shape, level)
+    ux, uy, p = exact(x, y, 0.0, length, viscosity)
+    return equilibrium(1 + 3 * p, ux, uy)
+
+
+def _leaves(arrays, masks):
+    accum = []
+    for level, (g, mask) in enumerate(zip(arrays, masks)):
+        if g.shape != (9, *mask.shape):
+            raise ValueError("population/mask shape mismatch")
+        values = g[:, mask].astype(float)
+        if not np.isfinite(values).all():
+            raise FloatingPointError("nonfinite leaf populations")
+        rho = values.sum(axis=0)
+        if (rho <= 0).any():
+            raise FloatingPointError("nonpositive leaf density")
+        x, y = centers(mask.shape, level)
+        area = np.full(rho.size, 0.25**level)
+        lev = np.full(rho.size, level)
+        accum.append((rho, CX @ values / rho, CY @ values / rho, x[mask], y[mask], area, lev))
+    return [np.concatenate(v) for v in zip(*accum)]
+
+
+def metrics(arrays, masks, t, length, viscosity, initial_mass=None):
+    rho, ux, uy, x, y, w, lev = _leaves(arrays, masks)
+    volume = w.sum()
+    if not np.isclose(volume, length**2, rtol=0, atol=1e-10):
+        raise ValueError("leaf partition does not cover domain once")
+    k = wavevector(length)
+    theta = k[0] * x + k[1] * y + PHI
+    s, c = np.sin(theta), np.cos(theta)
+    v = ux * E[0] + uy * E[1]
+    # Weighted least squares on the actual composite quadrature (no
+    # continuous-orthogonality assumption).
+    gram = np.array([[w @ (s * s), w @ (s * c)], [w @ (s * c), w @ (c * c)]])
+    a_hat, b_hat = np.linalg.solve(gram, [w @ (v * s), w @ (v * c)])
+    ex, ey, _ = exact(x, y, t, length, viscosity)
+    exact_norm = w @ (ex * ex + ey * ey)
+    fit = a_hat * s + b_hat * c
+    longitudinal = (ux * k[0] + uy * k[1]) / math.sqrt(k @ k)
+    amplitude = U * math.exp(-decay_rate(length, viscosity) * t)
+    scale = amplitude * amplitude / 4  # continuum reference scale, not the TG norm
+    modal = math.hypot(a_hat, b_hat)
+    p = (rho - 1) / 3
+    p = p - w @ p / volume  # one global gauge
+    mass = float(w @ rho)
+    return dict(
+        tstar=t * U / length,
+        mass=mass,
+        mass_relative=(
+            0.0 if initial_mass is None else abs(mass - initial_mass) / initial_mass
+        ),
+        a_hat=float(a_hat),
+        b_hat=float(b_hat),
+        amplitude_exact=amplitude,
+        amplitude_ratio=float(a_hat / amplitude),
+        modal_amplitude=modal,
+        amplitude_error=modal / amplitude - 1,
+        phase_drift=float(math.atan2(b_hat, a_hat)),
+        phase_drift_abs=abs(float(math.atan2(b_hat, a_hat))),
+        velocity_l2=float(
+            np.sqrt(w @ ((ux - ex) ** 2 + (uy - ey) ** 2) / exact_norm)
+        ),
+        residual_l2=float(
+            np.sqrt(w @ ((ux - fit * E[0]) ** 2 + (uy - fit * E[1]) ** 2) / exact_norm)
+        ),
+        longitudinal_l2=float(np.sqrt(w @ (longitudinal**2) / exact_norm)),
+        spurious_pressure_rms=float(np.sqrt(w @ (p * p) / volume)),
+        spurious_pressure_scaled=float(np.sqrt(w @ (p * p) / volume) / scale),
+        spurious_pressure_max_scaled=float(np.max(np.abs(p)) / scale),
+        spurious_pressure_scaled_by_level=[
+            float(np.sqrt(w[lev == i] @ (p[lev == i] ** 2) / w[lev == i].sum()) / scale)
+            for i in range(len(masks))
+        ],
+        rho_min=float(rho.min()),
+        rho_max=float(rho.max()),
+        max_speed=float(np.max(np.hypot(ux, uy))),
+        leaf_cells=int(len(rho)),
+    )
+
+
+def fit_rate(rows, length, viscosity):
+    """Free-intercept least squares of ln R, R = hypot(a_hat, b_hat), late samples.
+
+    The intercept absorbs only a constant amplitude prefactor once a single
+    exponential dominates; per-interval rates and the fit residual are kept so
+    a lingering transient stays visible. Rates are per root step of the record
+    (uniform 2N uses its own nu and doubled step counts).
+    """
+    late = [r for r in rows if r["tstar"] >= FIT_FROM_TSTAR - 1e-12]
+    amp = np.array([math.hypot(r["a_hat"], r["b_hat"]) for r in late])
+    if len(late) < 3 or not np.isfinite(amp).all():
+        raise ValueError("need >= 3 late samples with finite R")
+    exact_rate = decay_rate(length, viscosity)
+    to_tstar = length / U  # root steps per unit t*
+    if not (amp > 0).all():
+        # Finite modal extinction: a physical failure, not malformed data. No
+        # clipping and no invented rate; fit quantities are unavailable.
+        return dict(rate_fit_valid=False, rate=None, exact_rate=exact_rate,
+                    rate_tstar=None, exact_rate_tstar=exact_rate * to_tstar,
+                    rate_error=None, interval_rate_errors=None, log_fit_residual_max=None)
+    t = np.array([r["step"] for r in late], dtype=float)
+    (slope, intercept) = np.polyfit(t, np.log(amp), 1)
+    residual = np.log(amp) - (slope * t + intercept)
+    return dict(
+        rate_fit_valid=True, rate=float(-slope), exact_rate=exact_rate,
+        rate_tstar=float(-slope * to_tstar),
+        exact_rate_tstar=exact_rate * to_tstar,  # = 5 (2 pi)^2 / Re
+        rate_error=abs(-slope / exact_rate - 1),
+        interval_rate_errors=[
+            float(-np.log(amp[i + 1] / amp[i]) / (t[i + 1] - t[i]) / exact_rate - 1)
+            for i in range(len(t) - 1)
+        ],
+        log_fit_residual_max=float(np.max(np.abs(residual))),
+    )
+
+
+NONNEGATIVE = ("tstar", "mass", "mass_relative", "amplitude_exact", "modal_amplitude",
+               "phase_drift_abs", "velocity_l2", "residual_l2", "longitudinal_l2",
+               "spurious_pressure_rms", "spurious_pressure_scaled",
+               "spurious_pressure_max_scaled", "rho_min", "rho_max", "max_speed")
+SIGNED = ("a_hat", "b_hat", "amplitude_ratio", "amplitude_error", "phase_drift")
+
+
+def _number(value):
+    return (isinstance(value, (int, float)) and not isinstance(value, bool)
+            and math.isfinite(value))
+
+
+def validate_rows(record):
+    """Exact schedule, finite numbers (incl. lists) and nonnegative error fields.
+
+    Signed quantities (amplitudes, amplitude/phase errors) keep their sign.
+    Raises ValueError so callers can report an invalid run before any screen.
+    """
+    n, rows = record["n"], record["rows"]
+    steps = [round(tstar * n / U) for tstar in TIMES]
+    if not isinstance(rows, list) or len(rows) != len(steps):
+        raise ValueError("rows do not match the scheduled samples")
+    for row, step in zip(rows, steps):
+        if type(row.get("step")) is not int or row["step"] != step:
+            raise ValueError(f"unscheduled or duplicate step {row.get('step')!r}")
+        if not _number(row.get("tstar")) or abs(row["tstar"] - step * U / n) > 3e-17:
+            raise ValueError(f"wrong sample time at step {step}")
+        if not all(_number(row.get(key)) for key in (*NONNEGATIVE, *SIGNED)):
+            raise ValueError(f"missing or nonfinite diagnostic at step {step}")
+        if any(row[key] < 0 for key in NONNEGATIVE) or row["rho_min"] <= 0:
+            raise ValueError(f"negative error quantity or density at step {step}")
+        levels = row.get("spurious_pressure_scaled_by_level")
+        if (not isinstance(levels, list) or len(levels) != record["depth"]
+                or not all(_number(v) and v >= 0 for v in levels)):
+            raise ValueError(f"invalid per-level pressure at step {step}")
+
+
+def summarize(record):
+    validate_rows(record)
+    rows = record["rows"]
+    n = record["n"]
+    out = fit_rate(rows, n, record["viscosity"])
+    out.update(
+        eps=eps(n),
+        complete=record["completed"] is True,
+        residual_l2=max(r["residual_l2"] for r in rows),
+        phase_drift_abs=max(r["phase_drift_abs"] for r in rows),
+        spurious_pressure_scaled=max(r["spurious_pressure_scaled"] for r in rows),
+        spurious_pressure_rms=max(r["spurious_pressure_rms"] for r in rows),
+        amplitude_error_abs=max(abs(r["amplitude_error"]) for r in rows),
+        velocity_l2=max(r["velocity_l2"] for r in rows),
+        mass_relative=max(r["mass_relative"] for r in rows),
+    )
+    if out["rate_fit_valid"] and not all(
+            _number(v) for v in (out["rate"], out["rate_error"], *out["interval_rate_errors"],
+                                 out["log_fit_residual_max"])):
+        raise ValueError("nonfinite rate fit")
+    out["own_screens_pass"] = out["complete"] and out["rate_fit_valid"] and all(
+        out[key] <= out["eps"] for key in ("rate_error", "phase_drift_abs", "residual_l2")
+    ) and all(out[key] <= limit for key, limit in LIMITS.items())
+    return out
+
+
+def _usable(record):
+    try:
+        out = summarize(record)
+    except (KeyError, TypeError, ValueError):
+        return None
+    return out if out["complete"] else None
+
+
+def assess(base_control, fine_control, refined):
+    """Uniform root-spacing and finest-spacing controls versus refined runs.
+
+    INVALID_CONTROL: missing, incomplete, invalid-row or mixed-source controls.
+    INVALID_RUN: a refined record has invalid rows (schedule, NaN, sign).
+    CONTROL_SCREEN_FAIL: complete valid controls that fail their own screens;
+    refined own-screen results are kept, but no controlled comparison passes.
+    PASS/FAIL: every refined run's controlled_pass (own screens and budgets).
+    """
+    if base_control is None or fine_control is None or not refined:
+        return dict(status="INVALID_CONTROL", reason="missing control or refined run")
+    n = base_control["n"]
+    if (base_control["depth"], fine_control["depth"], fine_control["n"]) != (1, 1, 2 * n):
+        raise ValueError("controls must be uniform N and uniform 2N")
+    if any(r["depth"] != 2 or r["n"] != n for r in refined):
+        raise ValueError("refined runs must be depth 2 at root N")
+    if len({r.get("explosion") for r in refined}) != len(refined):
+        raise ValueError("duplicate refined explosion scheme")
+    sources = {repr(r.get("source")) for r in [base_control, fine_control, *refined]}
+    base, fine = _usable(base_control), _usable(fine_control)
+    if base is None or fine is None or len(sources) != 1:
+        return dict(status="INVALID_CONTROL",
+                    reason="incomplete/invalid control or mixed source")
+    controls_pass = base["own_screens_pass"] and fine["own_screens_pass"]
+    report = dict(base_control=base, fine_control=fine, refined={},
+                  controls_pass=controls_pass)
+    statuses = []
+    for r in refined:
+        try:
+            s = summarize(r)
+        except (KeyError, TypeError, ValueError) as error:
+            report["refined"][r["explosion"]] = dict(valid=False, reason=str(error))
+            statuses.append("INVALID_RUN")
+            continue
+        s["valid"] = True
+        # rate_error is None when a modal fit is unavailable; never a pass.
+        s["budget"] = {
+            key: (None if base[key] is None else max(BASELINE_FACTOR * base[key], floor))
+            for key, floor in FLOORS.items()
+        }
+        s["budget_pass"] = all(
+            s[key] is not None and s["budget"][key] is not None and s[key] <= s["budget"][key]
+            for key in FLOORS)
+        s["control_ratios"] = {
+            name: {key: (s[key] / c[key] if s[key] is not None and c[key] else None)
+                   for key in (*FLOORS, "spurious_pressure_rms")}
+            for name, c in (("root", base), ("finest", fine))
+        }
+        s["controlled_pass"] = controls_pass and s["own_screens_pass"] and s["budget_pass"]
+        report["refined"][r["explosion"]] = s
+        statuses.append("PASS" if s["controlled_pass"] else "FAIL")
+    if "INVALID_RUN" in statuses:
+        report["status"] = "INVALID_RUN"
+    elif not controls_pass:
+        report["status"] = "CONTROL_SCREEN_FAIL"
+    else:
+        report["status"] = "PASS" if all(v == "PASS" for v in statuses) else "FAIL"
+    return report

tests/validation/taylor_green/test_projected_pairs.py

@@ -319,7 +319,7 @@ class ProjectedPairsTests(unittest.TestCase):
                  patch.object(run_case, "runtime_identity", side_effect=AssertionError("CUDA reached")), \
                  redirect_stdout(stdout):
                 self.assertEqual(run_case.main(), 0)
-            verify.assert_called_once_with(REPO, MOCK_REVISION)
+            verify.assert_called_once_with(REPO, MOCK_REVISION, "taylor_green")
             self.assertTrue(json.loads(stdout.getvalue())["dry_run"])
             self.assertFalse(output.exists())
 
@@ -412,7 +412,7 @@ class ProjectedPairsTests(unittest.TestCase):
                     else:
                         self.assertEqual(run_case.main(), 0)
                 receipt = json.loads(output.read_text())
-                verify.assert_called_once_with(REPO, MOCK_REVISION)
+                verify.assert_called_once_with(REPO, MOCK_REVISION, "taylor_green")
                 self.assertEqual(selectors, ["projected_linear" if early else "constant"] if depth == 2 else [])
                 self.assertEqual(receipt["source"], source())
                 self.assertEqual(receipt["runtime_identity"], RUNTIME)

tests/validation/taylor_green/test_shear_wave.py

@@ -0,0 +1,471 @@
+"""Standalone CPU manufactured checks for the oblique shear wave.
+
+Run from this directory with PYTHONPATH=<checkout>/src (same as test_oracle.py).
+"""
+
+import hashlib
+import json
+import math
+import unittest
+from pathlib import Path
+
+import numpy as np
+import oracle
+import run_case
+import shear_wave as sw
+from oracle import CX, CY, U, TIMES, centers, rectangles
+
+N = 32
+NU = U * N / sw.RE
+HERE = Path(__file__).resolve().parent
+ORACLE_SHA256_EEC4677 = "83e4d7425d45538278e9fb181af450a36358bd9a5ed6be57ff611dd9ae5eb35b"
+
+
+def composite_masks(n):
+    """Level-wide union masks for rectangles(n, 2): root complement + fine box."""
+    (x0, y0, x1, y1), = rectangles(n, 2)[0]
+    root = np.ones((n, n), dtype=bool)
+    root[y0:y1, x0:x1] = False
+    fine = np.zeros((2 * n, 2 * n), dtype=bool)
+    fine[2 * y0:2 * y1, 2 * x0:2 * x1] = True
+    return [root, fine]
+
+
+def populations(masks, field, t=0.0):
+    """Equilibrium G of an arbitrary (ux, uy, rho) field on every level."""
+    out = []
+    for level, m in enumerate(masks):
+        x, y = centers(m.shape, level)
+        ux, uy, rho = field(x, y, t)
+        out.append(sw.equilibrium(rho, ux, uy))
+    return out
+
+
+def exact_field(phase=0.0, rate_factor=1.0, mode=sw.MODE, longitudinal=0.0, ripple=0.0,
+                offset=0.0):
+    k = 2 * np.pi / N * np.array(mode, dtype=float)
+    e = np.array([-mode[1], mode[0]], dtype=float) / math.hypot(*mode)
+    rate = rate_factor * sw.decay_rate(N, NU)
+    kh = k / np.linalg.norm(k)
+
+    def field(x, y, t):
+        theta = k[0] * x + k[1] * y + phase
+        a = U * np.exp(-rate * t)
+        ux = a * e[0] * np.sin(theta) + longitudinal * kh[0] * np.sin(theta)
+        uy = a * e[1] * np.sin(theta) + longitudinal * kh[1] * np.sin(theta)
+        rho = 1 + offset + ripple * np.cos(theta)
+        return ux, uy, rho
+
+    return field
+
+
+class ConventionTests(unittest.TestCase):
+    def test_mode_angle_and_polarization(self):
+        k = sw.wavevector(N)
+        self.assertAlmostEqual(sw.ANGLE_DEG, 26.565051177077994)
+        self.assertAlmostEqual(math.degrees(math.atan2(k[1], k[0])), sw.ANGLE_DEG)
+        self.assertAlmostEqual(float(sw.E @ k), 0.0)
+        self.assertAlmostEqual(float(sw.E @ sw.E), 1.0)
+        self.assertAlmostEqual(sw.eps(128), 5 * (2 * math.pi / 128) ** 2)
+
+    def test_navier_stokes_and_vanishing_advection(self):
+        # Independent central differences: du/dt = nu lap u, (u.grad)u = 0, div u = 0.
+        x = np.array([2.7, 8.1, 13.3])
+        y = np.array([3.2, 7.4, 21.6])
+        t, h = 10.0, 1e-3
+        f = lambda x, y, t: np.array(sw.exact(x, y, t, N, NU)[:2])
+        z = f(x, y, t)
+        dt = (f(x, y, t + h) - f(x, y, t - h)) / (2 * h)
+        dx = (f(x + h, y, t) - f(x - h, y, t)) / (2 * h)
+        dy = (f(x, y + h, t) - f(x, y - h, t)) / (2 * h)
+        lap = (f(x + h, y, t) + f(x - h, y, t) + f(x, y + h, t) + f(x, y - h, t) - 4 * z) / h**2
+        np.testing.assert_allclose(dt, NU * lap, atol=1e-9)
+        # Analytic identities: div u = A cos(theta) (E.k) and (u.grad)u = A sin(theta) (E.k) u/A.
+        k = sw.wavevector(N)
+        self.assertLess(abs(float(sw.E @ k)), 1e-17)
+        # Central differences do not cancel exactly: each derivative carries
+        # -(k_j h)^2/6 relative truncation, so div_h = -A cos(theta) h^2/6 sum_j E_j k_j^3
+        # + O(h^4) (nonzero for an oblique k). Bound it with that leading term plus roundoff.
+        a = U * math.exp(-sw.decay_rate(N, NU) * t)
+        trunc = a * h * h / 6 * float(np.abs(sw.E * k**3).sum()) * 1.01
+        # Argument rounding: eps*max|x|/h*U*|k| ~ 2.2e-16*21.6/1e-3*0.03*0.44 ~ 6e-14.
+        roundoff = 1e-13
+        self.assertLess(np.max(np.abs(dx[0] + dy[1])), trunc + roundoff)
+        # Discrete advection: same truncation scaled by |u| <= a.
+        self.assertLess(np.max(np.abs(z[0] * dx + z[1] * dy)), a * trunc + roundoff)
+        # Halving h reduces the divergence truncation about fourfold.
+        hh = h / 2
+        div2 = ((f(x + hh, y, t) - f(x - hh, y, t))[0] + (f(x, y + hh, t) - f(x, y - hh, t))[1]) / (2 * hh)
+        np.testing.assert_allclose(div2 * 4, dx[0] + dy[1], rtol=1e-2, atol=6 * roundoff)
+        self.assertTrue(np.all(sw.exact(x, y, t, N, NU)[2] == 0))
+
+
+class InitialTests(unittest.TestCase):
+    def test_moments_on_each_level(self):
+        for level, m in enumerate(composite_masks(N)):
+            g = sw.initial(m.shape, level, N, NU)
+            x, y = centers(m.shape, level)
+            ux, uy, _ = sw.exact(x, y, 0.0, N, NU)
+            rho = g.sum(axis=0)
+            np.testing.assert_allclose(rho, 1.0, atol=1e-14)
+            np.testing.assert_allclose(np.tensordot(CX, g, 1) / rho, ux, atol=1e-15)
+            np.testing.assert_allclose(np.tensordot(CY, g, 1) / rho, uy, atol=1e-15)
+
+    def test_equilibrium_matches_frozen_oracle_formula(self):
+        # Same equilibrium as oracle.initial when fed the TG field.
+        shape = (8, 8)
+        x, y = centers(shape, 1)
+        ux, uy, p = oracle.exact(x, y, 0.0, 4.0, 0.01)
+        np.testing.assert_array_equal(
+            sw.equilibrium(1 + 3 * p, ux, uy), oracle.initial(shape, 1, 4.0, 0.01)
+        )
+
+
+class MetricTests(unittest.TestCase):
+    def setUp(self):
+        self.masks = composite_masks(N)
+
+    def sample(self, field, t):
+        return sw.metrics(populations(self.masks, field, t), self.masks, t, N, NU, None)
+
+    def test_exact_field_on_composite_partition(self):
+        for t in (0.0, 100.0, 512.0):
+            r = self.sample(exact_field(), t)
+            self.assertLess(r["velocity_l2"], 1e-12)
+            self.assertLess(r["residual_l2"], 1e-12)
+            self.assertLess(r["longitudinal_l2"], 1e-12)
+            self.assertLess(r["phase_drift_abs"], 1e-12)
+            self.assertAlmostEqual(r["amplitude_ratio"], 1.0, places=12)
+            self.assertLess(abs(r["amplitude_error"]), 1e-12)
+            self.assertLess(r["spurious_pressure_scaled"], 1e-10)
+            self.assertEqual(len(r["spurious_pressure_scaled_by_level"]), 2)
+        self.assertEqual(r["leaf_cells"], int(sum(m.sum() for m in self.masks)))
+
+    def test_phase_control(self):
+        r = self.sample(exact_field(phase=0.01), 0.0)
+        self.assertAlmostEqual(r["phase_drift"], 0.01, delta=1e-9)
+        self.assertLess(abs(r["amplitude_error"]), 1e-12)  # R = hypot(a, b) is phase-free
+        self.assertLess(r["residual_l2"], 1e-12)  # a pure phase shift stays modal
+
+    def test_rate_control_and_fit(self):
+        for factor, expected in ((1.0, 0.0), (1.01, 0.01)):
+            field = exact_field(rate_factor=factor)
+            rows = []
+            for tstar in TIMES:
+                step = round(tstar * N / U)
+                rows.append(dict(self.sample(field, step), step=step))
+            fit = sw.fit_rate(rows, N, NU)
+            self.assertAlmostEqual(fit["rate_error"], expected, delta=1e-9)
+            np.testing.assert_allclose(fit["interval_rate_errors"], expected, atol=1e-9)
+            self.assertLess(fit["log_fit_residual_max"], 1e-9)
+            self.assertAlmostEqual(fit["exact_rate_tstar"], 5 * (2 * math.pi) ** 2 / sw.RE)
+            self.assertAlmostEqual(fit["exact_rate_tstar"], 1.97392088, places=8)
+
+    def test_fit_ignores_startup_sample(self):
+        rows = [dict(tstar=0.0, step=0, a_hat=2 * U, b_hat=0.0)]
+        rows += [dict(tstar=s, step=round(s * N / U), b_hat=0.0,
+                      a_hat=U * math.exp(-sw.decay_rate(N, NU) * round(s * N / U)))
+                 for s in TIMES[1:]]
+        self.assertLess(sw.fit_rate(rows, N, NU)["rate_error"], 1e-12)
+        rows[-1]["a_hat"] = float("nan")
+        with self.assertRaises(ValueError):
+            sw.fit_rate(rows, N, NU)
+
+    def test_wrong_mode_control(self):
+        # Swapping (2,1) for (1,2), i.e. 26.6 vs 63.4 deg, is not silently modal.
+        # Composite quadrature need not give an exactly zero projection.
+        r = self.sample(exact_field(mode=(1, 2)), 0.0)
+        self.assertLess(abs(r["amplitude_ratio"]), 0.05)
+        self.assertGreater(r["residual_l2"], 0.95)
+
+    def test_longitudinal_control(self):
+        r = self.sample(exact_field(longitudinal=1e-3), 0.0)
+        self.assertAlmostEqual(r["longitudinal_l2"], 1e-3 / U, delta=1e-9)
+        # The full-vector residual and velocity error see it too.
+        self.assertAlmostEqual(r["residual_l2"], 1e-3 / U, delta=1e-9)
+        self.assertAlmostEqual(r["velocity_l2"], 1e-3 / U, delta=1e-9)
+        self.assertLess(r["phase_drift_abs"], 1e-12)
+        self.assertAlmostEqual(r["amplitude_ratio"], 1.0, places=12)
+
+    def test_pressure_gauge_and_ripple(self):
+        r = self.sample(exact_field(offset=1e-4), 0.0)
+        self.assertLess(r["spurious_pressure_scaled"], 1e-10)  # one global gauge
+        ripple = 3e-5
+        r = self.sample(exact_field(ripple=ripple), 0.0)
+        # p = ripple/3 cos(theta); rms over a whole number of periods = ripple/(3 sqrt 2).
+        # Composite midpoint quadrature is not exactly periodic: 3% tolerance.
+        expected = ripple / (3 * math.sqrt(2)) / (U * U / 4)
+        self.assertAlmostEqual(r["spurious_pressure_scaled"], expected, delta=0.03 * expected)
+        self.assertAlmostEqual(r["spurious_pressure_rms"], expected * U * U / 4,
+                               delta=0.03 * expected * U * U / 4)
+
+    def test_volume_weighting_and_double_count(self):
+        bad = [np.ones_like(m) for m in self.masks]
+        with self.assertRaises(ValueError):
+            sw.metrics(populations(bad, exact_field()), bad, 0.0, N, NU)
+        # Unweighted (count-based) averaging would change the fit; weights matter.
+        r = self.sample(exact_field(), 0.0)
+        self.assertEqual(r["leaf_cells"], N * N - self.masks[1].sum() // 4 + self.masks[1].sum())
+
+
+def record(n, depth, rows, explosion="constant", completed=True, source="s"):
+    for row in rows:
+        row["spurious_pressure_scaled_by_level"] = [row["spurious_pressure_scaled"]] * depth
+    return dict(n=n, depth=depth, viscosity=U * n / sw.RE, rows=rows, completed=completed,
+                explosion=explosion, source=source)
+
+
+def rows_for(n, rate_error=0.0, residual=1e-4, pressure=1e-3, phase=0.0):
+    rate = (1 + rate_error) * sw.decay_rate(n, U * n / sw.RE)
+    out = []
+    for tstar in TIMES:
+        step = round(tstar * n / U)
+        amp = U * math.exp(-rate * step)
+        out.append(dict(tstar=step * U / n, step=step, a_hat=amp, b_hat=0.0,
+                        amplitude_ratio=1.0, modal_amplitude=amp, amplitude_exact=amp,
+                        phase_drift=phase, mass=float(n * n), rho_min=0.999, rho_max=1.001,
+                        max_speed=amp, longitudinal_l2=0.0, spurious_pressure_max_scaled=pressure,
+                        amplitude_error=0.0, residual_l2=residual, phase_drift_abs=phase,
+                        spurious_pressure_scaled=pressure,
+                        spurious_pressure_rms=pressure * U * U / 4,
+                        velocity_l2=residual, mass_relative=0.0))
+    return out
+
+
+class AssessTests(unittest.TestCase):
+    def test_budget_form_is_max_not_sum(self):
+        base = record(128, 1, rows_for(128, rate_error=1e-3, pressure=0.015))
+        fine = record(256, 1, rows_for(256, rate_error=2e-4))
+        # rate budget = max(2*1e-3, 0.002) = 0.002; 0.0025 would pass a sum form.
+        refined = record(128, 2, rows_for(128, rate_error=0.0025))
+        report = sw.assess(base, fine, [refined])
+        self.assertEqual(report["status"], "FAIL")
+        self.assertAlmostEqual(report["refined"]["constant"]["budget"]["rate_error"], 0.002)
+        # pressure budget = max(2*0.015, 0.02) = 0.03 (control-dominated).
+        self.assertAlmostEqual(
+            report["refined"]["constant"]["budget"]["spurious_pressure_scaled"], 0.03)
+        self.assertIn("finest", report["refined"]["constant"]["control_ratios"])
+        ok = record(128, 2, rows_for(128, rate_error=0.0015), explosion="projected_linear")
+        self.assertEqual(sw.assess(base, fine, [ok])["status"], "PASS")
+
+    def test_control_outcomes_are_distinct(self):
+        fine = record(256, 1, rows_for(256))
+        refined = record(128, 2, rows_for(128))
+        failing = record(128, 1, rows_for(128, residual=0.5))  # complete, > eps(128)
+        report = sw.assess(failing, fine, [refined])
+        self.assertEqual(report["status"], "CONTROL_SCREEN_FAIL")
+        own = report["refined"]["constant"]
+        self.assertTrue(own["own_screens_pass"])  # refined own screens kept
+        self.assertFalse(own["controlled_pass"])  # but no controlled comparison passes
+        good = record(128, 1, rows_for(128))
+        self.assertEqual(sw.assess(None, fine, [refined])["status"], "INVALID_CONTROL")
+        incomplete = record(128, 1, rows_for(128), completed=False)
+        self.assertEqual(sw.assess(incomplete, fine, [refined])["status"], "INVALID_CONTROL")
+        mixed = record(256, 1, rows_for(256), source="other")
+        self.assertEqual(sw.assess(good, mixed, [refined])["status"], "INVALID_CONTROL")
+
+    def test_invalid_rows_are_rejected_before_screens(self):
+        base = record(128, 1, rows_for(128))
+        fine = record(256, 1, rows_for(256))
+        for mutate in (
+            lambda rows: rows[2].update(rho_min=float("nan")),
+            lambda rows: rows[2].update(spurious_pressure_scaled_by_level=[0.0, float("nan")]),
+            lambda rows: rows[2].update(step=rows[1]["step"], tstar=rows[1]["tstar"]),
+            lambda rows: rows[2].update(residual_l2=-1e-6),
+            lambda rows: rows[2].pop("longitudinal_l2"),
+        ):
+            refined = record(128, 2, rows_for(128))
+            mutate(refined["rows"])
+            self.assertEqual(sw.assess(base, fine, [refined])["status"], "INVALID_RUN")
+        # Legitimate signs stay allowed: negative amplitude and phase errors.
+        refined = record(128, 2, rows_for(128))
+        for row in refined["rows"]:
+            row.update(amplitude_error=-1e-3, phase_drift=-1e-4, phase_drift_abs=1e-4)
+        report = sw.assess(base, fine, [refined])
+        self.assertEqual(report["status"], "PASS")
+        self.assertEqual(sw.assess(base, fine, [])["status"], "INVALID_CONTROL")
+        with self.assertRaises(ValueError):
+            sw.assess(base, fine, [record(128, 2, rows_for(128)), record(128, 2, rows_for(128))])
+
+    def test_modal_extinction_is_a_failure_not_malformed(self):
+        def extinct(rows):
+            for row in rows[1:]:
+                row.update(a_hat=0.0, b_hat=0.0, modal_amplitude=0.0, amplitude_ratio=0.0,
+                           amplitude_error=-1.0)
+            return rows
+        base = record(128, 1, rows_for(128))
+        fine = record(256, 1, rows_for(256))
+        refined = record(128, 2, extinct(rows_for(128)))
+        report = sw.assess(base, fine, [refined])
+        self.assertEqual(report["status"], "FAIL")
+        own = report["refined"]["constant"]
+        self.assertTrue(own["valid"])
+        self.assertFalse(own["rate_fit_valid"])
+        self.assertIsNone(own["rate_error"])
+        self.assertIsNone(own["control_ratios"]["root"]["rate_error"])
+        self.assertFalse(own["own_screens_pass"] or own["controlled_pass"] or own["budget_pass"])
+        self.assertEqual(own["residual_l2"], 1e-4)  # other finite metrics retained
+        json.loads(json.dumps(report, allow_nan=False))
+        control = sw.assess(record(128, 1, extinct(rows_for(128))), fine,
+                            [record(128, 2, rows_for(128))])
+        self.assertEqual(control["status"], "CONTROL_SCREEN_FAIL")
+        self.assertIsNone(control["refined"]["constant"]["budget"]["rate_error"])
+        self.assertFalse(control["refined"]["constant"]["controlled_pass"])
+        json.loads(json.dumps(control, allow_nan=False))
+
+    def test_wrong_shapes(self):
+        base = record(128, 1, rows_for(128))
+        fine = record(256, 1, rows_for(256))
+        refined = record(128, 2, rows_for(128))
+        with self.assertRaises(ValueError):
+            sw.assess(base, record(128, 1, rows_for(128)), [refined])
+        with self.assertRaises(ValueError):
+            sw.assess(record(128, 1, rows_for(128)), fine, [record(256, 2, rows_for(256))])
+
+    def test_incomplete_record_fails(self):
+        base = record(128, 1, rows_for(128))
+        fine = record(256, 1, rows_for(256))
+        refined = record(128, 2, rows_for(128), completed=False)
+        self.assertEqual(sw.assess(base, fine, [refined])["status"], "FAIL")
+
+
+class FakeRun:
+    def __init__(self, arrays):
+        self.arrays = arrays
+
+    def download(self):
+        return self.arrays if len(self.arrays) > 1 else self.arrays[0]
+
+
+class RunnerSampleTests(unittest.TestCase):
+    def test_refined_shear_sample_with_list_diagnostics(self):
+        masks = composite_masks(N)
+        arrays = [sw.initial(m.shape, level, N, NU) for level, m in enumerate(masks)]
+        row = run_case.sample(FakeRun(arrays), masks, 0, N, NU, None, sw.metrics, 2)
+        self.assertIsInstance(row["spurious_pressure_scaled_by_level"], list)
+        self.assertTrue(run_case.finite_row(row))
+        bad = [a.copy() for a in arrays]
+        bad[1][0, masks[1]] = np.nan
+        with self.assertRaises(FloatingPointError):
+            run_case.sample(FakeRun(bad), masks, 0, N, NU, None, sw.metrics, 2, "READY")
+        self.assertFalse(run_case.finite_row(dict(a=1.0, b=[0.0, float("inf")])))
+
+    def test_taylor_green_sample_unchanged(self):
+        masks = composite_masks(N)
+        arrays = [oracle.initial(m.shape, level, N, NU) for level, m in enumerate(masks)]
+        row = run_case.sample(FakeRun(arrays), masks, 0, N, NU, None, oracle.metrics, 2)
+        self.assertEqual(row, oracle.metrics(arrays, masks, 0, N, NU, None))
+        uniform = [oracle.initial((N, N), 0, N, NU)]
+        row = run_case.sample(FakeRun(uniform), [np.ones((N, N), bool)], 0, N, NU, None,
+                              oracle.metrics, 1)
+        self.assertEqual(row["leaf_cells"], N * N)
+
+
+def receipt(n, depth, explosion="constant"):
+    """Synthetic receipt satisfying every contract field of the fixed four-case set."""
+    import assess_projected_pairs as tg
+    steps = run_case.sample_steps(n)[0]
+    rows = rows_for(n)
+    for row, step in zip(rows, steps):
+        row.update(step=step, tstar=step * U / n,
+                   spurious_pressure_scaled_by_level=[row["spurious_pressure_scaled"]] * depth)
+    cells = [n * n] if depth == 1 else [8704, 30720]
+    hops = [16 * n * 2**level for level in range(depth)]
+    builds = []
+    for level in range(depth):
+        size = n * 2**level
+        builds.append(dict(source_sha256=tg.BUILD_SOURCES[size], arch="sm_70",
+                           flags=["--use_fast_math"], n_objects=0, ptx_sha256="a" * 64,
+                           config=dict(nx=10, ny=10, nz=1, lattice_model="D2Q9", collision="SRT",
+                                       store_precision="FP32", streaming="double_buffer",
+                                       ddf_shifting=True, les_enabled=False, velocity=0.0,
+                                       viscosity=U * size / 100, rho=1.0,
+                                       omega=1 / (.5 + 3 * U * size / 100),
+                                       threads_per_block=256)))
+    checkout = "/x/CelerisLab"
+    return dict(
+        n=n, depth=depth, re_L=100, explosion=explosion, U=U, mach=U * math.sqrt(3),
+        viscosity=U * n / 100, tau_by_level=[0.5 + 3 * U * n / 100 * 2**l for l in range(depth)],
+        source=dict(revision="r", dirty=False, source_tree_sha256=run_case.SOURCE_SHA256,
+                    harness_sha256={"x.py": "h"}, build_capture_sha256=run_case.BUILD_CAPTURE_SHA256,
+                    shear_wave_sha256=run_case.SHEAR_WAVE_SHA256),
+        runtime_identity=dict(device=dict(name="V100", pci_bus_id="0", capability=[7, 0],
+                                          driver=1, runtime=[12, 0]),
+                              nvcc_path="/nvcc", nvcc_version="v", python="3", numpy="1",
+                              pycuda="2"),
+        runtime_source=dict(checkout=checkout, module=checkout + "/src/CelerisLab/__init__.py",
+                            compiler=checkout + "/src/CelerisLab/cuda/compiler_v2.py",
+                            kernel_root=checkout + "/src/CelerisLab/lbm/kernels"),
+        cuda_visible_devices="0", numerical_revision=run_case.NUMERICAL_REVISION,
+        reference_harness=run_case.REFERENCE_HARNESS, numerics=dict(tg.NUMERICS),
+        initialization=sw.INITIALIZATION, limits=dict(sw.LIMITS),
+        early_pressure=dict(enabled=False, rows=[], sampled_max_pressure_l2=None),
+        refinements=[] if depth == 1 else rectangles(n, depth),
+        workload=dict(active_cells_by_level=cells, level_hops=hops, root_intervals=16 * n,
+                      active_collision_updates_by_level=[c * h for c, h in zip(cells, hops)],
+                      active_collision_updates=sum(c * h for c, h in zip(cells, hops))),
+        actual_build_sidecars=builds, rows=rows, completed=True,
+        flow="shear_wave", mode=list(sw.MODE), polarization=sw.E.tolist(),
+        angle_deg=sw.ANGLE_DEG, phase=sw.PHI, eps=sw.eps(n))
+
+
+class ContractTests(unittest.TestCase):
+    def setUp(self):
+        import assess_shear_wave
+        self.assess = assess_shear_wave.assess
+        self.records = [receipt(128, 1), receipt(256, 1), receipt(128, 2),
+                        receipt(128, 2, "projected_linear")]
+
+    def test_complete_contract_passes(self):
+        result = self.assess(self.records, "r")
+        self.assertTrue(result["contract_valid"], [k for k, v in result["checks"].items() if not v])
+        self.assertEqual(result["status"], "PASS")
+
+    def test_reproduced_false_passes_are_rejected(self):
+        a = self.assess
+        self.assertEqual(a(self.records[:2], "r")["status"], "INVALID_SET")  # empty refined
+        dup = [*self.records[:3], receipt(128, 2)]
+        self.assertEqual(a(dup, "r")["status"], "INVALID_SET")  # duplicate constant-only
+        for mutate in (
+            lambda r: r.pop("source"),
+            lambda r: r.update(flow="taylor_green"),
+            lambda r: r.update(mode=[1, 2]),
+            lambda r: r.update(re_L=1000),
+            lambda r: r.update(refinements=[[(0, 0, 8, 8)]]),
+            lambda r: r["actual_build_sidecars"][0].update(arch="sm_80"),
+            lambda r: r["rows"][0].update(step=1, tstar=U / 128),  # wrong initial time
+            lambda r: r["source"].update(shear_wave_sha256="0" * 64),
+        ):
+            records = [dict(r, rows=[dict(x) for x in r["rows"]],
+                            source=dict(r["source"]),
+                            actual_build_sidecars=[dict(b) for b in r["actual_build_sidecars"]])
+                       for r in self.records]
+            mutate(records[2])
+            self.assertEqual(a(records, "r")["status"], "INVALID_SET")
+        mixed = [dict(r) for r in self.records]
+        mixed[1] = dict(mixed[1], source=dict(mixed[1]["source"], revision="other"))
+        self.assertEqual(a(mixed, "r")["status"], "INVALID_SET")
+        self.assertEqual(a(self.records, "wrong-revision")["status"], "INVALID_SET")
+
+
+class DefaultPathTests(unittest.TestCase):
+    def test_frozen_oracle_is_byte_identical(self):
+        digest = hashlib.sha256((HERE / "oracle.py").read_bytes()).hexdigest()
+        self.assertEqual(digest, ORACLE_SHA256_EEC4677)
+
+    def test_default_flow_is_frozen_taylor_green(self):
+        init, met, limits, text = run_case.flow_functions()
+        self.assertIs(init, oracle.initial)
+        self.assertIs(met, oracle.metrics)
+        self.assertIs(limits, oracle.LIMITS)
+        self.assertEqual(text, run_case.INITIALIZATION)
+        self.assertEqual(run_case.flow_functions("taylor_green"), (init, met, limits, text))
+        shear = run_case.flow_functions("shear_wave")
+        self.assertIs(shear[0], sw.initial)
+        self.assertIs(shear[1], sw.metrics)
+        with self.assertRaises(ValueError):
+            run_case.flow_functions("tg")
+
+
+if __name__ == "__main__":
+    unittest.main()