research: reuse quadrature and clarify snapshot and VIV coordinates

Index values are unchanged (1, 3, 7, 10, 13); the run recorded at fb507aa1
used the same columns. Research-only.

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

BASELINE_JET_AMR.txt

@@ -0,0 +1,85 @@
+Jet / fixed-patch review baseline — 2026-10-15
+
+Base main: 6e3756c587ec08ab6a55c4a1a5f4671822d3f0a0
+Branch: baseline/jet-amr-20261014
+Publication target: Gitea Frank14f/CelerisLab only. This baseline does not
+advance main, publish to GitHub, or add new solver behavior.
+
+Scope
+The approved inventory contributes 43 previously tracked modifications and
+282 new files: D2 correctness/build/state repairs; planar slot/reservoir jet;
+static-circle surface actuation; one fixed 2:1 refinement patch; fine-interior
+circle integration; tests, examples and small historical validation records.
+Three reviewed repair logs are additionally retained: final-unit.log,
+final-gpu.log and simplification-checks.log. This explanation is the only new
+project document. Total: 329 changed/added paths relative to base main.
+
+Implementation: ed1a6ee54e07a5efbdc3f1880fde4cc357b10d7c (41 files)
+Tests/examples: cdbb9c42f6bfc65ec319313fb4e16cdc04dfdb95 (48 files)
+Historical evidence: 263f3b0c7addce7bacbb068f75ea707cf20b6810 (239 files)
+Historical source snapshots are evidence, not alternative runtime modules.
+
+Explicit exclusions
+The user's local changes to src/CelerisLab/lbm/kernels/config/config_grid.h,
+config_method.h, config_objects.h, config_physics.h and
+tests/postproc/experiment.ipynb are not included. Their already committed
+base-main versions remain in the tree. Their five original-user-files backups
+are excluded. Also excluded: the six pre-existing docs/design files,
+docs/multilevel_grid_architecture_analysis.md, tests/audit/body删减功能.md,
+tests/validation/multigrid/MULTIGRID_VERIFICATION_STRATEGY.md, the twenty files
+under research/audit-2026-10-09 and research/design-2026-10-09,
+research/j3-lag-2026-10-12/trajectory.h5, caches and the other twenty-two ignored
+historical output files. These exclusions preserve local originals; they are
+not deletions from the working copy. Historical manifests/reports can reference
+excluded material. In particular analyze_j3_saved_frames.py needs the omitted
+17.2 MB trajectory, and historical example images/summaries are not all bundled.
+This is a selected review baseline, not a self-contained archival data package.
+
+Fresh clean-checkout checks
+Detached checkout of 263f3b0c7addce7bacbb068f75ea707cf20b6810 was clean before
+and after both successful batches. Its four generated config headers and
+experiment notebook were byte-equal to base main; excluded untracked files
+were absent. Existing pycuda_3_10 interpreter; PYTHONPATH explicitly selected
+the clean checkout's src, which was asserted at startup. CUDA_VISIBLE_DEVICES
+was empty. No CUDA context/GPU simulation or new CFD trajectory was requested.
+
+pytest selection 1 (tests/unit): test_refinement.py, test_fine_surface.py.
+Result: 24 passed, 23 subtests passed, exit 0; pytest time 0.75 seconds.
+pytest selection 2 (tests/unit): test_build_contracts.py,
+test_context_ownership.py, test_initializers.py, test_simulation_lifecycle.py,
+test_state_regressions.py, test_surface_actuation.py, test_planar_velocity.py,
+test_slot_velocity.py, test_reservoir.py.
+Result: 152 passed, 13 subtests passed, exit 0; pytest time 5.06 seconds.
+Both used -q -p no:cacheprovider, PYTHONNOUSERSITE=1,
+PYTHONDONTWRITEBYTECODE=1, PYTEST_DISABLE_PLUGIN_AUTOLOAD=1,
+OPENBLAS_NUM_THREADS=1 and OMP_NUM_THREADS=1. Boundary-header tests use the
+existing C++ compiler; compilation-contract tests mock the CUDA compiler.
+
+The first host-contract batch was interrupted when the temporary monitoring
+script raced a removed private build directory. Its test exit is unknown;
+it is not counted as a pass. Only the monitor was corrected and that batch
+rerun; the initial geometry batch was not repeated. Project code and test
+criteria were unchanged. The final documentation-only commit does not alter
+the tested implementation, tests, configuration or historical evidence.
+
+Historical limits retained
+- J3 positive/negative full velocity steady-state criteria did not pass.
+- The local-stress implementation README records Claude's review as incomplete;
+  numerical execution is not a substitute for that implementation review.
+- repair provenance.json retains earlier 124/66 totals; final logs record
+  130 unit +13 subtests and 74 GPU tests. simplification-checks.log describes
+  an earlier phase with known XFAILs, not a new result on this baseline.
+- The 24-coarse-step joint run demonstrates startup disturbances crossing the
+  interface, potentially acoustic. It does not establish a developed jet,
+  physical accuracy, convergence order or long-term stability. Raw FP32 mass
+  residuals remain nonzero despite the independently measured rounding ledger.
+- Fixed-patch support is not dynamic/block-level AMR, moving rigid bodies,
+  complete 3D or multi-GPU support. Historical full suites were not rerun here.
+
+Publication screening
+Approved candidate bytes and the three logs were checked for common embedded
+credential/private-key patterns and unrelated private-location indicators;
+unchanged tracked blobs and staged content were also checked. No findings were
+detected. This bounded check is not a general security audit. Excluded files
+were hash-protected. No credentials, accounts, environments or remotes were
+modified by the baseline preparation.

README.md

@@ -90,6 +90,140 @@ sim.run(100, stream=stream, upload_act=False, sync_obs=False)
 # Later: sync and read
 stream.synchronize()
 obs = sim.read_bodies(stream=stream)  # sync already done, just read pinned buffer
+```
+
+### Fixed 2:1 refinement patch (experimental backend)
+
+`FixedPatchStepper` advances one fixed 2:1 refinement patch inside a coarse
+grid, optionally with stationary circles in the fine region and a prescribed
+normal surface velocity (blowing/suction). It is a standalone backend, not part
+of `Simulation`. Runnable demo (blocked fine storage; omit `--fine-block`
+for dense): `PYTHONPATH="$PWD/src" python examples/fixed_patch_circle.py --fine-block 16 20`.
+
+```python
+import numpy as np
+from CelerisLab.body.geometry.circle import CircleGeometry
+from CelerisLab.body.objects import SimObject, SurfaceActuation
+from CelerisLab.config import LBMConfig
+from CelerisLab.cuda.context import CudaContext
+from CelerisLab.lbm.equilibrium import compute_feq_d2q9
+from CelerisLab.lbm.refinement_stepper import FixedPatchStepper
+
+cfg = LBMConfig(nx=32, ny=24, viscosity=.1)
+body = SimObject(0, geometry=CircleGeometry(16.0, 12.0, 2.15), center=(16.0, 12.0), radius=2.15,
+                 surface_actuation=SurfaceActuation(0.7, 0.85, 0.002))  # angle, half-width, speed
+with CudaContext(0) as ctx, FixedPatchStepper(cfg, context=ctx, refinements=[(8, 6, 24, 18)],
+                                              level_blocks=[None, (16, 20)],
+                                              level_objects=[(), (body,)]) as run:
+    rest = np.asarray(compute_feq_d2q9(1.0, 0.0, 0.0), np.float32)[:, None, None]
+    # (9, ny, nx) postcollision populations per level; non-leaf cells are discarded.
+    run.initialize(np.broadcast_to(rest, (9, *run.hierarchy.pairs[0].coarse_shape)),
+                   np.broadcast_to(rest, (9, *run.hierarchy.pairs[0].fine_shape)))
+    run.step(128)                      # coarse steps; fine level takes two per step
+    coarse_g, fine_g = run.download()  # NaN on covered, ghost and solid cells
+```
+
+Scope and limits:
+- The examples below use D2Q9, SRT, FP32, double buffer, unshifted, no LES or
+  forcing. Fixed 2:1 hierarchies use level lists of arbitrary depth; two- and
+  three-level examples below use that same constructor.
+- `coarse_boundary="periodic"` (default) or `"slot_reservoir"` (bottom slot, top
+  reservoir; patch needs `y0 >= 4`, `y1 <= ny-4`). Periodic mode ignores the wall/slot config fields.
+- Object centers/radii use the coarse **cell-edge** frame (cell `I` spans `[I, I+1)`),
+  unlike `Simulation`'s integer-node frame. Surface speeds are in coarse lattice units.
+- Bodies must be stationary circles whose whole boundary stencil lies in the fine
+  active region, clear of the coarse/fine transfer cells; violations are rejected
+  before any GPU allocation.
+- `level_blocks=[None, (by, bx)]` stores the fine level in fixed-size blocks; `by`/`bx` must
+  divide the WHOLE fine allocation, i.e. `2*(y1-y0)+8` by `2*(x1-x0)+8` including the
+  four-cell ghost band. It gives results identical to dense storage and is
+  infrastructure for future block AMR, not a speedup.
+- Several regions: pass a sequence of `(x0, y0, x1, y1)` rectangles as
+  `refinements[0]`, with both levels blocked (`level_blocks`). Transfers are built once
+  from their union; adjacent, overlapping and concave unions are accepted when
+  their actual dependencies close. There is no fixed rectangle-gap rule.
+  The fine level is then one level-wide grid `(2*ny, 2*nx)`:
+  `run.hierarchy.pairs[0].fine_shape` gives it, `initialize`/`download` use it, and only the
+  grid-aligned tiles intersecting the union plus its four-cell ghost band are stored.
+  Block sizes must divide the level-wide grid; rectangle edges need not align
+  with tiles. Order of rectangles does not matter. L1 bodies/Jets (`level_objects[1]`/`level_jets[1]`) work
+  as for one patch: each circle (same coarse cell-edge frame) must lie wholly
+  inside the union's active region with
+  its boundary stencil clear of transfer cells; a jet may not select links of two
+  different bodies, even across regions. Wall-touching patches remain unsupported.
+  For nesting, add further `refinements` entries as shown below.
+
+  ```python
+  cfg = LBMConfig(nx=32, ny=16, viscosity=.1)
+  rest = np.asarray(compute_feq_d2q9(1.0, 0.0, 0.0), np.float32)[:, None, None]
+  with CudaContext(0) as ctx, FixedPatchStepper(
+          cfg, context=ctx, refinements=[((4, 4, 12, 12), (16, 4, 24, 12))],
+          level_blocks=[(4, 4), (4, 4)]) as run:
+      run.initialize(np.broadcast_to(rest, (9, *run.hierarchy.pairs[0].coarse_shape)),
+                     np.broadcast_to(rest, (9, *run.hierarchy.pairs[0].fine_shape)))  # (9, 32, 64)
+      run.step(32)
+      coarse_g, fine_g = run.download()  # coarse: NaN on every covered cell;
+                                         # fine: NaN on every non-ACTIVE cell
+  ```
+- Three-level nested windows: pass two scalar rectangles in `refinements` —
+  L1 in L0 cells, L2 in **L1 window cells** (the parent's fine grid including its
+  4-cell ghost band) — plus all three `level_blocks` entries. L2 must sit inside
+  L1's ACTIVE cells, away from L1's ghost band and transfer footprint (checked
+  before any GPU allocation). `initialize` and `download` take/return three
+  arrays; each level is NaN on its non-ACTIVE (and child-covered) cells. One
+  coarse step = 2 L1 steps = 4 L2 steps. One L1 window only in this scalar
+  chain. Optional stationary circles and Jets live on L2 via `level_objects[2]`
+  and `level_jets[2]`; L1 bodies/Jets retain their L1 meaning and must be empty
+  in this mode. All object and Jet geometry uses the **L0 edge frame**, not the
+  child bounds' L1 window frame. L2 has dx=dt=0.25, so prescribed lattice
+  velocity is unchanged. Each whole body and its BFL stencil must be inside L2
+  ACTIVE cells, outside the transfer footprint. A Jet may select one physical
+  body across multiple blocks, never two bodies.
+
+  ```python
+  from CelerisLab.body.geometry.circle import CircleGeometry
+  from CelerisLab.body.objects import SimObject
+  from CelerisLab.body.jets import Jet, Tube, Parallel
+
+  cfg = LBMConfig(nx=16, ny=16, viscosity=.1)
+  body = SimObject(0, geometry=CircleGeometry(8., 8., .8), center=(8., 8.), radius=.8)
+  jet = Jet(Tube((6.5, 8.), 0., 3., .3), Parallel(0.), amplitude=.002)
+  rest = np.asarray(compute_feq_d2q9(1.0, 0.0, 0.0), np.float32)[:, None, None]
+  with CudaContext(0) as ctx, FixedPatchStepper(
+          cfg, context=ctx, refinements=[(4, 4, 12, 12), (8, 8, 16, 16)],
+          level_blocks=[(4, 4)] * 3, level_objects=[(), (), (body,)],
+          level_jets=[(), (), (jet,)]) as run:
+      shapes = (run.hierarchy.pairs[0].coarse_shape, run.hierarchy.pairs[0].fine_shape, run.hierarchy.pairs[1].fine_shape)
+      run.initialize(*(np.broadcast_to(rest, (9, *s)) for s in shapes))  # 16², 24², 24²
+      run.step(4)
+      run.set_jet_amplitude(0, -.002, level=2)  # explicit level selects the driven level
+      run.step(4)
+      coarse_g, l1_g, l2_g = run.download()  # solids/covered/nonleaves are NaN
+  ```
+- Level lists (the only constructor): `refinements[l]` describes level `l+1`
+  in allocated level-`l` integer cells; use a rectangle list for a union, or a
+  scalar rectangle for a single window (a scalar child requires a scalar
+  parent). `level_blocks`, `level_objects` and `level_jets` each have one entry
+  per level, including L0. Three or more levels require all-blocked storage and
+  bodies/Jets only on the finest level. Every adjacent pair must preserve
+  inherited ACTIVE coverage, valid donors/receivers, surviving pulls and the
+  upstream transfer footprint. Level `l` takes `2**l` steps per base interval.
+  This describes implemented topology and scheduling, not accuracy or
+  convergence qualification.
+- Blocked body levels can enable `observe_raw_exchange=True` and call
+  `read_raw_exchange(body_id, level=...)` after a completed base interval.
+  It reduces unique cut-link observations into wall/aperture/total force,
+  torque and mass exchange in base-lattice units per unit depth, for the last
+  base interval (default) or `window="last_substep"`.
+  `observe_window_exchange=True`, alongside `observe_raw_exchange=True`, enables
+  `start_exchange_window()` / `read_exchange_window(body_id, level=...)` across
+  completed base intervals. These are raw boundary-reaction diagnostics, not a general
+  stress or nozzle-load accuracy claim; dense body layouts are unsupported.
+- Not available: checkpoints, moving bodies, L1 bodies/Jets in a three-level
+  chain, automatic dynamic refinement, `Simulation` integration. Qualification
+  depends on the tested configuration; see [the validation scope](docs/validation/2d_scope.md).
+  CPU topology/schedule tests alone do not establish GPU numerical correctness,
+  general convergence or long-time stability.
 
 ## Installation
 
@@ -260,6 +394,12 @@ before `run()`, the force will be reset to zero. For the common usage pattern
 | `sim.load_checkpoint(path)` | Restore from HDF5 (config must match) |
 | `sim.snapshot()` / `sim.restore()` | In-memory field snapshot |
 
+In-memory snapshots save populations only. Restore keeps the current clock,
+controls, observations, geometry and flags; use it only while geometry is
+unchanged. This is not a restart or an FSI rollback. In particular, do not
+restore a snapshot taken before a translating circle changed position.
+This geometry restriction is a caller precondition, not a runtime check.
+
 #### Low-level access
 
 | Attribute | Description |
@@ -553,6 +693,17 @@ for step in range(steps):
 streak.render("streakline.png")
 ```
 
+## Validation campaigns
+
+- [Periodic Taylor–Green AMR](docs/validation/taylor_green.md): analytic periodic-decay pilot and frozen baseline-relative assessment.
+- [Matched refined DFG](docs/validation/refined_dfg.md): frozen SRT uniform/refined comparison, requiring channel GPU gates before execution.
+- [DFG 2D-2 Re100](docs/validation/dfg_re100.md): frozen periodicity and official-reference comparisons, with a declared noncanonical outlet.
+- [Uniform LES shear decay](docs/validation/uniform_les_flow.md): independent continuum-oracle flow diagnostic, baseline and isolated corrected source variants.
+- [Smagorinsky helper comparison](docs/validation/les_helpers.md): pinned baseline versus an output-local two-coefficient candidate, without production edits.
+- [Jet-circle control volume](docs/validation/jet_circle_cv.md): bounded AMR versus uniform-grid conservation diagnostic.
+
+The runners are in `tests/validation`, their CPU tests in `tests/unit`, and compact reference/source guards in `tests/validation/data`. Current Re100/Jet source guards explicitly pin the reviewed AMR-channel experiment; historical d79 evidence remains tied to its original checkpoint commits. New runs record actual Git HEAD separately from source origin. These campaigns preserve pinned production code; successful CPU checks alone do not establish GPU or physical validation. Keep generated results outside tracked files.
+
 ## Citation
 
 ```bibtex

docs/compatibility.md

@@ -0,0 +1,57 @@
+# 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.
+
+## Redundant periodic stepper alias removed
+
+`PeriodicPatchStepper` is no longer exported from `lbm.refinement_stepper`.
+Use `FixedPatchStepper` with the same arguments, including explicit
+`level_blocks`. The old name was an alias for that exact class; periodic
+boundaries remain the default. Existing imports of the old name must be updated.
+
+## 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.
+
+## 7afb5ad: `Simulation` fails closed after a Jet amplitude device-write failure
+
+`Simulation.set_jet_amplitude` previously only documented that a device error
+leaves the per-link velocity column undefined; the instance stayed usable.
+Now any error after input validation (internal stream creation or the upload)
+marks the Simulation failed. Every later device-touching public method,
+including the `stream` property (guard added in the follow-up repair commit on
+`claude/jet-update-consistency`), raises
+`RuntimeError("Simulation failed (...); close() and recreate it")`. The host
+amplitude keeps its previous value. `close()` still works and stays retryable;
+cached host readers and host staging calls are not blocked. Invalid input
+(`ValueError`/`IndexError`) is unchanged: it raises before any change and the
+instance stays usable. `FixedPatchStepper.set_jet_amplitude` already failed the
+instance (status `failed`) and is unchanged.

docs/development/les_dev8403956_integration.md

@@ -0,0 +1,62 @@
+# Selective LES normalization integration on dev8403956
+
+This change reuses the reviewed correction from 5465832 without merging its
+branch history. The only production change is the two closed-form coefficients
+18 -> 18 sqrt(2) and their explanatory comments in turbulence_smag.cuh. Its SHA256
+is a3db46c2e7d27530b2d1436e65cdbed0b72cc7e047bfbeef2a640877271b51aa.
+Defaults, iterative/deviatoric/capped closure, collision dispatch, AMR guards,
+and all other production source files are unchanged.
+
+## Separate source contract; unchanged experiment
+
+The single existing flow runner now accepts `--experiment dev8403956`.
+Its separate source_pins_dev8403956.json pins all 101 production files from the
+committed 8403956 baseline; corrected mode permits only the exact reviewed
+header substitution. Results record the actual checkout commit, import path,
+experiment name and manifest SHA256. No arbitrary manifest-path override exists.
+
+Omitting the option still selects the original historical source manifest.
+That manifest, the original paired receipts, scalar preparation manifests and
+independent continuum oracle are unchanged. Historical baseline and corrected
+receipts remain evidence for their own exact sources, not new dev receipts.
+Historical guards intentionally reject this different dev source tree. Eight
+production files already differed between the historical source snapshot and
+8403956; neither the old manifest nor its acceptance is silently regenerated.
+
+The physical experiment and every numerical acceptance threshold are unchanged:
+8 x 34 nodes, halfway y walls, periodic x, unforced D2Q9/SRT, shifted FP32,
+double-buffer streaming, Cs=0/.16/1, checkpoints 519/1038/2075. Each case has one
+actual advancing warm-up followed by complete initial-state restoration before
+READY. Total launches are 6,225 measured plus three warm-ups. Cs=1 remains an
+amplified diagnostic, not a physical coefficient recommendation.
+
+## Host checks
+
+    PYTHONDONTWRITEBYTECODE=1 python -m unittest discover -s tests/unit -p 'test_smagorinsky_normalization.py' -v
+    PYTHONDONTWRITEBYTECODE=1 python -m unittest discover -s tests/unit -p 'test_les_flow_*.py' -v
+
+The direct-current-header test is copied unchanged from reviewed 5465832:
+120 tensor parameter cases, Cs=0/equilibrium and omega guards, converged
+trace-free iterative comparison, and mutation detection in both lattice
+algebras. This is scalar D2/D3 algebra coverage, not 3D-flow qualification.
+Flow tests retain analytic/reference checks and add current named-source,
+reverse-patched baseline, variant rejection, unrelated-source tampering and
+immutable historical-default checks. The temporary baseline is constructed
+only inside a test directory; production is never reverse-patched.
+
+## Pending final-commit GPU gate
+
+After independent review and explicit executor authorization, run from the
+exact committed candidate checkout, selecting the authorized physical GPU:
+
+    CUDA_VISIBLE_DEVICES=<physical-GPU> PYTHONDONTWRITEBYTECODE=1 python tests/validation/run_uniform_les_flow.py --root "$PWD" --experiment dev8403956 --variant corrected --run-gpu --device 0 --output <new-evidence-directory>/corrected.json
+
+Retain all source hashes, exact commit/import/device identity, manifest hash,
+three READY/reset records, complete result JSON, stdout/stderr and actual exit.
+Require all frozen gates, DONE passed=true and exit 0. Compare with historical
+corrected evidence without relabeling it as current evidence. The old-vs-new
+normalization discrimination already exists; no new baseline GPU run is needed
+unless review finds a changed exercised uniform solver path.
+
+No GPU result is claimed by this integration preparation. This does not expand
+LES qualification to MRT, forcing, AMR LES or three-dimensional turbulent flows.

docs/development/projected_pair_explosion.md

@@ -0,0 +1,57 @@
+# Experimental projected G explosion
+
+`FixedPatchStepper(..., explosion="projected_linear")` changes only the existing
+G-to-G explosion reconstruction. The omitted/default `"constant"` selector retains
+the same kernel, launch arguments and device allocations. Projected mode adds two
+compact tables per adjacent pair; recursion, collision, BFL, restriction, buffer
+ownership and synchronized publication are unchanged. `remap_finest` preserves it.
+
+Runtime eligibility is periodic-root, fully blocked D2Q9/SRT/FP32, body/Jet-free,
+without LES; the fixed-patch backend has no forcing interface. Shifted and unshifted
+storage use the same reconstruction. One generic builder handles scalar windows,
+unique union rows and all adjacent hierarchy pairs without depth/rectangle caps.
+Donors are original explosion donors intersected with owned, uncovered ACTIVE
+cells. An axis uses centered differences only if both neighbors are legal;
+otherwise both addresses repeat the center. Nested layout periodicity is explicit.
+No covered cells, holes, inactive cells or stale halo copies enter the stencil.
+
+The 33-line kernel is unchanged from our `519473a` experiment and retains its
+mathematical attribution. Host tests cover union decomposition, concavity, narrow
+gaps, grazing packet paths, offsets, sparse/nested owner addresses, three/four-level
+source timing, unchanged constant dispatch, remapping and shifted/unshifted actual
+kernel arithmetic compiled as host C++. These are not CUDA or flow validation.
+
+## Reviewed bounded evidence
+
+The `1aa8110` CUDA gate, with production exactly `a135252`, passed exact-dev
+omitted/default and explicit-constant equivalence, per-population reconstruction,
+scalar/union/four-level scheduling, alternate layouts, and changed remapping in
+both storage modes. Operator maximum error was 2.98023224e-8; the eight-step
+concave replay maximum was 1.58037614e-7. Whole-step mass/momentum remain
+finite diagnostics, not an FP32 conservation certificate. Reviewed evidence:
+`7aa66ff0542175092753ea099f40b903ece0527e`.
+
+The fresh four-case `2cf9853` N128/256 Taylor–Green repeat retained all `11901a7`
+settings and gates. All 20 main scalar rows and 260 early-pressure samples matched
+the older receipts exactly; this is not field-array equality. Projected worst
+velocity was 0.001995299260844 versus 0.002 (only 0.235% margin), pressure
+0.012157174904932 and energy 0.001184362645162. Constant velocity
+0.004418076615223 failed its gate, so the aggregate verdict remains false.
+The projected early sampled pressure peak was 0.021621453573334; it remains a
+descriptive sampled maximum. Reviewed evidence: `90849a55cad4a0da9b72747da7bfe6eb75962a44`.
+
+The old N64 projected failures remain relevant. These results support only this
+bounded plumbing gate and short periodic Re100 smooth-decay experiment. They do
+not establish union/multilevel physics accuracy, convergence, long-time stability,
+body/Jet, boundary, forcing, MRT or LES suitability. Constant remains the default.
+
+## Separate LES source profile
+
+The two older LES source manifests and the historical default are unchanged and
+correctly reject this different source tree. The existing LES runner now offers
+`--experiment a135252`, pinning all 101 actual committed corrected source files.
+Its explicit baseline-header override describes only a synthetic isolated reverse
+control, never the committed a135252 header. The unchanged corrected-only uniform
+LES regression (Cs=0/.16/1) is the remaining integration gate; no LES result is
+inherited from the projected evidence. The separate historical jet-CV `channel.py`
+pin mismatch predates this port and is not addressed here.

docs/development/raw_exchange.md

@@ -0,0 +1,73 @@
+# Raw multilevel boundary exchange (opt-in candidate)
+
+Use `FixedPatchStepper(..., observe_raw_exchange=True)` and, after a successful
+base step, `read_raw_exchange(body_id, level=l, window="last_base_step")`.
+The alternative window is `"last_substep"`. Body IDs are object positions within
+the named level, not the object's original user label. The torque reference is
+that circle's geometry.center (the center used to construct BFL arms), reported
+in the root edge frame. A differing SimObject.center does not change this reference. Current geometry
+restrictions are unchanged: fixed complete bodies on the finest level, isolated
+from the transfer footprint. New observation currently requires blocked body
+storage; dense-body configurations raise before device allocation. Existing
+dense diagnostics are unchanged.
+
+Each result contains `wall`, `aperture`, `total`, with `force`, `torque`,
+`impulse`, `angular_impulse`, `mass_into_fluid`, and `mass_rate`. These are raw
+boundary momentum reaction, not validated stress or whole-nozzle mechanical
+load. No GI/advective correction or guessed thrust is added. Apertures retain
+their geometric classification when their prescribed velocity is zero.
+
+All results are base-lattice units per unit out-of-plane depth. For local
+spacing and timestep h=dt, raw `(jx,jy,tz,dm)` converts to impulse
+`(h*dt*jx,h*dt*jy,h*h*dt*tz)` and mass `h*h*dm`.
+The accumulator intentionally accepts h and dt separately to make the spatial
+and temporal conversion explicit; the current acoustic hierarchy supplies dt=h.
+The stored rx/ry arms run from geometry.center to the actual wall hit, not to
+the fluid node. For this raw exchange j=c_i(a+b), moving the arm from the fluid
+node to the hit adds q*c_i, whose cross product with j is zero. Thus either arm
+gives the same raw torque (up to floating-point rounding); this equivalence
+must not be assumed for a future nonparallel stress/advective correction.
+
+Force/torque are impulse/angular impulse divided by the reported window length.
+`dm=b-a` is positive into the exterior fluid, while j is the opposite of the
+fluid's momentum change across that cut link. Interpolated BFL can introduce
+mass drift; dm is an observation, not an assertion of impermeability.
+
+`last_base_step` means [t-1,t] even after step(n); `last_substep` means [t-h,t]
+and is not a common instantaneous sample across levels. A Jet amplitude set
+before step(1) applies to all its substeps. Reads are repeatable; step(0) leaves
+them unchanged. Initialization and a remap candidate invalidate observation.
+Only successful stream synchronization publishes a window; failed instances
+reject reads rather than returning partially advanced measurements.
+
+Storage is one FP32 [N,4] raw array and one FP64 [N,4] integral per measured
+level, plus row metadata. No substep history is stored. Same-stream sequencing
+is halo/restriction -> BFL -> independent row accumulation -> step. There are
+no accumulation atomics or body obs offsets (blocked n_objects remains zero).
+Disabled observation allocates neither observation buffer and launches no
+accumulation kernel. The standalone periodic block caller passes explicit
+null optional arguments.
+
+## Gates
+
+CPU (standard library unittest, plus existing NumPy dependency):
+
+    PYTHONPATH=src python -m unittest discover -s tests/unit -p test_raw_exchange.py -v
+
+GPU, explicitly on a CUDA host with the existing environment:
+
+    PYTHONPATH=src python -m unittest discover -s tests/validation/multigrid -p test_raw_exchange_gpu.py -v
+
+The GPU suite includes an independent actual-population cut-link census and
+ACTIVE-fluid momentum/mass ledger with non-body boundary flux, observation
+on/off population equivalence, dense/blocked row comparison, three block
+partitions, zero/step/reversed/disabled Jet amplitudes, depth-four eight-sample
+accumulation, and a short-time whole-domain uniform-fine comparison with the
+same physical geometry, viscosity and Jet velocity. The uniform reference
+uses a test-only adapter to the standalone kernel's optional inputs.
+
+These are implementation checks. They do not establish physical Jet/stress
+accuracy, long-time AMR error, or convergence order. Resolution/long-time
+studies and independently validated continuum load benchmarks remain separate.
+GPU gates were prepared but not run in the authoring environment (no CUDA,
+PyCUDA or nvcc); run them before merging this candidate.

docs/development/refinement_mrt.md

@@ -0,0 +1,34 @@
+# MRT reuse in blocked/refined stepping (candidate)
+
+Base `9805383`. Opt-in by `LBMConfig(collision="MRT")`; SRT remains the default and its
+kernel statements, including the shifted retained-delta/direct-momentum path, are unchanged
+under the alternate compile branch.
+
+## What changes
+- `blocks.cu` (`BlockStep`), `step/block_channel.cu` (`BlockChannelStep`) and `refinement.cu`
+  (`patch_collide`) gain a compile-time `COLLISION_MODEL == 2` branch that repeats the uniform
+  `collide_dispatch` sequence with zero forcing: `compute_rho_u`, omega clamp to
+  `[OMEGA_COLLISION_MIN, OMEGA_COLLISION_MAX]`, `collide_mrt_no_force`.
+- Kernel and host guards accept SRT or MRT only. TRT, LES, non-FP32 storage, non-double-buffer
+  streaming, and shifted dense/mixed refinement remain rejected.
+- Transfers, subcycling, BFL, raw exchange ledgers and channel closures are untouched. The
+  existing pressure-NEQ outlet selects its MRT branch (unknowns-only NEQ extrapolation) from
+  `COLLISION_MODEL`, so MRT channel parity must use uniform MRT as reference.
+
+## Contracts (existing operator, not redefined here)
+- Shifted storage uses the existing MRT representation (equilibrium moments from `rho - 1`),
+  not the SRT retained-delta/direct-momentum precision. Mass and momentum are conserved
+  moments (relaxation rate 0).
+- Kinetic rates are the operator's fixed `s_e = s_eps = s_q = 1.2` on every level; the shear
+  rate is the existing per-level omega. Under acoustic 2:1 scaling the physical bulk viscosity
+  therefore halves on each finer level. No rate rescaling is applied.
+- No LES, no external forcing (`d_params` force fields stay zero).
+- Shifted Jets stay SRT-only: `body/jets.py` keeps its existing guard. This extension does not
+  provide shifted MRT Jets.
+- `PeriodicBlockStepper` (uniform blocked stepper) remained SRT-only; it was removed in 8e1feff and its single-level capability, still SRT-only, is `FixedPatchStepper(refinements=[])`.
+
+## Evidence status
+CPU: `tests/unit/test_refinement_mrt.py` (host guards, source contract). GPU:
+`tests/validation/multigrid/test_refinement_mrt_gpu.py` (uniform-MRT channel parity, AMR MRT
+smoke) and unchanged SRT GPU tests. Strict parity may be subject to cross-kernel FMA
+contraction differences already documented for SRT. Not a DFG/benchmark validation.

docs/development/root_channel_candidate.md

@@ -0,0 +1,22 @@
+# Blocked AMR root channel increment
+
+Opt in with `FixedPatchStepper(..., coarse_boundary="channel", refinements=[bounds], level_blocks=[(by,bx), (fy,fx)])`. Every level must be blocked. The supported boundary is the existing uniform D2Q9/SRT/FP32 double-buffer channel: local Zou-He west inlet, pressure-NEQ east outlet, stationary halfway bounce-back y walls. Uniform and parabolic inlet profiles and shifted/unshifted storage are supported; the existing configuration guards still reject MRT/LES and incompatible storage. This does not change the external DFG MRT reference.
+
+`step/block_channel.cu` is a small root-only kernel. Fine kernels, transfer kernels and recursive hop scheduling are unchanged. Global coordinates and the global profile height/velocity are separate from block-local storage strides. Corner ownership and collision phases match `OneStep`:
+
+- y-edge ghosts (including corners): pull, pair swap, no collision
+- west ghosts at interior y: Zou-He reconstruction then SRT collision
+- east ghosts at interior y: pressure NEQ from the immutable left input node, no collision
+- physical fluid beside y walls: same-node opposite-input correction then collision
+
+The root uses the uniform SRT equilibrium arithmetic, including the existing shifted rho-minus-one path, to preserve matched-root semantics. Fine `BlockStep` retains its existing shifted direct-momentum/retained-density arithmetic. This increment is not a migration of fine arithmetic.
+
+Root halo topology stays wrapped like the uniform kernel, solely to reproduce its complete evolved ghost state as well as physical populations. It does not make the physical inlet/outlet periodic. Evolved root state includes boundary ghosts, while public fluid-leaf downloads exclude them. Initialization must provide finite positive-density root ghost states. Private raw snapshots preserve them exactly for same-representation continuation; public leaf-only downloads are not restart states. Channel remapping remains explicitly unsupported.
+
+`channel.py` checks the actual explosion donors and restriction receivers are uncovered bulk fluid and checks actual receiver-local restriction slots against pressure-donor and wall-correction reads. No arbitrary large padding or block-aligned patch restrictions are added. Keep the physical domain dimensions exact: choose legal root block divisors (including full width) instead of padding a benchmark domain. Stationary circles/Jets retain the existing finest-level and transfer-footprint rules.
+
+## Gates
+
+- `tests/unit/test_channel_root.py`: host semantics, minimal footprint, overlap rejection, raw-state/public-leaf separation; actual production uniform and blocked kernels under a CPU launch shim, five non-equilibrium steps, all corners, profiles, representations, y seams and a one-cell-wide block outlet donor.
+- `tests/validation/multigrid/test_channel_root_gpu.py`: exact uniform-versus-blocked full-state GPU parity; AMR finite-state and block-split invariance with/without a stationary circle and velocity Jet; amplitude update and raw snapshot round-trip.
+- GPU tests require explicit device admission by the caller. CPU-header algebra is not CUDA execution or external physical validation. The current increment does not establish DFG drag/lift/pressure acceptance or a performance speedup; those need matched SRT controls and a separate benchmark run.

docs/development/src_coherence.md

@@ -0,0 +1,116 @@
+# src coherence stage (from main 914906e)
+
+Owner direction 2026-10-28: unified style over historical compatibility, inside `src`.
+No numerical change is intended. Stages after 5f69eba: 65339ab (one boundary/Jet record,
+host preparation helpers, pair accessors), c5a3cdb (`block_collide` families), 442979b
+(exchange metadata on the boundary record). All three received parent/candidate
+generated-config and host/GPU equality checks. Only the collision slice ran a new PTX
+matrix (a4fc46d, whose src is identical to c5a3cdb); 65339ab and 442979b reused prior
+PTX evidence after unchanged CUDA/compiler and generated-input checks. In the collision
+matrix, only the two channel-root SRT modules changed PTX (omega load/clamp moved);
+their parent/candidate outputs matched exactly in the exercised cases.
+
+## Conventions (defined once, in `lbm.hierarchy.Hierarchy`)
+
+- Level `l = 0 .. depth-1` (0 = root). Pair `hierarchy.pairs[l-1]` builds level `l`.
+- Array shapes are `(ny, nx)`; rectangles, origins and centers are `(x, y)`.
+- Coarse/fine name the two members (parent/child) of ANY pair, not absolute L0/L1:
+  `fine_shape`, `fine_origin`, `prepare_fine_boundary`, `blocked_fine_tables`,
+  `blocked_coarse_tables`.
+- Refined levels (l >= 1) of FixedPatchStepper place bodies/Jets in the root EDGE frame
+  (root cell `i` = `[i, i+1)`). Uniform `Simulation` objects AND the static circles of a
+  single-level (depth 1) FixedPatchStepper use the integer-NODE frame. Nothing converts
+  between them. This concerns input placement only: within the EDGE frame, refined
+  levels still project root-edge coordinates to fine-local cell indices with the
+  half-cell shift (`prepare_fine_boundary`: `(v - o)/dx - .5`; hits back via `fine_hits_to_edge_frame`
+  `origin + dx*(hit + .5)`), using `edge_frame`/`fine_origin` below.
+- `Hierarchy.edge_frame(l)` -> `((ox, oy), h)`: cell `(i, j)` of level `l`'s allocated
+  array (ghost band and holes included) covers `[o + h*i, o + h*(i+1))`. A scalar
+  FixedPatch2D window carries the half-coarse-cell ghost shift `bounds - HALO/2` in
+  `fine_origin`; a set's level-wide grid has origin 0. Level 1 boundaries are built from
+  the root config (the wall-aware fields live there); deeper ones from the parent frame.
+- `FixedPatch2D.fine_level_offset` (was `fine_level_origin`) is an array INDEX offset
+  `(y, x)`, not an `(x, y)` origin.
+
+## FixedPatchStepper migration map
+
+Historical: left column = names at or after 914906e that no longer exist; right column =
+the current name.
+
+| removed / changed | replacement |
+|---|---|
+| `patch`, `child_patch` | `hierarchy.pairs[0]`, `hierarchy.pairs[1]` |
+| `base_layout`, `fine_layout`, `child_layout` (stepper properties) | `layouts[0]`, `layouts[1]`, `layouts[2]` (`FixedPatchSet2D.fine_layout(block)` is unchanged) |
+| `fine_boundary`, `child_boundary` | `boundaries[1]`, `boundaries[2]` (host geometry; `None` = no bodies/Jets) |
+| `_jets` | `jets[1]` |
+| `_boundaries[l]` (dict from L1, level keys), `_level_boundaries` (b4eacf7), `_device_boundaries` (65339ab) | `_boundaries[l]`: the one combined per-level `_BlockedBoundary` record (list from L0, `None` at L0 unless single-level static circles): host geometry `.host`, `.tables`, `.jets`, `.jet_cache`, exchange `.spacing`/`.centers`, device handles |
+| `_fine_tables`, `_actuated`, `_jet_cache` | `_boundaries[1].tables` / `.actuated` / `.jet_cache` |
+| `_level_jets` (private) | `_boundaries[l].jets` (public `jets[l]` is derived) |
+| `_exchange_spacing[l]`, `_exchange_centers[l]` (private) | `_boundaries[l].spacing` (h_l, root units) / `.centers` (root edge frame); only levels with a boundary report exchange |
+| `_level_blocks` (private) | `_layouts[l].block` |
+| `_remap_cfg` (private) | `_root_cfg` |
+| `refinement_tables.blocked_base_tables` (also via `refinement_stepper`) | `refinement_tables.blocked_coarse_tables` (import from `refinement_tables`; the stepper no longer re-exports) |
+| `_fine_leaf`, `_child_leaf` | `leaf[1]`, `leaf[2]` (copies) |
+| `_middle_kind` | `hierarchy.kinds[1]` |
+| `_boundary_hosts` (private) | public `boundaries[l]` = `_boundaries[l].host` (host geometry only; the private record is the combined one) |
+| `remap_child(rects, child_objects=...)` | `remap_finest(rects, objects=...)` |
+| `set_jet_amplitude(i, a)` (implicit level 1) | `set_jet_amplitude(i, a, level=l)` (required) |
+| `read_raw_exchange(b)` / `read_exchange_window(b)` (implicit level 1) | `read_raw_exchange(b, level=l)` / `read_exchange_window(b, level=l)` (required) |
+| `_level_name(l)` "base/fine/child" messages | `"level l"` |
+| `refinement.MIN_PATCH_GAP` | deleted (no gap policy exists) |
+| `params.cuh HaloPlan`, `collide_trt_no_force` | deleted (zero references) |
+
+Kept: `step_count`, constructor keywords (`refinements`, `level_blocks`, `level_objects`,
+`level_jets`, `coarse_boundary`, `explosion`), `Simulation.set_jet_amplitude(i, a)` (one level),
+`RemapTopology.from_config(..., child_objects=, child_jets=)` (internal remap helper; "child" =
+the replaced level relative to its parent).
+
+## Responsibilities
+
+- Construction: `_check_levels` (inputs); host preparation, numpy only, before any device
+  work: `_level_layouts`, `_kernel_configs` (per-level kernel configs), `_host_boundaries`,
+  `_prepare_blocked_boundary`, `_fluid_leaves`; `Hierarchy.edge_frame` (geometry frames);
+  then `_planned_bytes()` (memory preflight) and `_build_level` / `_build_pair` /
+  `_upload_boundary` (device). A construction failure closes the partial instance.
+  Observation reads share `_observed_boundary` + `_summarize`.
+- Pair accessors: `rectangles` (a scalar FixedPatch2D gives `(bounds,)`) and
+  `fine_level_offset` (`(0, 0)` for a set) on both pair types; the types and their
+  storage frames stay distinct.
+- Per-level state, by lifecycle:
+  - Fixed plan structure (built once in `__init__`, read by `_planned_bytes()` before any
+    allocation, readable after `close()` through the public views): `_layouts`,
+    `_level_cfgs`, `_leaf`, `_state`, and in each `_boundaries[l]` record the host geometry
+    `.host`, link tables, `.jet_cache`, `.spacing`, `.centers`.
+  - Mutable boundary data in the same record: `.jets` and `.tables["surface_velocity"]`,
+    changed only by `set_jet_amplitude` (host prepare -> device write -> commit; an uncertain
+    write fails the instance); device handles (`.flags`, `.device`, `.kernel`, ledgers) are
+    set by `_upload_boundary` and cleared by `close()`.
+  - Runtime: `_levels` (`_Level`) holds compiled modules, kernels, the two population
+    buffers (swapped per step) and transfer/kind handles. It is created only after the
+    memory preflight and cleared on `close()`; `.layout`/`.boundary` reference the plan for
+    `_hop`. Folding the plan into `_Level` would mix both lifecycles in one record.
+- Blocked kernels: `operators/block_collision.cuh block_collide` is the one collision extension
+  point of `BlockStep` and `BlockChannelStep`. It computes rho/u once and reads no runtime
+  force (`d_params.fx/fy`). Two compile-time families: uniform-equivalent (MRT on any level,
+  SRT on the channel root `BLOCK_ROOT_BC == 2`): clamped omega, `collide_mrt_no_force` or
+  `collide_srt` with its zero Guo term; and level SRT (`BLOCK_ROOT_BC` 0/1): unclamped omega,
+  `collide_srt_no_force`, with the shifted direct-momentum feq under `USE_DDF_SHIFTING`.
+  The uniform path keeps `collide_dispatch` (runtime force, LES, TRT).
+- `explosion="projected_linear"` stays an optional capability; `"constant"` stays default.
+
+## Not done / open
+
+- Two per-level config derivations stay distinct on purpose: `Hierarchy.configs`
+  (`_middle_config`, wall fields reset on every refined level, geometry validation) vs.
+  `FixedPatchStepper._kernel_configs` (reset only on level 1 of a slot_reservoir root;
+  generates each level's config.h). Folding them needs a config.h/PTX diff gate.
+- No single-`Simulation` facade over FixedPatchStepper: the two own different state models
+  (uniform node frame, body sync, forcing, checkpoint vs. fixed blocked hierarchy, edge
+  frame, remap-as-new-instance). A facade would only forward calls; no concrete need found.
+- Deferred, each needing its own evidence first: sharing the channel-root cell/donor selector
+  with OneStep (the closure functions are already shared; a shared selector changes uniform
+  signatures and needs a uniform PTX gate); merging FixedPatch2D into FixedPatchSet2D
+  (different origin, ghost band, layout size and addressing; needs a geometry/parity table and
+  would need tiles that are not grid-aligned); one `clamp_omega` helper for uniform and
+  blocked paths (it lives in the hash-pinned LES header `turbulence_smag.cuh`).
+- Tests, examples and validation callers are migrated separately (pinned runners stay frozen).

docs/evidence_index.md

@@ -0,0 +1,393 @@
+# Evidence index (draft, R0)
+
+Active-tree evidence at candidate 0f8fdbc30ea640c764b38ee598d8f4d135c81c85, classified for the release cleanup
+(thread C0C78UFKGRM 1793021833.593279). Draft for review: nothing is removed by this file.
+Recovery of any listed file: `git show 0f8fdbc3:<path>` (blob id given; an immutable tag is requested as anchor).
+
+Classes: K = conclusion kept in the active tree; K-code = tested research code kept; D-snapshot = pre-Gitea
+patch/diff transport (code landed in git from ed1a6ee on; not yet verified hunk by hunk); P-pin = generated hash inventories, git-status dumps and manifests;
+R-raw = run outputs, logs, signals, frames, one-shot run scripts and handoff notes. D, P, R leave the active tree in R1.
+No file under src/ or a test reads any of these paths (git grep at 0f8fdbc3); runners under tests/validation
+that read research/j* are handled in R2.
+
+| Class | Files | Bytes |
+|---|---:|---:|
+| K | 31 | 196,506 |
+| K-code | 3 | 24,324 |
+| D-snapshot | 18 | 338,948 |
+| P-pin | 50 | 979,177 |
+| R-raw | 142 | 3,790,554 |
+
+## (root)
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| BASELINE_JET_AMR.txt | R-raw | 5,244 | 62aa2a66dc05 |
+
+## output
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| round3_compatibility_summary.md | R-raw | 4,366 | f243318f5591 |
+
+## research/fine_surface_20261014
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| baseline.json | P-pin | 54,507 | 71a4543ead37 |
+| cpu_device_guard_cmd.txt | R-raw | 241 | 06e0f35d92b3 |
+| cpu_device_guard_exit.txt | R-raw | 2 | 573541ac9702 |
+| cpu_device_guard_stdout.txt | R-raw | 98 | 424d584a031c |
+| cpu_existing_runs.json | R-raw | 650 | 3179536407b7 |
+| cpu_final_run.json | R-raw | 386 | 523fadb3fec9 |
+| cpu_final_stdout.txt | R-raw | 99 | 9cfe73da3858 |
+| cpu_lifecycle_run.json | R-raw | 387 | 5b403b9e2f30 |
+| cpu_lifecycle_stdout.txt | R-raw | 112 | 3c5c49b285fa |
+| cpu_maps_stdout.txt | R-raw | 95 | 71dd87f9faf9 |
+| cpu_preallocation_run.json | R-raw | 337 | fa6e96d98cdd |
+| cpu_preallocation_stdout.txt | R-raw | 98 | 5d643576f251 |
+| cpu_shared_kernel_stdout.txt | R-raw | 98 | 8a0c046bb9b1 |
+| cpu_surface_command.txt | R-raw | 113 | 2a5ff31e8d06 |
+| cpu_surface_exit.txt | R-raw | 2 | 573541ac9702 |
+| cpu_surface_projection_command.txt | R-raw | 171 | 70b7f5c62c1a |
+| cpu_surface_projection_exit.txt | R-raw | 2 | 573541ac9702 |
+| cpu_surface_projection_stdout.txt | R-raw | 113 | efd37a149cc1 |
+| cpu_surface_stdout.txt | R-raw | 99 | 9cfe73da3858 |
+| gpu_preparation_run1.py | R-raw | 14,043 | ee586d035b7a |
+| gpu_run.json | R-raw | 2,943 | 15b8ba70d528 |
+| gpu_stdout.txt | R-raw | 5,424 | c5216e0267f3 |
+| gpu_test_run1.py | R-raw | 15,479 | f30376abc97f |
+| incremental.diff | D-snapshot | 53,853 | 318d92e7d177 |
+| manifest.json | P-pin | 8,411 | 8281338416af |
+| report.txt | K | 8,373 | 6b9e5123e414 |
+
+## research/fine_surface_joint_20261014
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| baseline_00.json | P-pin | 21,302 | 4ae101ebd02b |
+| baseline_01.json | P-pin | 26,191 | 548cf7b3b494 |
+| baseline_02.json | P-pin | 22,440 | e0421e7a4052 |
+| baseline_03.json | P-pin | 8,584 | da99b45f32a4 |
+| blow_boundary.csv | R-raw | 12,536 | e13363b69457 |
+| blow_collisions.csv | R-raw | 19,145 | 5d5b395486bb |
+| blow_ledger.csv | R-raw | 15,977 | b43bbfd0b8d2 |
+| blow_propagation.csv | R-raw | 9,714 | f06d80d296ca |
+| blow_signals.npz | R-raw | 221,114 | 528adf75baa2 |
+| blow_summary.json | R-raw | 4,113 | 32285ac15be3 |
+| command.txt | R-raw | 232 | 510ecb2925dd |
+| criteria.txt | K | 7,480 | dd36e76a3be1 |
+| frozen.json | R-raw | 11,972 | b5a3324e8686 |
+| gpu_run.json | R-raw | 1,955 | 67ac4785f7e4 |
+| incremental.diff | D-snapshot | 625 | e03c132d22df |
+| integrity.json | P-pin | 826 | a8b6e4be88d2 |
+| manifest.json | P-pin | 4,388 | d2af50260c39 |
+| regions.json | R-raw | 27,525 | 7bba26904221 |
+| report.txt | K | 8,207 | d7571e068ad3 |
+| result.json | R-raw | 11,442 | 9580c2686e70 |
+| review.txt | K | 2,117 | bbe1d8a83d47 |
+| runner.py | R-raw | 5,847 | 812973acc000 |
+| stdout.txt | R-raw | 19,940 | c9218e2e48fc |
+| suction_boundary.csv | R-raw | 12,505 | b870be05e6c0 |
+| suction_collisions.csv | R-raw | 19,173 | 2de48c0a84ab |
+| suction_ledger.csv | R-raw | 16,208 | 92cf1f44911e |
+| suction_propagation.csv | R-raw | 9,720 | f017bcc3ca6f |
+| suction_signals.npz | R-raw | 220,058 | 66d06cf2d909 |
+| suction_summary.json | R-raw | 4,126 | d70a1d371950 |
+| validate.py | R-raw | 19,576 | 37441febd168 |
+| zero_boundary.csv | R-raw | 11,491 | 65c92e48c974 |
+| zero_collisions.csv | R-raw | 18,915 | 027cb8ff6b23 |
+| zero_ledger.csv | R-raw | 16,051 | 34a99bb89dd7 |
+| zero_signals.npz | R-raw | 127,958 | a966f093a9cd |
+| zero_summary.json | R-raw | 1,508 | 6e033f991438 |
+
+## research/fixed_patch_jet_20261013
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| baseline.json | P-pin | 69,721 | 91ad9c4d1e88 |
+| before.json | R-raw | 690 | 06e1b6278a29 |
+| fixed_patch_jet.py | R-raw | 9,646 | 6fbdcd9a076b |
+| incremental.patch | D-snapshot | 9,891 | b43129d82c69 |
+| manifest.json | P-pin | 1,967 | 08daa0248f60 |
+| notes.txt | K | 2,214 | 50070fe54efb |
+| results.json | R-raw | 1,100 | d959a6a1cc2c |
+| stdout.txt | R-raw | 1,272 | eccdc0f6b16a |
+
+## research/fixed_patch_jet_closure_20261013
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| baseline.json | P-pin | 72,692 | 8a157af82ecf |
+| cpu_results.json | R-raw | 628 | 8e4a1c090c93 |
+| cpu_stdout.txt | R-raw | 590 | d800b783fe47 |
+| incremental.patch | D-snapshot | 3,490 | a9a486c68afd |
+| layout_uncropped.png | R-raw | 51,785 | 0cf1cfa5e99d |
+| manifest.json | P-pin | 1,849 | 31cf0c739241 |
+| notes.txt | K | 3,023 | 0f7e7bdfd0e6 |
+
+## research/fixed_patch_jet_records_20261013
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| baseline.json | P-pin | 71,228 | a8e967f76e08 |
+| before.json | R-raw | 690 | ebd6f4251fc2 |
+| fixed_patch_jet.py | R-raw | 10,650 | f6b299885da0 |
+| incremental.patch | D-snapshot | 5,539 | c7f4d0c02ccc |
+| manifest.json | P-pin | 2,057 | 1d616c2541df |
+| notes.txt | K | 2,449 | b58cec14d359 |
+| results.json | R-raw | 1,136 | 788af64a6ebd |
+| stdout.txt | R-raw | 20,750 | a765b06deefa |
+
+## research/j1-2026-10-12
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| REVIEW.md | K | 7,667 | 8f469daef054 |
+| baseline-status.txt | P-pin | 2,601 | 64ca05ab952e |
+| baseline.json | P-pin | 23,052 | ab5852bcb0ef |
+| incremental.diff | D-snapshot | 29,912 | dd9c4e688888 |
+| results.json | R-raw | 68,294 | 56547aa8a678 |
+
+## research/j2-slot-2026-10-12
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| REVIEW.md | K | 12,930 | 69fa4d3bccd3 |
+| baseline-status.txt | P-pin | 2,825 | e711afb0016c |
+| baseline.json | P-pin | 24,660 | 286e023da94f |
+| incremental.diff | D-snapshot | 25,231 | 649f3b5d168d |
+| results.json | R-raw | 477,249 | b4272e25179d |
+
+## research/j3-coverage-2026-10-12
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| REVIEW.md | K | 11,409 | 5887cf73dce2 |
+| baseline-status.txt | P-pin | 3,055 | 78e88356caa3 |
+| baseline.json | P-pin | 30,407 | 095972547a7f |
+| incremental.diff | D-snapshot | 20,114 | f0d502dc5c5b |
+| negative-budget-20744.h5 | R-raw | 88,017 | 693b133be84d |
+| negative-end-20760.h5 | R-raw | 88,174 | 429270d263d4 |
+| restart-21280.h5 | R-raw | 88,062 | 74900affae38 |
+| restart-reference-21296.h5 | R-raw | 88,154 | 7510ee97885b |
+| results.json | R-raw | 296,314 | 7806b10e65cb |
+| verification.json | K | 1,468 | 78a07c47aea4 |
+
+## research/j3-lag-2026-10-12
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| REVIEW.md | K | 11,732 | 34fe5dbb2cae |
+| baseline-status.txt | P-pin | 2,968 | 6ae6094ea9d7 |
+| baseline.json | P-pin | 26,505 | 5c289d14ff30 |
+| end-21280.h5 | R-raw | 92,366 | f30b209179ab |
+| incremental.diff | D-snapshot | 15,790 | 5c6c485e1f75 |
+| results.json | R-raw | 21,718 | 2bf58939129c |
+| start-20760.h5 | R-raw | 92,247 | ae0abd05190c |
+
+## research/j3-offline-2026-10-12
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| REVIEW.md | K | 6,271 | a76e1b486bd2 |
+| lags.csv | R-raw | 1,104 | dd3136dd2dc2 |
+| localization.png | R-raw | 136,013 | 74b56f3e814c |
+| regions.csv | R-raw | 2,126 | 5d361e6872af |
+| results.json | R-raw | 8,852 | bf77b0f534d4 |
+
+## research/j3-reservoir-2026-10-12
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| REVIEW.md | K | 13,563 | a74b67a64e0d |
+| baseline-status.txt | P-pin | 2,896 | a318e077dfae |
+| baseline.json | P-pin | 25,571 | 060502ea7dd8 |
+| incremental.diff | D-snapshot | 22,898 | 8e2c79a86c98 |
+| results.json | R-raw | 182,747 | 7fd5e51a1785 |
+
+## research/refinement_example_20261013
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| baseline.json | P-pin | 8,286 | 591478100da8 |
+| before.json | R-raw | 818 | 7ab0962775b1 |
+| incremental.patch | D-snapshot | 8,682 | 7ad8719d0167 |
+| manifest.json | P-pin | 1,798 | bf1eee8a7cf8 |
+| notes.txt | K | 1,185 | 7ff019ad023d |
+| results.json | R-raw | 1,118 | 94697b0988b9 |
+| stdout.txt | R-raw | 325 | 501446f557f4 |
+
+## research/refinement_followup_20261013
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| README.txt | K | 4,887 | af65e889f20e |
+| baseline.json | P-pin | 5,343 | 7c60ad8ad692 |
+| cleanup.json | R-raw | 1,253 | 15cf342fba2e |
+| cpu_results.json | R-raw | 1,056 | 1166dffd2a09 |
+| cpu_results_attempt1.json | R-raw | 642 | d139d5508105 |
+| cpu_stdout.txt | R-raw | 499 | d1b33ea20563 |
+| cpu_stdout_attempt1.txt | R-raw | 879 | 6a9fe7fce39a |
+| gpu_before.json | R-raw | 589 | 46762a0ab207 |
+| gpu_before_no_launch.json | R-raw | 589 | 074982d1b2d4 |
+| gpu_rectangle_before.json | R-raw | 589 | 831e3793339f |
+| gpu_rectangle_before_no_launch_1791886104981638567.json | R-raw | 589 | c33885d50bfd |
+| gpu_rectangle_results.json | R-raw | 1,003 | 9c6da219ac6c |
+| gpu_rectangle_stdout.txt | R-raw | 332 | 9185bf303954 |
+| gpu_results.json | R-raw | 1,189 | 53e4f1c44de1 |
+| gpu_seed1_before.json | R-raw | 589 | c77ea3485f84 |
+| gpu_seed1_results.json | R-raw | 996 | b718e8af84e4 |
+| gpu_seed1_stdout.txt | R-raw | 306 | 4d7de0897137 |
+| gpu_stdout.txt | R-raw | 68 | b0956fe3cdb0 |
+| incremental.patch | D-snapshot | 16,836 | 9df25d8c177a |
+| manifest.json | P-pin | 4,410 | 177704d6f1ae |
+| run_gpu.py | R-raw | 5,237 | b5af3f0d4f79 |
+
+## research/refinement_prepare_20261013
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| README.txt | K | 8,939 | 8e210c28c7c5 |
+| baseline.json | P-pin | 46,348 | d5f257216b8d |
+| incremental.patch | D-snapshot | 15,751 | 0ddb32550584 |
+| manifest.json | P-pin | 2,113 | 9fd94ccf2c3e |
+| validation.json | R-raw | 3,567 | f057e7cbcd35 |
+| validation.txt | R-raw | 873 | 594daa45c58c |
+
+## research/refinement_slot_20261013
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| baseline.json | P-pin | 67,717 | d498081e7c50 |
+| before.json | R-raw | 690 | 430e76b3aa8a |
+| cpu_results.json | R-raw | 1,421 | 4f6bc4d9428f |
+| incremental.patch | D-snapshot | 18,676 | 67a3e8cc9e68 |
+| manifest.json | P-pin | 2,270 | 6515458290f4 |
+| notes.txt | K | 2,612 | 08a713ba4b37 |
+| results.json | R-raw | 1,160 | 03e683027ba8 |
+| stdout.txt | R-raw | 643 | d57b91769826 |
+
+## research/refinement_slot_followup_20261013
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| baseline.json | P-pin | 68,536 | 89a26ce79438 |
+| before.json | R-raw | 690 | e707df192ff2 |
+| incremental.patch | D-snapshot | 495 | c6f6fa11237d |
+| manifest.json | P-pin | 1,920 | 4840243a33aa |
+| notes.txt | K | 1,549 | 4b77583ca116 |
+| planar_velocity.cuh | R-raw | 1,911 | 87db7466c843 |
+| planar_velocity.sha256 | P-pin | 251 | 6694c4a1c1f0 |
+| results.json | R-raw | 1,050 | 6ef6eda854c6 |
+| stdout.txt | R-raw | 1,160 | 461860351c0c |
+
+## research/refinement_step_20261013
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| README.txt | K | 10,671 | 88d6f24743f5 |
+| baseline.json | P-pin | 40,620 | 20f61559dd38 |
+| cpu_validation.json | R-raw | 1,231 | 7999fd30018c |
+| gpu_failure_validation.json | R-raw | 868 | 5f6db65ee4f9 |
+| gpu_failure_validation.txt | R-raw | 248 | d9a570a1e9e9 |
+| gpu_validation.json | R-raw | 672 | 2028f59e1055 |
+| gpu_validation.txt | R-raw | 632 | 9699918ee127 |
+| incremental.patch | D-snapshot | 26,516 | d95f9347633d |
+| manifest.json | P-pin | 2,075 | 32a7f1a7309e |
+
+## research/repair-2026-10-10
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| TRON_HANDOFF.md | R-raw | 25,208 | a339786c7944 |
+| baseline-hashes.json | P-pin | 16,020 | 9b4e24cb1d10 |
+| baseline-status.txt | P-pin | 429 | 515be249b638 |
+| checkpoint-domain-2026-10-12.diff | D-snapshot | 14,443 | 035ed630dda1 |
+| classic-results.json | R-raw | 244,729 | 7297aa0d5bca |
+| classic-signals.npz | R-raw | 630,332 | 8cf6d1218aa0 |
+| final-gpu.log | R-raw | 191 | a0eec1a8ea31 |
+| final-unit.log | R-raw | 188 | 94efba2f1d42 |
+| provenance.json | P-pin | 1,020 | 25e22b4f0696 |
+| repair-architecture.md | K | 9,498 | 12051c3e8571 |
+| repair-numerical.md | K | 10,769 | 0c5757fe5f36 |
+| repair-state.md | K | 8,481 | 3c7f2d5b687a |
+| simplification-checks.log | R-raw | 1,045 | fa9d464be740 |
+
+## research/shear_refinement
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| README.md | K-code | 4,142 | 67bdd8ed622b |
+| boundary_shear_tagging.py | K-code | 13,859 | b5415a1c4ea1 |
+| example.py | K-code | 6,323 | 66295d3f0273 |
+
+## research/surface_actuation_20261014
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| baseline.json | P-pin | 54,139 | 0ad06888dbeb |
+| cpu_checkpoint_run.json | R-raw | 400 | 39681b60ff15 |
+| cpu_checkpoint_stdout.txt | R-raw | 114 | 929e4b8d4f46 |
+| cpu_initial.txt | R-raw | 620 | 29213c58a679 |
+| cpu_surface_command.txt | R-raw | 118 | 6d8c615a6e03 |
+| cpu_surface_exit.txt | R-raw | 2 | 573541ac9702 |
+| cpu_surface_stdout.txt | R-raw | 99 | ee9237fc26e5 |
+| gpu_run.json | R-raw | 1,698 | dc8f87eafaa9 |
+| gpu_stdout.txt | R-raw | 159 | b262891e52c3 |
+| incremental.diff | D-snapshot | 50,206 | 43090a1a8b11 |
+| manifest.json | P-pin | 7,527 | 35daa01271cb |
+| report.txt | K | 5,078 | 1162a6479f9f |
+
+## research/wall_seam_pulse_20261014
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| analyze.py | R-raw | 10,343 | ed7cf6999a49 |
+| interpretation.txt | K | 3,514 | 90935db2aa99 |
+| results.json | R-raw | 15,137 | 678a0759871a |
+| run.json | R-raw | 1,170 | 53e303fd0d5d |
+| sources.csv | R-raw | 2,313 | 40d3736b8ef1 |
+| stdout.txt | R-raw | 1,179 | 756d8c38e213 |
+
+## tests/validation/multigrid/cpuref_0_3_evidence
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| README.txt | K | 4,133 | 62897bfd9812 |
+| README_grok.md | K | 1,751 | 2d36e05661a8 |
+| baseline.json | P-pin | 39,291 | 188491096547 |
+| manifest.json | P-pin | 3,495 | 10c19f5fe5ca |
+| results_horsea.json | R-raw | 2,281 | 3b163384e376 |
+| stdout_grok.txt | R-raw | 7,143 | 5a0c270ea4ae |
+| stdout_horsea.txt | R-raw | 9,013 | adff8bb8d295 |
+
+## tests/validation/multigrid/local_stress_v1_evidence
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| README.txt | K | 8,239 | 3513fd294223 |
+| TABLE_local_stress_observable_v1.md | K | 2,967 | 6115dcde0f46 |
+| baseline.json | P-pin | 43,991 | ab631ea4f2ad |
+| comparison.json | R-raw | 13,248 | d7d1b36eb247 |
+| manifest.json | P-pin | 4,132 | c6c44d8125cd |
+| results_horsea.json | R-raw | 2,671 | 79bdf001f948 |
+| run_once.py | R-raw | 4,313 | fa9c5239e993 |
+| source_manifest.json | P-pin | 622 | 0516f1860407 |
+| stdout_horsea.txt | R-raw | 17,091 | a20c554693df |
+| stdout_local_stress_observable_v1.txt | R-raw | 12,238 | 692ffe1a05da |
+
+## tests/validation/multigrid/shear_v0_2_evidence
+
+| File | Class | Bytes | Blob |
+|---|---|---:|---|
+| README.txt | K | 7,220 | 772f74ad40ff |
+| baseline.json | P-pin | 41,751 | 70d9c9fa71c0 |
+| comparison.json | R-raw | 7,679 | 0af8736f9a01 |
+| joint_report.md | K | 6,110 | eed871221298 |
+| manifest.json | P-pin | 3,796 | b22d03a1ba9e |
+| results_horsea.json | R-raw | 1,957 | b2cd48a07a08 |
+| run_once.py | R-raw | 3,245 | 0b8d5e21f326 |
+| source_manifest.json | P-pin | 574 | 4d1c742690c7 |
+| stdout_grok.txt | R-raw | 7,950 | 0e80b1aba7f6 |
+| stdout_horsea.txt | R-raw | 11,421 | 3c867cdac197 |

docs/fixed_three_level_multipatch.md

@@ -0,0 +1,88 @@
+# Fixed three-level rectangle unions
+
+This page describes three-level `FixedPatchStepper` setups built from the
+`refinements` level list, with rectangle unions on either adjacent pair. The
+same constructor supports arbitrary depth; three or more levels require
+all-blocked storage and bodies/Jets only on the finest level. This is not
+general AMR: there is no per-region timestep, moving geometry, automatic
+dynamic refinement or L1 body support in the three-level form.
+All regions share one current/spare buffer pair per level. The existing schedule
+advances L0 once, L1 twice and L2 four times per base step, with aggregate transfers.
+No CUDA kernel changes are involved.
+
+## Explicit coordinate frames
+
+For a single scalar parent patch, pass a scalar rectangle as `refinements[1]`:
+`(x0,y0,x1,y1)` in half-open integer indices of the allocated L1 window,
+including its ghost band.
+
+A rectangle list as `refinements[1]` accepts a scalar or a set parent and
+interprets every rectangle in the actual allocated L1 array, including ghost
+bands and holes. It never infers region-local coordinates. The physical root
+cell edge corresponding to an L1 index `(x,y)` is
+`parent.fine_origin + (x,y)/2`:
+
+- A scalar L1 parent has a shifted window origin.
+- A set L1 parent has origin `(0,0)` and public shape `(2*ny,2*nx)`.
+- A child set has public shape twice the allocated L1 shape. Its root origin is
+  the L1 allocated origin, even when the parent is a scalar window.
+
+For a 16x16 root, scalar parent `(4,4,12,12)` and scalar child `(8,8,16,16)`
+are physically equivalent to parent set `[(4,4,12,12)]` with child set
+`[(12,12,20,20)]`. A child set on the *scalar* parent instead uses
+`[(8,8,16,16)]`. Reusing the same numbers after changing the parent frame can
+move the physical region.
+
+Both adjacent pairs are built from their unions, without a fixed rectangle-gap
+rule. Adjacent, overlapping and concave unions are accepted only when their
+actual transfer dependencies close. The whole child union must preserve
+inherited ACTIVE coverage, uncovered ACTIVE donors/receivers, surviving pulls, and the upstream
+restriction footprint. Sparse holes remain unowned; inherited INNER remains
+stream-only and OUTER remains invalid. Block sizes must divide their allocated
+level grids. Sparse storage owns every grid-aligned tile intersecting the union
+plus its four-cell ghost band; rectangle and support edges need not align with
+tile edges.
+
+## Example
+
+```python
+run = FixedPatchStepper(
+    cfg, context=ctx,
+    refinements=[[(4, 4, 20, 28), (24, 4, 44, 28)], [(16, 16, 32, 40), (56, 16, 80, 40)]],
+    level_blocks=[(4, 4)] * 3,
+)
+```
+
+This example uses a 48x32 root. `initialize` and `download` use three Q-major
+dense arrays. Public arrays and masks still scale with the full allocated
+extent; sparse device buffers do not remove that host-memory limit.
+
+Stationary whole-circle L2 bodies and Jets (`level_objects[2]`, `level_jets[2]`) use root edge
+coordinates and a single L2 boundary object. Body IDs are physical object-list
+positions, not region IDs or caller `obj_id`. Complete boundary stencils must
+avoid the transfer footprint. Change a child Jet with
+`set_jet_amplitude(index, value, level=2)` (`level` is required); L1 bodies/Jets remain unsupported.
+
+## Verification
+
+CPU geometry, table, pre-CUDA rejection, schedule and cleanup tests:
+
+```sh
+PYTHONPATH=src python -m unittest discover -s tests/unit -p 'test_refinement*.py' -v
+```
+
+`tests/unit/test_union_refinement.py` covers union dependencies and tile
+ownership; `tests/unit/test_hierarchy.py` covers composed geometry through four
+levels. `tests/unit/test_raw_exchange.py` checks the four-level host schedule
+with CUDA mocks. These establish topology/control-flow coverage, not numerical
+qualification at every depth or interface shape.
+
+Explicit GPU gates are in
+`tests/validation/multigrid/test_refinement_three_level_multipatch_gpu.py`.
+They cover physical-frame equivalence, twins, asymmetric refinement, multiple
+children, reversed order, independently varied aligned layouts, public/raw
+masks and two L2 bodies with static/zero/driven/switched Jets. Snapshots are
+0/1/2/8. CPU mocks do not execute CUDA and do not establish numerical accuracy.
+GPU equivalence gates supplement the separately frozen independent dense
+three-level numerical replay; passing either alone is not a conservation,
+performance or physical-accuracy claim.

docs/lifecycle.md

@@ -0,0 +1,26 @@
+# Device state lifecycle (uniform Simulation, FixedPatchStepper)
+
+State is grouped by what a change invalidates. This file describes the code as
+it is; it adds no framework. Line references are to candidate 0f8fdbc3.
+
+| Class | Contents | How it changes | Owner rule |
+|---|---|---|---|
+| 1. Module and its globals | Compile-time (visible to the compiler, fixed per module): `config.h` macros incl. `NX`/`NY`, `COLLISION_MODEL`, `BLOCK_ROOT_BC`, `WALL_*`. Runtime per-module globals (not visible to the compiler; written by host code): `__constant__` `d_params`, `d_w`, `d_cx`, `d_cy`, `d_block_channel`, `d_block_wall`; plus bound kernel handles | Globals are written once by the owner right after `load_module`. Uniform grid: `Simulation._recompile` (construction, body-topology sync) loads a new module and re-uploads; `update_runtime_params` rewrites `d_params` (omega, force, n_objects) between runs. Steppers: never rewritten after construction, so they are immutable for the instance's lifetime although they are runtime values. The blocked slot/reservoir root reads its slot from the `d_block_wall` constant (the former dense route used `WALL_*` macros; both were bit-identical in the parity gates). | Every owner loads its own module (`compiler.load_module` = `module_from_file`, no cache). A loaded module is never shared between live owners: globals are per module, so sharing would share mutable `d_params`. |
+| 2. Geometry, layout, tables | flags, curved-link tables, block layouts and halo pairs, transfer (explode/coalesce) tables, block kinds | Immutable for the life of an instance, except translating circles on the uniform grid: their swept-band flags and cut links are rewritten on the device every advancing step (`MovingCircleCells`/`MovingCircleLinks`, docs/moving_bodies.md); the host flag mirror is then stale for those cells. Uniform grid otherwise: rebuilt by body sync. `FixedPatchStepper`: a geometry change is a new instance (`remap_finest`), committed only after a successful transfer. | No in-place table edits. |
+| 3. Controls and dependent boundary columns | Jet amplitude -> per-link `surface_velocity`; body actions (uniform grid) | Between steps, without a table or module rebuild (`set_jet_amplitude`). | Input (index, level, amplitude) is validated before any device write; invalid input changes nothing and the instance stays usable. The host copy commits only after the upload returned. Any error after validation leaves the device column undefined and fails the instance: `FixedPatchStepper` status `failed`, `Simulation._failed`; every later device-touching public method (`Simulation`: `stream`, `set_jet_amplitude`, `initialize`, `sync_bodies`, `run`/`step`, `read_surface_exchange`, `read_body(s)`, `get_macroscopic`, `get_ddf`, `update_runtime_params`, `snapshot`, `restore`, save/load checkpoint) raises; cached host readers and host-side staging (e.g. `get_flags` without translating circles, `add_body`/`remove_body` before a sync) do not touch the device and stay callable; with translating circles `get_flags` reads the device flags back and refuses after a failure. Translating-circle targets follow the same rule: `set_body` validates before mutation, the applied offset commits only after a successful synchronized step, and a failed moving step fails the instance (docs/moving_bodies.md). `close()` still releases resources and stays retryable. |
+| 4. Per-step state | population double buffers and their parity, raw-exchange ledgers, observations | Device-only during `step(n)` / `run(n)`; buffer swaps are host-handle swaps. | Valid on the host only after the single wait at the end of the call. |
+
+Storage routes are separate concerns:
+
+- Original uniform grid (`uniform.cu`, `Simulation`): whole-domain `NX`/`NY`.
+- Blocked levels (`blocked.cu`; every `FixedPatchStepper` level, including the
+  single level of `refinements=[]`): `NX`/`NY` are one block window including halo.
+- Dense refinement levels (`refinement.cu`) were removed: `level_blocks` is
+  required and every refinement level is blocked.
+
+A single-rectangle refinement (`FixedPatch2D`) is stored in its own fine
+window frame (`FixedPatchStepper.__init__`,
+`BlockLayout2D.build(*pair.fine_shape, ...)`). Only a rectangle set
+(`FixedPatchSet2D`) uses the level-wide frame `(2*ny, 2*nx)`, whose
+`fine_layout` requires that full grid to be divisible by the tile
+(`refinement.py:240-252`).

docs/moving_bodies.md

@@ -0,0 +1,451 @@
+# Moving circles on the uniform dense grid
+
+## Status and user guide (current)
+
+Development-stage feature, integrated from the reviewed slices S1–S3a
+(production code identical to `653fd997`). Physical evidence and its limits:
+`docs/validation/moving_bodies_stage1.md`. The force used as a structural RHS
+is a declared stage choice, not an established result.
+
+*What it does.* Translating circles (with optional spin) on the dense
+double-buffer D2Q9 path: per-step cut links from an FP64 geometry record
+(M2 `MovingCircleLinks`), reclassification and refill of covered/uncovered
+cells (M1 `MovingCircleCells`), moving-wall Bouzidi with wall velocity
+`u + omega x r`, and separate per-body diagnostics.
+
+*API.*
+- `Simulation.add_body("circle", center=(x, y), radius=r,
+  translation=Translation(offset_box, max_speed))` before `initialize()`;
+  `offset_box = (x_min, x_max, y_min, y_max)` in lattice cells around the
+  base centre (must contain 0), `0 < max_speed ≤ .5`.
+- `set_body(id, offset=(dx, dy), vx=..., vy=..., omega=...)` sets a pending
+  target (validated against the applied offset: box, Euclidean step ≤ .5
+  cell, speed, no sliding hold); `vx`/`vy` are the interval wall velocity.
+- `run(1)` advances a pending target and commits it only after the step
+  synchronizes with `no_donor == 0`; `run(n > 1)` with a pending target
+  raises; without a target `run(n)` holds the geometry (spin allowed).
+  Direct `LBMStepper.step` refuses while a target is pending.
+- `moving_diagnostics()` returns per body the columns of
+  `MovingTables.DIAG` (CME, Wen term, link mass, cover/uncover momentum and
+  mass, eq_only, no_donor, crossings) accumulated since obs were zeroed;
+  `obs`/`read_force` keep their contract (CME on the body).
+- `get_flags()` reads device flags back when moving circles exist.
+- `snapshot()` / `restore()` save and restore populations only, keeping the
+  current clock, controls, observations, geometry and flags. Use them only
+  with unchanged geometry; restoring across a translation is unsupported
+  and is not rejected at runtime. They do not provide FSI rollback.
+
+*Supported:* dense double buffer, D2Q9, FP32 unshifted, SRT/MRT, circles,
+spin. *Rejected before mutation:* EsoPull, ddf shifting, D3Q19, refinement /
+blocked steppers, Jets or surface actuation on a moving circle,
+`sync_bodies` and checkpoints while a moving circle exists, swept bands that
+touch the domain edge, other bodies, sensors or force regions.
+
+*Failure lifecycle.* Device-side failures (upload, step, sync, no_donor)
+mark the Simulation failed; later run/step/sync/checkpoint calls and direct
+stepper calls refuse until `close()`.
+
+*Known limitations.* No mass correction at curved walls (static or moving);
+cover/uncover and Wen terms are diagnostics, not a selected force law; the
+host loop costs a fixed per-step synchronization (≈ 1 ms/step measured on a
+7.2 M-cell grid, run(1) class); outer boundaries are the single dense
+channel package (see `configs/CONFIG.md`).
+
+## Design record (staged contract, kept as written)
+
+The sections below are the contract the slices were reviewed against
+(S0 → S3a). They are kept unchanged for provenance; where they say "draft",
+"proposed" or "until S2/S3", the status above supersedes them.
+
+Original scope (Frank via TRON, thread C0C78UFKGRM/1793335557.460509):
+uniform-grid prescribed translation and single-cylinder free transverse VIV;
+base main `b2034f87e03656c5f67ab88562a70d6c338b9918`.
+
+## 1. Working standards
+
+- Lean, readable kernels in the existing idiom (`kernels/step/*.cu`, shared
+  `apply_bouzidi_link`); Python manages state and validation. No framework,
+  no compatibility layer, no new dependency.
+- The existing stationary/rotating path (`CurvedBoundaryKernel`, host link
+  packing, `sync_bodies`) stays byte-identical. Moving circles are a separate,
+  explicitly enabled path with its own numerical contract (this file).
+- One authority per state (section 4). No per-step full-domain download,
+  rebuild or recompile; local swept-band device updates are in scope.
+- Small slices (S1 host spec, S2 kernels without motion, S3 motion + refill,
+  S4 oscillator); each reviewed SHA is frozen before targeted runs.
+- Tolerances, benchmark parameters and the force composition used in the
+  structural RHS are declared before the runs that judge them. Fresh vs carried
+  evidence and existing baseline failures are recorded; smoke, convergence and
+  physical validation are reported separately. No undeclared force filtering.
+- External code (waLBerla GPLv3, FluidX3D source-available, VIVSIM) is a
+  concept reference only; nothing is copied.
+
+## 2. Current update order (main b2034f87, dense double buffer)
+
+`Simulation.run(n)`: upload host action (if `upload_act`) → zero obs (if
+`zero_obs`) → `DoubleBufferStepper.step(n)` → download obs → synchronize.
+
+Per step (`lbm/stepper.py` `step`):
+
+1. `CurvedBoundaryKernel` over the packed cut links: reads post-collision
+   `G^{n-1}` at `k_f` (and `k_f - c` for q < 1/2), adds the moving-wall term
+   (`Uw = -omega*ry, Vw = omega*rx` + optional per-link `surface_velocity`),
+   writes the reflected value into slot `opp` of the solid node `k_s`, and
+   accumulates `c(f_toward + f_reflected)` and torque into `obs`.
+2. `OneStep` pull/collide `ddf → temp` (collides FLUID cells; obstacle
+   interiors flagged `SOLID|OBSTACLE|BC_CURVED`), then buffer swap.
+3. `ForceRegionKernel`, `SensorKernel`.
+
+Raw `obs` force is the force **on the body** (link derivation in section 6;
+DFG docs report `Cd > 0` from it). Translation `vx, vy` in the action slots is
+currently stored but not read by any curved kernel.
+
+## 3. Proposed update order (moving circles)
+
+Per step n, before the existing step 1:
+
+- **M1 `MovingCircleCells`** (one thread per swept-band cell): classify with the
+  analytic predicates `in_old = inside(x, c^{n-1})`, `in_new = inside(x, c^n)`;
+  write `flag = in_new ? SOLID|OBSTACLE|BC_CURVED : FLUID`; covered cells
+  (`!in_old && in_new`) accumulate `node_cover`; fresh cells
+  (`in_old && !in_new`) are refilled (section 5) and accumulate `node_uncover`.
+- **M2 `MovingCircleLinks`** (one thread per band cell × direction): compute
+  q and hit point at `c^n` (FP64, same formula as `find_circle_intersection`,
+  same clamp [0.01, 1] and fallback classes as `CircleGeometry.build_cut_links`),
+  skip non-cut slots, call `apply_bouzidi_link` with
+  `u_w = (vx^n, vy^n) + omega × (hit - c^n)`, accumulate the link terms
+  (section 6).
+
+Then the unchanged steps 1–3. M2 must follow M1 because a q < 1/2 link may
+read `k_f - c` at a fresh cell.
+
+Exclusivity: moving bodies are never packed into the `CurvedBoundaryKernel`
+link arrays (`n_curved` covers stationary/rotating bodies only), so M2 is the
+sole writer of their solid slots and the sole source of their link force; no
+double write and no double `obs`. The stationary path's packing, launch and
+arithmetic are unchanged.
+
+Completeness: after M1, every (fluid cell, direction) pair in the swept band
+whose neighbour is `in_new` is visited by M2. This holds because the band is
+the circle AABB at the declared extreme offsets plus 2 cells, and the host
+rejects per-step moves with `|c_new - c_old|_2 > 0.5` and bands touching the domain edge,
+other bodies, sensors or force regions. Each M2 write lands at
+`index_f(k_s, opp)`, the exact slot the adjacent fluid cell pulls, so every
+fluid pull from a solid slot of a moving body is BFL-written.
+
+## 4. State, masks and authority
+
+- Host `ObjectState` is the single authority for one displacement
+  `offset = (dx, dy)` relative to the immutable base centre, plus
+  `velocity = (vx, vy)` and `omega`. Centres are always derived
+  (`c = base + offset`), never stored as independent state. Velocity is
+  supplied, never differenced from offsets.
+- `c^{n-1}` is derived from the last *committed* offset, `c^n` from the
+  offset being applied. Per body a small device **motion record**
+  `{c^{n-1}, c^n, u^n}` is uploaded with the action buffer; action-slot meaning
+  is not overloaded. (CANDIDATE layout; OPEN.)
+- Fail-closed commit: an enqueued upload is not a completed one. The new
+  offset becomes the committed offset only after the stream synchronization
+  that follows the upload and the step group succeeds. Any upload or later
+  synchronization failure leaves host and device motion state unknown: the
+  simulation is marked unusable (existing `_require_usable` lifecycle), and
+  no API may report a host/device match afterwards.
+
+### 4a. Applied geometry vs pending target (CANDIDATE, narrow API)
+
+Two distinct facts per moving body, one authority each:
+`applied` = offset of the geometry last applied on the device, changed only
+by a successful commit; `pending` = an optional requested target
+`(offset, velocity)`, changed only by `set_body`. A setter returning proves
+nothing about the device. The uploaded motion record is derived each run:
+`{c_old = base + applied, c_new = base + (pending.offset if pending is not
+None else applied), u = pending.velocity if pending is not None else 0}`
+(explicit `is not None`, so a zero offset or zero velocity is a valid target). Translational wall velocity exists only on a step
+that advances to a pending target; a hold step (`c_old == c_new`) has
+translational `u_w = 0` (spin unchanged), so a non-advancing circle never
+acts as a sliding wall. One moving step consumes one target.
+
+| situation | contract |
+|---|---|
+| `set_body` target | validated against `applied` (box, `|Δc|_2 ≤ 0.5` cell, speed bound) before mutation; on success replaces `pending` |
+| target with `offset == applied` and nonzero translational velocity | `ValueError` before mutation (would be a hold step with sliding wall velocity) |
+| two setters before a run | last wins; each validated against `applied`, not against the earlier pending target |
+| `run(1)` with pending | upload record, step, sync; on success `applied := pending.offset` (applied stores only the offset), `pending := None` |
+| `run(1)` without pending | hold: `c_old == c_new`, no cover/uncover, links at `applied`, translational `u_w = 0` |
+| `run(n > 1)` with pending | `ValueError` before mutation (single-step-only moving API) |
+| `run(n > 1)`, no pending | allowed: hold for n steps, translational `u_w = 0`, spin only |
+| `run(0)` | no motion upload, no commit; `pending` kept |
+| validation failure | `ValueError`, nothing mutated, retry allowed |
+| upload/launch/sync failure after enqueue | simulation unusable; `applied` and `pending` are not reported as device truth; no re-entry |
+
+Displacement norm: Euclidean per-step `|c_new - c_old|_2 ≤ 0.5` lattice
+cells (declared bound; CANDIDATE value).
+- Membership is never read from a flag that M1 is overwriting. The host
+  verifies at `add_body` that every swept-band cell has base flag FLUID, so the
+  band's base state is known without reading `flag_gpu`.
+- `flag_gpu` is the device authority for band cells while a moving body
+  exists; the host flag mirror is stale for those cells and is not used.
+
+## 5. Refill of fresh cells (CANDIDATE)
+
+- Stored time level: everything in `ddf` at M1 is post-collision `G^{n-1}`; the
+  refill writes all 9 slots at that same level, so every slot of a fresh cell
+  that the following pull or a q < 1/2 link may read is defined. Donor values
+  are read at the same level `G^{n-1}` (old-fluid cells, untouched by M1).
+- `G = f_eq(rho_bar, u_w(x)) + G_neq(x_d)` where `rho_bar` = mean density of
+  valid neighbours and `x_d` = the valid neighbour best aligned with the outward
+  normal `(x - c^n)/|x - c^n|`; `G_neq(x_d) = G(x_d) - f_eq(rho(x_d), u(x_d))`.
+- Valid donor: inside the domain, base FLUID, `!in_old && !in_new`.
+- Sets: `V(x)` = the 8 lattice neighbours that are in the domain, base FLUID
+  and `!in_old && !in_new`. `rho_bar` = mean density over `V(x)`. NEQ donor =
+  the member of `V(x)` with the largest `c·n` among those with `c·n > 0`
+  (`n` = outward normal at `c^n`); none → NEQ part 0 (counted as `eq_only`).
+- `V(x)` empty → no defined density: the cell is refilled with
+  `f_eq(RHO, u_w(x))` so all 9 slots stay defined, the `no_donor` counter is
+  incremented, and the host treats `no_donor > 0` after the run as a hard
+  failure (simulation unusable). It is not a silent fallback.
+- Non-emptiness is NOT assumed from the displacement bound. Geometry
+  assumptions: circle radius `R ≥ R_min` (CANDIDATE 4 cells), `|Δc|_2 ≤ 0.5`.
+  S1 includes a host enumeration over sub-cell centre positions and
+  displacement directions on a fine grid within these bounds that checks every
+  fresh cell has nonempty `V(x)`; it is evidence for those bounds, not a
+  proof, and runtime keeps the counter.
+- Fresh cells only write, old-fluid cells only read: no race.
+
+## 6. Discrete momentum ledger (to review; not a selection)
+
+Notation per step n: `F^n` = fluid set after M1; links L = (k_f, dir) at
+`c^n`; `f_t = G_dir(k_f)`; `f_r` = value M2 writes into `(k_s, opp)`.
+Fluid momentum before streaming:
+
+    P_pre = P(G^{n-1} on F^{n-1}) - sum_cover sum_q c_q G_q + sum_fresh sum_q c_q G_q^refill
+
+During the pull, every population entering a fluid cell comes from a fluid
+cell except the BFL-written slots; `f_t` leaves into solid and is never pulled
+by a fluid cell. Collision conserves momentum for SRT/MRT without forcing.
+Hence, in exact arithmetic,
+
+    P_fluid^n - P_fluid^{n-1} = - sum_L c (f_t + f_r) - I_cover + I_uncover + B^n + S^n
+
+with `B^n` external-boundary momentum (inlet/outlet/walls) and `S^n` forcing.
+So **`F_CME + node_cover - node_uncover`** is, by construction, the body
+momentum that balances the fluid ledger of *this* storage/update order.
+Branch details: halfway fallback links (`f_r = f_t` plus the moving-wall
+addend) and q < 1/2 links enter the link accumulators exactly like Bouzidi
+links, with `c(f_t + f_r)`. In the q < 1/2 branch `G_dir(k_f - c)` is an
+interpolation input only, not a fluid-momentum sink. Pull-slot completeness
+is the section 3 contract. The scope excludes `ddf_shifting` (rejected), so
+the unshifted force form applies. The balance is a fluid-side identity; it
+does not close body+fluid globally in a domain with inlet/outlet/forcing
+(`B^n`, `S^n`), and the solid-slot writes are boundary plumbing, not physical
+streaming packets.
+
+The Wen 2014 relative-velocity link sum adds `-u_w (f_t - f_r) = u_w dm` per
+link (`dm = f_r - f_t`, the BFL mass defect). That term has no counterpart in
+the fluid ledger above. Peng et al. (PRE 2016 submitted, §II.C, Eqs. 20–21)
+show for a straight wall that the bounce-back error accumulated before a node
+switch cancels with the switching momentum. Whether `sum u_w dm` approximates
+`I_cover - I_uncover` here (implying double counting if both are used) is
+**NOT demonstrated** for this implementation: it needs a bounded experiment
+(prescribed slow translation; cumulative `sum u_w dm` vs cumulative node
+impulse, per crossing cycle). Momentum conservation is also distinct from
+Galilean invariance, which G4 tests.
+
+External reference note: waLBerla's covered/refill momentum switches
+(`conserveMomentumWhenMapping`, `conserveMomentumWhenRestoring`) default to
+false (Astra), so their existence does not establish which combination its
+validation cases use. A bookkeeping identity alone does not select the
+physical force either.
+
+Mass ledger (same proposition status). With `M^n` the active-fluid mass
+summed over `F^n` at the sample point,
+
+    M^n - M^{n-1} = sum_L dm - m_cover + m_uncover + B_m^n
+
+(`dm = f_r - f_t`, `m_cover`/`m_uncover` = summed `sum_q G` of covered and
+refilled cells, `B_m` external-boundary mass flux; collision conserves mass).
+
+Sample point (fixed): post-collision storage after the swap of step n, i.e.
+the same level `G` that M1 reads at step n+1; both ledgers are evaluated
+there. Ledger residual = left side minus every listed term. Zero mass flux
+does not imply zero momentum exchange: closed walls (bounce-back, free-slip)
+still exchange momentum, so "no inlet/outlet, no forcing" does NOT give
+`B = S = 0`. The rounding-level momentum check therefore uses either a
+momentum-isolated case (periodic in both directions, no forcing) or counts
+the wall impulse explicitly as part of `B`; the mass check may use a closed
+domain. Otherwise `B`, `S` are not separately measured, the residual is
+reported as their estimate and is not a pass criterion.
+Both ledger identities are **proposed, unreviewed**: they are not called
+proven until review and a host replay agree.
+
+Accumulators (separate, per body, per step window; all reported raw):
+`link_cme`, `link_wen_correction` (= `sum u_w dm`), `node_cover`,
+`node_uncover` (momentum), `link_dm`, `mass_cover`, `mass_uncover` (mass),
+plus counters of crossings, `eq_only` and `no_donor`, so force spikes can be
+correlated with crossing events.
+
+**OPEN — structural RHS candidates (not selected):**
+(a) `link_cme + node_cover - node_uncover`; (b) `link_cme + link_wen_correction`
+(no node impulse). Selection follows the ledger review and the bounded
+experiment above.
+
+## 7. Rejection semantics
+
+- Before any mutation (`ValueError`, no device write, host state unchanged):
+  moving body with EsoPull, `ddf_shifting`, refinement/blocked stepper, D3Q19,
+  Jets or surface actuation on that body, `sync_bodies`/checkpoint while a
+  moving body exists; swept band touching domain boundaries, other bodies,
+  sensors or force regions; `set_body` offset outside the declared box,
+  per-step move `|c_new - c_old|_2 > 0.5` cell (the single bound of 4a), speed
+above the declared bound.
+- Host motion state is committed only after the upload *and* the following
+  synchronization of the step group succeed (section 4); any failure in
+  between makes the simulation unusable and no host/device match is reported.
+- The only soft device diagnostic is `eq_only` (NEQ part omitted, counted).
+  `no_donor > 0` is a hard failure: it is checked after the step group and
+  before the step is committed or any results are returned; on failure the
+  simulation is unusable (section 5).
+
+## 8. Coupling and units (CANDIDATE)
+
+Lattice units, rho0 = 1, per unit span. Step n uses `c^n`, `u^n` and yields
+`F^n`. Weak staggered update
+`v^{n+1} = v^n + (F^n - c v^n - k y^n)/m`, `y^{n+1} = y^n + v^{n+1}`
+(Newmark is an alternative; OPEN). Mass, natural frequency, damping and `U_r`
+follow the chosen benchmark's own definitions. Leontini, Thompson & Hourigan,
+JFS 22:857–864 (2006), DOI 10.1016/j.jfluidstructs.2006.04.003, as read by
+Grok from the full text: Re = 200, `m* = m/m_f = 10` (m_f displaced fluid
+mass), `zeta = c/c_crit = 0.01`, `U* = U/(f_N D)` with `f_N` the natural
+frequency in fluid assuming an inviscid added-mass term; the paper also
+reports frequencies normalised by the in-vacuo value. Our runner derives `k`
+from that in-fluid `f_N` (added-mass coefficient as stated in the paper) and
+never from the vacuum formula; `c_crit` convention and the original
+comparison data are still OPEN. Stability/convergence is gated by fluid
+time/space refinement of the coupled run, not assumed from the mass ratio;
+structural sub-stepping does not substitute for fluid-coupling time
+refinement.
+
+## 9. Gates (map; tolerances OPEN, declared before runs)
+
+G0 zero-motion regression, split: G0a populations of the existing stationary
+and spin-only path bitwise unchanged vs main; G0b moving path at rest (with
+and without spin) reproduces the stationary link set and populations; force
+estimator outputs are compared separately from populations, since the moving
+path adds estimator terms · G1 raw force sign (`Cd > 0`) ·
+G2/G3 prescribed translation incl. ledger accumulators · G4 matched
+relative-flow (moving body in quiescent fluid vs fixed body in uniform
+stream), optional boost, co-moving sanity · G5 Dütsch et al. 1998 Re 100,
+KC 5 in-line (needs 2-component offset) · G6 Leontini free transverse VIV
+(m* = 10, ζ = 0.01, Re = 200, definitions pending) · G7 time-level contract
+frozen before the oscillator.
+
+Candidate pre-run engineering tolerances (Astra; for discussion, not
+literature limits or measured outcomes; norms, averaging window, convergence
+protocol and physical reference uncertainty must be fixed before adoption, and
+none may be weakened after seeing runs):
+normalised momentum-ledger residual FP32 ≤ 5e-6 (FP64 oracle ≤ 2e-13);
+10-cycle relative mass drift ≤ 1e-4; prescribed-motion grid study D = 40/80/160
+with change in the force-response amplitude (observed quantity and norm to be
+named before adoption) ≤ 2 % and phase ≤ 2°; enlarged domain
+amplitude change ≤ 1 %; matched-frame force RMS ≤ 2 % and improving with
+refinement; VIV refinement amplitude ≤ 2 %, frequency ≤ 1 %, five consecutive
+cycle amplitudes within 1 %.
+
+Conditions stated before any moving kernel (S2/S3), not only at the
+oscillator stage: (i) fluid refinement protocol for the prescribed-motion
+gates — diffusive scaling (dx halved, dt quartered, physical Re, KC and
+amplitude fixed), the observed quantities and norms named in advance;
+(ii) Galilean constant-boost G4-boost requires boundaries compatible with a
+uniform boost (periodic in the boost direction or boundaries that move with
+it); if the current dense configuration cannot represent that, G4-boost is
+recorded as not runnable rather than replaced by another test.
+
+## 10. Proposed minimal S1 scope (host only; held until cross-review)
+
+- `add_body` moving-circle declaration: base centre, declared offset box
+  (x/y), speed bound; swept-band computation and band-placement validation.
+- `set_body(offset=..., velocity=..., omega=...)` validation before mutation
+  (section 7), applied/pending state and the run-transition table of 4a,
+  and the fail-closed commit of section 4.
+- Host enumeration check of refill-donor non-emptiness (section 5) within
+  the declared `R_min` and displacement bound.
+- Motion-record host layout and upload path; exclusion of moving bodies from
+  the packed `CurvedBoundaryKernel` links (stationary packing unchanged).
+- Explicit rejections for unsupported modes.
+- S1 execution guard: until the S2 moving kernels exist, any `run(n)` with
+  `n > 0` (and `step(n)`) while a moving body is declared raises before any
+  device mutation (no action/motion upload, no launch), including the
+  nominal at-rest case, because the moving body is excluded from the static
+  packed links and nothing else would apply its boundary. `run(0)` keeps its
+  existing behaviour. Simulations without moving bodies are unaffected.
+  Preparation/commit helpers are exercised by host tests with mocks; no
+  operational unsupported stepping path is exposed.
+- Host tests (Astra runs them): rejection-before-mutation, band geometry,
+  derived centres, fail-closed behaviour under an injected upload/sync
+  failure, stationary packing byte-identical, execution guard (positive-step
+  run with a moving body raises before upload/launch; stationary unaffected). No kernels, no GPU runs, no
+  y-only VIV oscillator (S4), no force RHS.
+
+## 10a. S2a — fixed-centre moving links (implemented on `claude/moving-bodies-s2a`)
+
+- `MovingCircleLinks` (`kernels/step/moving_circle.cu`, dense double buffer)
+  runs before the static curved kernel when moving tables are attached: one
+  thread per (band cell, direction) slot, FP64 `{cx, cy, r}` at the applied
+  offset, q/hit/clamp/fallback in the order of `build_cut_links` with explicit
+  `_rn` operations (host/device bit parity is a test target, not a claim),
+  then the unchanged `apply_bouzidi_link` with spin wall velocity only.
+- `obs` keeps its contract (CME and torque from `apply_bouzidi_link`). A
+  separate per-body diagnostics buffer receives `cme`, the Wen term
+  `u_w * dm`, `link_dm` and the link count from the same link outputs; it is
+  zeroed with obs and only exists when moving circles do. Optional
+  `slot_debug` (q, fallback, rx, ry per slot) is null in production.
+- Displacement is disabled: `set_body(offset=..., vx=..., vy=...)` on a
+  translating circle raises before mutation, before and after initialize, so
+  no pending target can exist and `run`/`step`/direct `LBMStepper.step` all
+  hold at the applied geometry. `initialize()` never reads or consumes
+  `pending`. `stepper.blocked` is cleared only when the moving tables are
+  attached (initialize, stepper recreation).
+- S3 rule (not implemented): once targets are re-enabled, any pending target
+  must raise in `run`/`step` and in `LBMStepper.step` alike before any launch,
+  swap or step-count change; zero-step calls never consume it.
+- Not validation: a pass of the zero-motion gates says nothing about moving
+  geometry. GPU parity (G0a/G0b) is unverified until run on a free device.
+
+## 10b. S3a — translation with refill (implemented on `claude/moving-bodies-s3a`)
+
+- Targets are enabled again (4a). `set_body(offset, vx, vy)` validates against
+  `applied`; a pending target blocks direct `LBMStepper.step(n > 0)` before any
+  launch; `run(n > 1)` with a target raises before mutation; `run(0)` never
+  consumes it; `run(1)` advances it.
+- Per advancing step, on one stream: upload the immutable FP64 records
+  `{c_old, c_new, r, u}` (only when changed) → M1 `MovingCircleCells` → M2
+  `MovingCircleLinks` (`u_w = u + omega x r` at the hit point) → static curved →
+  `OneStep` → swap → force region → sensors → synchronize → read `no_donor` →
+  commit (`applied := pending.offset`) → upload the hold record
+  (`c_old = c_new = applied`, `u = 0`) → synchronize. Hold steps launch no M1
+  and are the S2a path. Commit point: the advancing step-group sync plus a
+  zero `no_donor` count; a failure before it commits nothing. The hold-record
+  upload stages the next step after the commit: if it (or its sync) fails,
+  `applied` already matches the moved device geometry, but the Simulation is
+  still marked failed and refuses reuse. Any failure from the first upload on
+  marks the circles and the Simulation failed.
+- M1 classifies with the old/new predicates only (no flag reads). Covered
+  cells add raw `sum c G` / `sum G` of `G^{n-1}` to `cover_*` and become
+  `SOLID|OBSTACLE|BC_CURVED`. Uncovered cells: donors are fluid in both
+  geometries; `rho_bar` over all of them; NEQ from the donor with the largest
+  unnormalized `c·n > 0` (first direction wins ties, `n` from `c_new`);
+  `u_w` (translation + spin) at the cell position; all nine slots written;
+  raw `sum c G`, `sum G` of the refill go to `uncover_*`; no donor →
+  `f_eq(RHO, u_w)` plus `no_donor` (hard failure before commit); no NEQ donor
+  → `eq_only`.
+- `get_flags()` reads the device flags back (synchronized) when moving tables
+  exist; otherwise it returns the host array as before.
+- Not selected: the structural force. CME+node vs CME+Wen stay OPEN until X1
+  and G4 have run.
+
+## 11. Remaining decisions
+
+Structural RHS (section 6); motion-record layout; refill details; coupling
+scheme; benchmark definitions and digitized reference data; tolerances;
+execution/resource feasibility (Astra, pending); whether a quiescent domain
+(zero inlet velocity) runs cleanly in the current config.

docs/shifted_blocked_candidate.md

@@ -0,0 +1,61 @@
+# Opt-in shifted blocked candidate
+
+This candidate is based on fbe7377. The default remains unshifted. Enable with
+`LBMConfig(ddf_shifting=True)` only on the supported routes below.
+
+| Route | Candidate support |
+|---|---|
+| PeriodicBlockStepper, FP32 D2Q9 SRT double-buffer, no LES | shifted or unshifted |
+| FixedPatchStepper, every level blocked and same representation | shifted or unshifted |
+| Passive stationary circular BFL boundary and raw exchange | supported candidate scope |
+| Synchronized three-level child remap | private raw shifted snapshot, exact overlap/copy |
+| Dense root/refinement or mixed representation | rejected for shifted |
+| Slot/reservoir, surface actuation, velocity Jet | existing public shifted exclusion retained |
+| Other collision/lattice/storage/streaming/LES combinations | existing exclusions retained |
+
+The D2Q9 equilibrium helper accepts a retained density offset only in shifted
+compilation. BlockStep computes delta=sum(g) before adding the unit density;
+velocity uses the existing macro calculation. The existing SRT collision and
+all unshifted expressions remain. No global precision type or duplicate
+collision implementation is introduced. Ordinary shifted Simulation callers
+still use the existing rho−1 overload; this candidate does not change their
+numerical method.
+
+Public initialize receives physical populations and performs shifted subtraction
+in FP64 before the one FP32 storage cast. Public shifted download returns FP64
+physical populations with exact-rational D2Q9 background weights. Internal raw
+snapshots retain FP32 g and a representation tag; runtime remap never decodes
+and re-encodes overlap. Exact mass is interpreted as 1+sum(g), and momentum as
+sum(c*g); analyses should use raw values for tiny perturbation budgets. The
+FP32 BFL force constants have their own arithmetic rounding; no exact global
+conservation claim follows from shifting.
+
+Planar helper formulas include their shifted reference-density offsets and have
+actual-header host tests. Their public shifted route remains excluded until a
+separate test-gated migration. Next velocity-Jet work must validate physical
+wall density, incoming/outgoing populations, raw force/mass, ownership and
+transfer interactions before relaxing that restriction.
+
+Evidence so far: selected-cell CUDA replay favored retained-delta shifting;
+this is not full-solver validation. Host algebra/storage/remap tests and staged
+GPU continuation, three-grid cylinder physics, raw budgets, Couette helper
+stress and measured runtime are separate gates. Original failed experiments
+remain evidence; no acceptance threshold is relaxed.
+
+## Direct-input-momentum equilibrium candidate
+
+The shifted BlockStep now constructs the linear equilibrium term from input
+momentum j, without reconstructing rho*u. For opposite axis pairs the odd term
+is j/3; for diagonal pairs it is (jx +/- jy)/12, evaluated with explicit
+round-to-nearest division. The even term is
+w*[delta + 4.5*(c dot j)*(c dot u) - 1.5*(j dot u)].
+This is the same second-order D2Q9 equilibrium in exact arithmetic. Original SRT,
+storage, boundaries, and transfers are unchanged. No collision residual or force
+is corrected afterward. Existing four/five-argument equilibrium APIs are retained;
+only shifted blocked collision calls the new six-argument momentum helper.
+
+The all-fluid read-only CUDA replay reduced signed x-momentum error by 120–2285x
+at five sampled states, with lower mass/momentum and second-moment RMS errors.
+Signed mass bias was larger (~1e-12/cell/hop), so full evolving mass budgets remain
+mandatory. This local evidence does not establish physical convergence or speed.
+The unshifted default and its arithmetic path remain unchanged.

docs/supported_settings.md

@@ -0,0 +1,96 @@
+# Supported settings: 2D Jet + fixed multilevel refinement (candidate 888c8038)
+
+Every entry names the guard that enforces it (file and function or kernel guard,
+at source revision 888c80381c006e976be2af8a452288729fc17c1b) and, where one
+exists, an existing test that exercises it. A setting not listed here is not
+claimed. Observations at the end are tied to the exact case in which they were
+measured; they are not general bounds.
+
+## Lattice, storage, collision
+
+| Setting | Supported | Guard |
+|---|---|---|
+| Dimension / lattice | 2D D2Q9 only (3D refinement is future work) | `lbm/refinement.py` `FixedPatch2D.from_config`; `#error` guards in `lbm/kernels/blocked.cu` |
+| Precision / streaming | FP32 storage, double buffer | same guards |
+| Collision on refinement levels | SRT or MRT; TRT and LES rejected | `lbm/refinement.py` `FixedPatch2D.from_config` (re-checked for fine boundaries in `prepare_fine_boundary`) |
+| Shifted (ddf_shifting) storage | supported (every level is blocked); one representation on all levels | `lbm/refinement_stepper.py` `FixedPatchStepper._check_storage` |
+| Fine relaxation | 1/tau_fine must lie inside the configured omega guards | `lbm/refinement.py` `FixedPatch2D.from_config` |
+| Single blocked level `FixedPatchStepper(refinements=[], level_blocks=[(by, bx)], level_objects=[circles])` (replaces `PeriodicBlockStepper`, removed in 8e1feff) | doubly periodic, SRT only, no LES/Jets/projection/exchange observation, stationary passive circles; `download()` returns a 1-tuple | `lbm/refinement_stepper.py` `_check_levels`, `FixedPatchStepper.__init__`; `lbm/blocks.py` `static_circle_tables` |
+| Refinement storage | blocked on every level: `level_blocks` is required, one tile `(by, bx)` per level dividing that level; a whole-level tile (`(ny, nx)` at the root, the fine window shape for one rectangle) always divides. Dense and mixed dense/blocked storage were removed (parity of D/D, D/B and B/B recorded at 1573942 and 2469af7) | `lbm/refinement_stepper.py` `_check_levels`, `FixedPatchStepper.__init__` |
+
+Tests: `tests/unit/test_refinement_mrt.py`, `tests/validation/multigrid/test_refinement_mrt_gpu.py`,
+`tests/unit/test_shifted_storage.py`, `tests/unit/test_shifted_block_operators.py`.
+
+## Refinement hierarchy (`FixedPatchStepper(cfg, *, context, refinements, ...)`)
+
+| Setting | Supported | Guard |
+|---|---|---|
+| Depth | at least one refinement level; one entry per level in `level_blocks`/`level_objects`/`level_jets` | `lbm/refinement_stepper.py` `_check_levels` |
+| Single L1 rectangle | two-coarse-cell margin to the domain edge | `lbm/refinement.py` `FixedPatch2D.from_config` |
+| Several L1 rectangles (union) | require `level_blocks[0]` and `level_blocks[1]`; transfers must close (dependency checks, no fixed gap rule) | `lbm/refinement_stepper.py` `_check_levels`; `lbm/refinement.py` `_check_parent_pull_closure` |
+| Nested levels | depth >= 3 must be all blocked; a blocked level requires blocked levels below; a scalar child needs a scalar parent | `lbm/refinement_stepper.py` `_check_levels`; `lbm/hierarchy.py` `build_hierarchy` |
+| Nested transfer support | child only over inherited ACTIVE cells, donors/receivers uncovered ACTIVE, no child over the parent restriction footprint | `lbm/refinement.py` `_nested_kind` |
+| Tile shape | positive `(by, bx)`; the level allocation must be divisible by the tile (no partial tiles yet) | `lbm/refinement_stepper.py` `_check_levels`, `lbm/refinement.py` `FixedPatchSet2D.fine_layout` (shape); `lbm/blocks.py` `BlockLayout2D.build` (divisibility) |
+| Coarse boundary | `periodic`, `slot_reservoir` or `channel` | `lbm/refinement_stepper.py` `FixedPatchStepper.__init__` |
+| `slot_reservoir` | on-site velocity bottom slot, reservoir top, velocity 0, 2 <= slot width < nx, patch rows 4..ny-4 | `lbm/refinement_stepper.py` `FixedPatchStepper.__init__`; `lbm/refinement.py` `prepare_fine_boundary` |
+| `channel` | all levels blocked; Zou-He inlet, pressure-NEQ outlet, stationary bounce-back walls; transfers away from the closure | `lbm/channel.py` `validate_channel_config`, `validate_channel_transfers` |
+| Explosion | `constant` (default); `projected_linear` only periodic, all-blocked SRT, no bodies/Jets, no LES (experimental) | `lbm/refinement_stepper.py` `FixedPatchStepper.__init__` |
+| L2 runtime remap (`remap_finest`) | periodic three-level L2 sets only, no L0/L1 bodies, identical pinned boundary | `lbm/refinement_stepper.py` `FixedPatchStepper.remap_finest` |
+
+Tests: `tests/unit/test_refinement_three_level_multipatch.py`, `tests/validation/multigrid/test_refinement_multipatch.py`,
+`test_refinement_three_level.py`, `test_refinement_three_level_multipatch_gpu.py`, `test_refinement_blocked_base.py`,
+`test_refinement_blocked_fine.py`, `test_channel_root_gpu.py`, `tests/unit/test_channel_root.py`,
+`tests/unit/test_projected_pair_stepper.py`, `test_runtime_child_remap_gpu.py`, `test_pinned_body_remap_gpu.py`.
+
+## Bodies and Jets on refined levels
+
+| Setting | Supported | Guard |
+|---|---|---|
+| Bodies | stationary circles without sensor/force-region roles, entirely inside the patch union, fully resolved, disjoint, stencil away from the two-hop transfer footprint | `lbm/refinement.py` `prepare_fine_boundary` |
+| Level | not on L0; only on the finest level of a nested hierarchy | `lbm/refinement_stepper.py` `_check_levels` |
+| Jet condition | velocity only; `pressure` is reserved and raises NotImplementedError | `body/jets.py` `Jet.__post_init__` |
+| Jet geometry | each Jet selects resolved links of exactly one stationary body; no Jet/Jet or Jet/SurfaceActuation overlap; abs(amplitude) < 1 lattice | `body/jets.py` `Jet.__post_init__`, `jet_link_shapes`, `_surface_links` |
+| Jets with shifted storage | only in the all-blocked stepper with SRT and no LES | `body/jets.py` `_surface_links` |
+| SurfaceActuation | unshifted storage only | `body/objects.py` `SimObject.validate_surface_actuation` |
+| Raw boundary exchange (force) | blocked body levels only; the window ledger requires `observe_raw_exchange` | `lbm/refinement_stepper.py` `FixedPatchStepper.__init__` |
+| Checkpoint with Jets | refused | `simulation.py` `Simulation.save_checkpoint` |
+
+Raw exchange is the cut-link momentum reaction (wall + aperture), not a validated
+nozzle thrust or stress load. Jet amplitude is a lattice velocity, not a flow rate.
+
+Tests: `tests/unit/test_jets.py`, `test_jets_review.py`, `test_shifted_jets.py`, `test_raw_exchange.py`,
+`tests/validation/multigrid/test_refinement_jets.py`, `test_shifted_jets_gpu.py`, `test_raw_exchange_gpu.py`,
+`test_exchange_window.py`, `test_fine_surface_gpu.py`.
+
+## Observations from specific tested cases (not general bounds)
+
+- SRT channel root vs uniform OneStep, strict-parity test
+  `tests/validation/multigrid/test_channel_root_gpu.py::ChannelRootGPU::test_uniform_matched_root`:
+  in one of its 18 sub-cases (2 storage modes x 3 profile/clamp/damp settings x 3 blocks; which
+  one is not recorded), 1 of the 4320 compared values differs, max abs 2.33e-10, max rel 1.77e-7
+  (about 2 ULP). The test remains failed; its cause and any general bound are unresolved.
+- MRT root parity test
+  `tests/validation/multigrid/test_refinement_mrt_gpu.py::RefinementMRTGPU::test_uniform_matched_mrt_root`
+  (12 sub-cases: 2 storage modes x 2 profiles x 3 blocks, default outlet settings) passed bitwise
+  in the Horsea focused GPU run at K1 7813334 (2026-10-21).
+- Periodic Taylor-Green Re 100, measured at 36ffc8b1 (V3 matched pair, N128 depth 2):
+  every per-sample screen passed; the constant explosion's aggregate worst velocity L2,
+  0.004418, exceeds its preregistered 0.002 budget, while projected_linear passed that budget.
+- Curved-wall pressure (pilot harness, exact-q analytic annulus, tau 0.8): the coarse swirl r1
+  case exceeded its terminal density-gain cap (1.105e-4 vs 1e-4), so the frozen 9-case matrix
+  is NOT_ESTABLISHED. No validated fix exists. This is a pilot harness, not production code.
+- DFG 2D-1 Re 20 (V4, SRT, t* 60, pressure-NEQ outlet and local Zou-He inlet): refined and uniform
+  runs were NOT_STEADY under the frozen steady rule, so no interval verdict was given.
+
+## Moving circles (dense `Simulation`, uniform grid only)
+
+Translating circles with optional spin are supported on the dense double
+buffer D2Q9 FP32 path only (not on `FixedPatchStepper` or refined levels).
+API, supported/rejected modes and limits: `docs/moving_bodies.md`; stage-1
+evidence: `docs/validation/moving_bodies_stage1.md`.
+
+## Not supported in this release
+
+3D, dynamic/automatic AMR (tagging, time-varying hierarchies beyond `remap_finest`),
+moving bodies on refined levels, pressure Jets, Jet checkpoints, LES or TRT on refined
+levels, partial (non-dividing) tiles.

docs/synchronized_leaf_remap.md

@@ -0,0 +1,172 @@
+# Synchronized leaf G remap and manual continuation
+
+This is a CPU state-transfer component, **not a runtime adaptive solver**.
+It changes only an L2 rectangle union in a three-level periodic hierarchy.
+The body-free case is shown first; stationary L2 bodies/Jets follow the bounded
+support contract below. L0/L1 topology, relaxation parameters, direction order,
+physical frame and completed time remain unchanged. Existing geometry checks
+validate child support/nesting and actual transfer dependencies, without a fixed
+rectangle-gap rule. The three-level remap limit is unchanged by the stepper's
+arbitrary-depth level-list support. The CPU helper itself adds no CUDA,
+scheduler, allocator, boundary handling, collision or ghost refill. A bounded
+runtime adapter is described below.
+
+```python
+from CelerisLab.lbm.refinement import FixedPatchSet2D
+from CelerisLab.lbm.synchronized_remap import RemapTopology, remap_synchronized
+
+# cfg: D2Q9/SRT/FP32/unshifted/double_buffer, nz=1, no LES
+parent = FixedPatchSet2D.from_config(cfg, [(4, 4, 20, 28), (24, 4, 44, 28)])
+old = RemapTopology.from_config(cfg, parent, [(16, 16, 32, 40)])
+new = RemapTopology.from_config(cfg, parent, [(20, 16, 36, 40)])
+candidate = remap_synchronized(
+    old, new, current_g, base_count=7, level_steps=(7, 14, 28),
+    phase="postcollision_g", origin=(0., 0.), spacing=1.,
+)
+```
+
+The example has a 48×32 root; both child supports allow 4×4 blocks.
+Child bounds use the parent's allocated L1 coordinates, not rectangle-local
+indices. A scalar FixedPatch2D parent is also supported: its shifted L1 window
+origin is retained. Physical lower edges are `origin + spacing*(x,y)` on L0,
+`origin + spacing*(parent.fine_origin + (x,y)/2)` on L1 and
+`origin + spacing*(parent.fine_origin + (x,y)/4)` on L2.
+
+Factory options `coarse_boundary` and `objects` must declare `"periodic"` and
+an empty collection; L2 bodies use `objects` as described below.
+LBMConfig's channel settings do not select this operator's boundary mode.
+Geometry metadata is factory-created;
+manual mutation/forging of metadata is unsupported. Caller certifies the
+actual state matches the declared boundary and has no forcing, that all device
+work and old readers are quiescent, and that inputs are the **current owned-leaf
+postcollision G**.
+Count/phase stamps check consistency, not freshness or active-buffer identity.
+
+`current_g` is three NumPy Q-major arrays `(9,ny,nx)`. For blocked inputs,
+pass `layouts=(base_layout, fine_layout, child_layout)`; each optional `None`
+entry denotes dense input. Every leaf must have an owner. Only owner cores
+are read, never redundant block halos. Mixed precision is rejected. FP64 is
+accepted for CPU reference tests; this does not enable FP64 runtime storage.
+Outputs `candidate.g` are separate dense arrays regardless of input layout.
+Memory scales with public grid extents, not only sparse allocated blocks.
+
+Same-level leaf overlap is copied bitwise in physical coordinates. Newly
+refined L2 copies all nine values from its valid old L1 parent. Newly exposed
+L1 receives the complete four-child mean, including q0. Covered parents,
+ghosts and holes never serve as donors; NaN/Inf outside leaves is ignored,
+while nonfinite required leaves or nonpositive density reject the operation.
+Restriction uses FP64 quarter-weight accumulation and rounds to the input
+dtype. New nonleaves are NaN. Source arrays/metadata are not changed.
+
+`candidate` retains `base_count`, `level_steps`, `phase`, `origin`, `spacing`
+and new `topology.leaf_masks`. Existing `FixedPatchStepper.initialize` resets
+the counter: using it is **not** a continuation adapter. This component neither
+publishes a candidate nor retires old state. Runtime table rebuild/halo refill
+and correct first-step scheduling are handled only by the explicit adapter below.
+
+Tests accumulate leaf-area integrals in FP64 for each population, mass and
+momentum. The declared absolute tolerance is `2e-13 * sum(abs(old population
+integrals))` for FP64, `2e-7 * scale` for FP32, accounting for reduction and
+restriction rounding (not a solver accuracy bound). Coarse→fine→coarse copy
+round-trips preserve state; coarsening arbitrary fine structure loses it and
+is not invertible. No kinetic accuracy or stability claim follows.
+
+```sh
+PYTHONPATH=src python -m unittest discover -s tests/unit -p 'test_synchronized_remap.py' -v
+```
+
+## Explicit runtime continuation
+
+`replacement = current.remap_finest(rectangles)` returns a new ready
+`FixedPatchStepper` at the **same absolute step_count**. It supports only
+periodic three-level runs with no L0/L1 bodies and an existing L2
+`FixedPatchSet2D`; stationary L2 bodies/Jets follow the support contract below.
+Scalar or union L1 parents are supported; scalar `child=` is deliberately
+rejected. L0/L1, relaxation and block sizes stay fixed.
+No tagger, scheduler, in-place replacement, or general rollback is provided.
+
+The method holds the stepper lock, validates geometry, synchronizes its stream,
+and downloads the actual current owned leaves. It certifies postcollision G
+and completed 1:2:4 counts internally, applies the CPU helper, rebuilds all
+geometry/transfer/kind/halo buffers, and uploads both current and spare buffers.
+No old halo is reused. The regular step schedule fills transit ghosts/halos
+before use. `initialize` itself still resets the count to zero.
+
+The old stepper remains ready, unchanged and independently usable. The caller
+owns **both** objects and must close both before closing their shared CUDA
+context. Candidate construction or upload failure releases only candidate
+resources; an actual old-device synchronization/read failure marks the old
+stepper failed, consistent with its existing failure semantics.
+
+```python
+replacement = current.remap_finest([(20, 16, 36, 40)])
+# Explicitly choose the returned continuation only after success.
+current.close()
+current = replacement
+current.step()  # advances the preserved absolute count by one
+```
+
+CPU lifecycle mocks cover fresh current-buffer reads, exact transfer, separate
+ownership, time preservation, ordinary initialization reset, unsupported states
+and geometry, and candidate/source failure cleanup. GPU tests are predeclared
+in `tests/validation/multigrid/test_runtime_child_remap_gpu.py`: identity next
+step bitwise, shifted A→B→A with two intervals between changes, uniform moving
+and nonequilibrium states, exact CPU remap and overlap, both buffers reset,
+finite leaves, exact masks and absolute counts. They were not run on the CPU
+host. The separate independent FP64 capture/replay gate is max population
+error **3e-6**, with exact masks; remap mass/momentum allow FP32 roundoff.
+Per-population conservation is not an advancement target under collision.
+
+### Bounded pinned-body extension
+
+`replacement = current.remap_finest(rectangles, objects=original_objects)`
+also accepts stationary Circles inside the L2 union. Each body's **physical
+boundary, complete BFL support and current per-link velocity must remain
+identical**. Rectangles are not pinned: they may be split, merged or resized,
+and other fluid coverage may change, including within the same connected union,
+provided that physical support is unchanged. Existing nesting, union transfer
+dependencies, full-circle containment, reverse cut-link
+coverage and two-hop BFL transfer-footprint checks still apply. This is manual
+remapping, not adaptive body tracking or runtime body editing.
+
+Supply all original root edge-frame definitions in their construction order.
+Do not pass `current.boundaries[2].objects`: those are projected fine-local copies.
+There is no retained mutable original-object registry. Before reading device
+state, remapping reprojects the supplied definition onto the old topology and
+compares exact ordered circle centers/radii, flags, physical cut links, body
+IDs, q, lever arms, hits, BFL support,
+legacy SurfaceActuation specification and current per-link velocity against
+the existing boundary. Omission, changed geometry/actuation or changed physical
+boundary/BFL support fail without device reads or allocations; reordered bodies fail
+too. Root object IDs are still assigned by list position, as in the constructor.
+
+Jets are taken from the live L2 boundary, including the most recent successful
+`set_jet_amplitude(..., level=2)`. There is no replacement-Jets argument or
+constructor-time Jet snapshot. New blocked addresses may differ; the physical
+boundary and velocities must match exactly.
+
+`RemapTopology.from_config(..., child_objects=..., child_jets=...)` prepares a
+typed `FineBoundary2D`; it derives L2 fluid leaves as ACTIVE minus SOLID. No
+caller mask is accepted. Solids, ghosts and holes are never donors and remain
+NaN, physical-fluid overlap is exact, and exposed L1 still restricts all four
+old fluid children. The helper checks old/new physical boundary and velocity
+equality too. Its immutable `pinned_rectangles` is legacy containment metadata,
+not a remap eligibility constraint; it may be empty for a seam-spanning body.
+Scalar-parent window offsets remain part of the coordinate conversion.
+
+Focused CPU mocks: `tests/unit/test_pinned_body_remap.py`.
+`tests/unit/test_union_body_support.py` also checks seam-spanning circles,
+rectangle repartition/resize, unchanged physical support and live-Jet
+preservation. These host checks do not establish GPU evolution accuracy.
+GPU declarations:
+`tests/validation/multigrid/test_pinned_body_remap_gpu.py`, covering no-op
+next-step bitwise identity, moved-fluid A→B→A, current-amplitude preservation,
+physical boundary/velocity equality, source independence and absolute counts.
+Multiple-body CPU coverage: `tests/unit/test_multiple_pinned_remap.py`.
+`tests/validation/multigrid/test_multiple_pinned_remap_gpu.py` adds two pins,
+two independently updated Jets, variable fluid-region counts and add/move/remove
+immediate comparisons with CPU transfer. All nine solid-excluded area-weighted
+population integrals, exact overlap and nonleaf NaNs are checked.
+These new GPU cases have **not been run here**. They do not establish evolution
+accuracy. A 3e-6 FP32-vs-FP64 evolution gate requires a separate independent
+BFL reference; the body-free replay gate above does not establish that claim.

docs/validation/2d_scope.md

@@ -0,0 +1,53 @@
+# Bounded 2D implementation and validation scope
+
+This inventory starts from dev `8403956a9afc0b0bb89265cec374392013d89016` and
+integrates only the reviewed LES normalization production correction from
+`95cb6d2b9f43c1bdd46cbf27f03f0dfc0877cfb0`. The merged production bytes match that
+tested candidate exactly; the scope-test changes are retained from `53fad767`.
+GPU receipts remain associated with their exact tested commits, not relabeled as
+a new merged-commit run. Historical source identities and gates remain unchanged.
+
+## Implementation boundaries
+
+- Uniform D2Q9 supports SRT, TRT and MRT. An available collision selector does not
+  qualify every wall, inlet/outlet, forcing, storage or LES combination.
+- Fixed refinement supports SRT/MRT, FP32 and double-buffer streaming; TRT and LES
+  are rejected. Shifted refinement requires all-blocked storage. Refined channel
+  boundaries have narrower configuration guards than uniform boundaries.
+- Uniform checkpoints support compatible same-method continuation. Changing
+  collision or LES parameters is a different evolution, not exact continuation.
+  Jet checkpoints and refined checkpoints are unsupported; synchronized remapping
+  is not persistent restart.
+- Keep these conclusions 2D. Local D3Q19 operator tests do not establish a supported
+  3D Simulation runtime.
+
+## Evidence and remaining gaps
+
+| Area | Available evidence | Boundary of the conclusion |
+|---|---|---|
+| MRT cylinder flow and observation windows | Full matched uniform/refined MRT DFG and the window-ledger campaign passed their frozen periodicity, reference and matched-comparison gates. The window campaign used `185a919`; its MRT/no-LES numerical path remains unchanged. Current dev also contains independently scoped test/documentation changes and the LES correction, which do not extend MRT qualification. | This does not qualify other collision/boundary combinations or every refinement interface. Timing improvements are not additional accuracy evidence. |
+| Uniform forced channel | Six Poiseuille GPU cases on `8403956`: SRT/TRT/MRT at wall-normal resolutions H16/H32 passed. | This is the tested analytic channel configuration, not open-boundary or all-layout qualification. |
+| Uniform restart | Ten SRT/MRT checkpoint GPU tests passed on `8403956`; the separate representative TRT same-method double-buffer continuation GPU case also passed (one test). | This covers the tested same-method continuation configurations. No LES, Jet or refined checkpoint claim follows. |
+| Taylor–Green refinement | Independent topology checks are available. The actual-rate phase GPU regression passed one test across two layouts, with errors 1.584e-7 and 4.500e-9. | The physical interface-accuracy gap remains open. Passing topology and phase checks does not establish convergence or close that accuracy gate. |
+| Porous Couette and annulus | Prior campaign evidence exists and must remain associated with its original setup and source. | The reconstructed annulus is a validation helper, not qualification of a public boundary-condition API. Do not infer absence of evidence from a missing current rerun. |
+| LES normalization | The reviewed correction is integrated. Exact `95cb6d2` GPU validation passed all nine observations and frozen gates, with three warm-up/reset records, verified 101-source/import identity, DONE and exit 0. Last two SGS decrement relative errors were 6.276e-4 and 6.124e-5 against the unchanged 0.15 gate. | Scope is unforced uniform D2Q9/SRT, shifted FP32, double-buffer streaming and the tested wall-bounded x-periodic shear. No TRT/MRT LES, forcing, EsoPull, objects, refinement or 3D turbulence qualification follows. |
+
+Historical uniform SRT cylinder-startup and inlet-rounding findings remain separate
+from the passed MRT DFG result. Raw exchange/window consistency is a measurement
+contract, not a general stress or force-accuracy certification. Existing source-pinned
+runners may intentionally reject a newer checkout; never silently repin old receipts.
+
+## Remaining work
+
+The related host checks passed (67 checks); they do not replace the GPU or
+physical-accuracy evidence above. Preserve the existing SRT checkpoint cases,
+historical LES manifests and all frozen numerical criteria.
+
+Continue the TG accuracy investigation using its actual fine-level rates and
+the established analytic convention. Keep the physical accuracy gate open until
+the relevant comparison passes. Review this integration independently before
+publication; no new merged-commit GPU run is claimed here.
+
+No repeat of the accepted full MRT DFG or Cartesian expansion across unsupported
+combinations is required by this document. Main integration remains a separate
+review of complete, bounded feature scope.

docs/validation/dfg_re100.md

@@ -0,0 +1,60 @@
+# DFG 2D-2 Re100 GPU campaign (validation-only)
+
+## Current experimental source provenance
+
+This development branch now includes the reviewed AMR-channel source changes originating in `5338864748ac67fe2544487c059ba149ebf916da` and `47b05bc8abfc957fe876b0c63bdb386e3c6cbaa5`. The current full-source manifest pins the latter reviewed source snapshot, including the new channel files. This is an explicit new experiment; neither source review nor host tests transfer historical d79 GPU/flow acceptance to it. The channel GPU gate has not yet run at integration time.
+
+New run JSON records the source-origin pin plus `checkout_revision` (actual Git HEAD), `checkout_dirty`, and the experimental-source label. The origin pin is not claimed to be the run's checkout commit. Numerical definitions and thresholds are unchanged. Runs require a Git checkout for this runtime identity; source hash checks remain active.
+
+Historical d79 Re100/Jet execution stays reproducible at `69e9b78de9483a5ff21e2d0c74311d240bfaf88c`; the d79 LES diagnostic checkpoint is `20ae6770924df15f31305aad56e44a54a3dd4d88`. Their manifests and existing result files are not rewritten. Use those commits to reproduce or interpret old d79 evidence. The current AMR-channel experiment requires its own GPU and applicable flow evidence.
+
+## Scope and locked definitions
+
+Explicitly pinned AMR-channel experimental production snapshot (see provenance below). Uniform D2Q9/MRT, shifted FP32, double buffer, no LES, stationary cylinder and no-slip walls. This is not an AMR, jet, or full canonical-outlet certification.
+
+Physical geometry: [0,2.2] × [0,0.41], center (0.2,0.2), radius .05, rho=1, nu=.001, inlet mean=1 and peak=1.5. D is lattice diameter; dx=.1/D, dt=U_lattice*dx, nu_lattice=U_lattice*D/100. U_lattice=.01 gives peak inlet Mach .02598. Existing local Zou–He inlet is selected in validation config only. Existing pressure-NEQ outlet is unclamped: **it does not impose the canonical vector do-nothing condition nu*d_n(u)-p*n=0**. The existing production channel-flow initial condition is used, not zero velocity. Periodic eligibility is delayed to t*=250 (25 physical seconds), with fixed end t*=300 (30 seconds).
+
+Official source: https://wwwold.mathematik.tu-dortmund.de/~featflow/en/benchmarks/cfdbenchmarking/flow/dfg_benchmark2_re100.html
+
+The 20141124 official newer reference archive has higher-order line-integration force data and supersedes the older example table for this comparison. The compact tests/validation/data/dfg_re100/reference_cycle.json preserves the last complete lift-minimum cycle from lv6/dt4. Reference Cd=[3.164266,3.227392], Cl=[-1.021286,.986571], pressure difference=[2.420371,2.507013], St=.301841. These are derived sampled extrema, not exact analytical values. Official mean=(min+max)/2 and amplitude=max-min; separate time averages are also recorded.
+
+## Exact commands and startup ownership
+
+Use the existing CUDA/PyCUDA environment; no package installation or production edits required. From the repository root, use a new task-owned output path:
+
+    export PYTHONPATH="$PWD/src${PYTHONPATH:+:$PYTHONPATH}"
+    python -m pytest -q tests/unit/test_re100.py
+    CUDA_VISIBLE_DEVICES=0 python tests/validation/run_dfg_re100.py --diameter 20 --speed .01 --mode pilot --output output/validation/pilot_d20_u001 > pilot.log 2>&1
+
+Pilot is t*=5 (10,000 steps), with dense .02-t* sampling to calibrate diagnostic cost. It cannot pass periodicity or external benchmark validation. Root launch owner reviews health, memory, timing and stdout before full runs; the full pair is not launched automatically.
+
+    CUDA_VISIBLE_DEVICES=0 python tests/validation/run_dfg_re100.py --diameter 40 --speed .01 --mode full --output output/validation/full_d40_u001 > d40.log 2>&1
+    CUDA_VISIBLE_DEVICES=1 python tests/validation/run_dfg_re100.py --diameter 80 --speed .01 --mode full --output output/validation/full_d80_u001 > d80.log 2>&1
+
+These are separate invocations, not a parallel shell script. A single root launch owner serializes startup/compilation across all Horsea work. Do not launch the next process until the previous log contains an explicit `READY {...}` line. READY comes after the first physical sample, including Simulation initialize, sim.run, read_force and get_macroscopic, so lazy runtime/diagnostic paths are exercised. That sample remains in the physical trajectory/history. No hidden warmup/reset, no later new diagnostic kernel. Do not treat a process merely existing as READY. Keep separate output directories and retain exit codes/logs. GPU assignment is chosen by root after checking existing workloads; shown indices are examples of physical device selection.
+
+## Measurement, frozen criteria and outcomes
+
+Force uses advancing link-momentum exchange, accumulated in batches <=100 steps, combined in FP64; Cd/Cl=2F/(U_lattice² D). Force timestamp is the batch midpoint. Pressure uses fluid-only h/2h extrapolation to cylinder front/back points and physical conversion 1/(3 U_lattice²), at each sample endpoint. For phase comparisons endpoint pressure is interpolated to the same cycle phase. Both raw times are saved.
+
+Before t*=240 sample width=.5; afterwards .02 (about 166 samples per lift cycle). Pilot uses dense sampling throughout. Extract complete lift-minimum-to-minimum cycles using quadratic local minimum locations, accepting periods 2–5 t*. Latest five complete cycles must be consecutive with the last ending no more than 5 t* before the final observation, and must start at or after t*=250. Eligibility requires lift amplitude >=.2, period range/mean <=.005, Cd/Cl/pressure min and max ranges <=.005 absolute, cycle-mean mass range/mean <=1e-4, and each cycle's mean mass-flux imbalance <=.005. Instantaneous flux equality is not required in this unsteady compressible LBM diagnostic.
+
+Reference gates: Cd extrema relative errors <=2%, Cl extrema absolute errors <=.03, pressure extrema relative errors <=2%, St relative error <=2%. These are predeclared engineering tolerances, not official uncertainty intervals. Phase-aligned waveform RMS errors, extrema, midpoint means, time means, amplitudes, outlet residual, sampled density bounds and Mach are all reported. Waveform RMS is diagnostic (no retroactive gate). No threshold changes after GPU results. At cap, failed periodicity stays incomplete. Invalid/nonfinite state, rho outside [.5,1.5], or sampled max Mach>.2 causes a safety stop; this is a gross-health guard, not a Mach-independence claim.
+
+A case_reference_pass requires both periodicity and reference gates. Every raw case keeps suite_validated=false. The two-grid comparison must report each case and errors; matched-Mach D40/D80 is evidence of resolution sensitivity only, not an asymptotic convergence order. If either fails or finer errors increase materially, report the failure instead of adjusting thresholds. No full canonical/AMR/Mach-independent validation claim is allowed.
+
+## Resource and calibration plan
+
+D20: 441×84=37,044 nodes, pilot 10,000 steps. D40: 881×166=146,246 nodes, 1,200,000 full steps. D80: 1761×330=581,130 nodes, 2,400,000 full steps. Main double-buffer DDF arrays alone cost 72 bytes/node: 2.7/10.5/41.8 MB decimal. Flags, masks, macro host arrays, body buffers and CUDA context/JIT memory add overhead; root verifies actual free GPU/host memory and disk before launch. Conservative per-process reservation: 1 GiB VRAM and 2 GiB host RAM, excluding shared/compiler overhead; measurements take precedence.
+
+Historical Re20 D80 U=.01 step throughput was ~6082 MLUPS (45.9 seconds/480k steps). At equal throughput D80 Re100 full advancing steps would take ~229 seconds, excluding dense full-field downloads/reduction and compile overhead. D40 estimate must be calibrated, not assumed proportional. Pilot records startup_seconds, step_seconds, measurement_seconds, mlups. For each full grid, calibrate a same-grid pilot if D20 cannot predict cost adequately. Full has about 3480 records (480 coarse+3000 dense); use measured seconds/step × full steps plus seconds/record ×3480 plus startup. D20-to-D80 extrapolation is only a rough planning upper/lower guide, not an ETA commitment.
+
+Only geometry.npz, one final_field.npz, history.csv, summary.json and stdout/stderr are persisted. No per-step or repeated full-field snapshots. D80 final float64 rho/ux/uy plus mask are <15 MB uncompressed; history/summary several MB, compact versioned reference/source guards <50 KiB. Budget <100 MB per case and <500 MB whole campaign including logs and optional externally retained archives, safely below 2 GiB; root still checks baseline Horsea usage. Retain sparse evidence only.
+
+## CPU validation and remaining execution
+
+Ten tests cover geometry/units/config, pressure scaling, periodic and nonperiodic synthetic histories, immutable production hashes, and self-reference comparison. CUDA execution is not available in the preparation environment and has not been claimed. Run pilot first on Horsea; do not confuse successful CPU tests with GPU readiness.
+
+## Reference provenance and reproduction
+
+Only the compact derived cycle is versioned. Its source URL, official ZIP SHA-256, column selection, and cycle-selection description are embedded in reference_cycle.json. Raw archives and GPU results are not repository inputs. To reproduce it, obtain the exact archive identified there, verify its SHA-256, and extract logs/results_cc2d_bench2_referencenew/bdforces_q2_lv6_dt4 and pointvalues_q2_lv6_dt4. Use physical time column 2 multiplied by 10, drag/lift columns 4/5, and pressure columns 7 minus 12 (one-based columns). Build rows with mass=flux_in=flux_out=1, then call periodic.extract(rows, min_time=0) and select the last complete cycle. The source guard is tests/validation/data/dfg_re100/source_manifest.json; it verifies the current reviewed production snapshot rather than equating its origin with the validation branch HEAD.

docs/validation/dfg_re20.md

@@ -0,0 +1,49 @@
+# 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/duetsch_re100_kc5_protocol.md

@@ -0,0 +1,242 @@
+# Prescribed in-line oscillation: Dütsch Re 100 / KC 5 — PROTOCOL (review draft)
+
+Production under test: `claude/moving-bodies-s3a` at `653fd997` (unchanged).
+Primary source: Dütsch, Durst, Becker & Lienhart, J. Fluid Mech. 360, 249–271
+(1998), doi:10.1017/S002211209800860X. Source facts below were verified from
+the paper (Slack C0C78UFKGRM/1793335557.460509, TRON 1793356317–1793356724,
+page numbers given). Everything marked ENGINEERING is our a-priori choice,
+fixed before any benchmark result; it is not a paper uncertainty.
+
+## 0. Source facts (with provenance)
+
+- Motion (p.251): `x_c = -A sin(2 pi f t)`; paper phase phi = 0 is the mean
+  position moving left at `-U_max`. KC = 5 gives `A/D = 5/(2 pi) = .7957747`.
+- Start (p.254): the computation starts a quarter cycle before phi = 0, at
+  `x = +A` with zero velocity (phi = -90°).
+- Experiment (pp.252, 254–256): D = 10 mm, L = .65 m, tank 1.2 × .7 × .7 m,
+  rho = 998.2 kg/m³, mu = 1.00818 mPa·s, Re = 100, KC = 5; LDA with 1° phase
+  bins and 200 samples per node and degree; no quantified experimental error
+  recovered.
+- Profiles (Fig. 8, p.260): LAB-FIXED stations x1 = -6, 0, 6, 12 mm, i.e.
+  x/D = -.6, 0, .6, 1.2, at phi = 180°, 210°, 330°; u1 and u2 versus x2.
+- Original numerics (§2): cylinder-fixed accelerated frame (`x_i = x~_i +
+  x_i,s`, outer velocity `-u_c`, inertial source `-rho du_c/dt`), O-grid outer
+  diameter 120 D, illustrated 192 circumferential nodes, 720 steps/cycle; tank
+  influence neglected.
+- Force fit (verified): force ON THE BODY per unit span
+  `F1 = -0.5 rho D c_d xdot|xdot| - (pi/4) rho D² c_i xddot` with `x = -A sin phi`;
+  normalized by `0.5 rho D U_max²`: `c_d cos phi |cos phi| - (pi² c_i / KC) sin phi`.
+  `c_i` is the ADDED-MASS coefficient; total inertia `c_m = c_i + 1` is a
+  different convention and is not used.
+- Table 1 computed Morison coefficients (c_d, c_i) for 96 / 192 / 384 perimeter
+  nodes at dt/T = 1/720: (2.15, 1.42), (2.10, 1.45), (2.09, 1.45). These are
+  fitted computed coefficients, not a measured force and not an error bar. The
+  paper states the coarse direct force is closer to the finest direct force
+  than the Morison fit, but gives no waveform-error norm.
+
+## 1. Kinematics, time levels and phase bookkeeping
+
+- Our run is in the LAB frame: the circle moves, the fluid is initially at rest
+  (rho = 1, u = 0); no fictitious inertial source is added. Lab-fixed profile
+  stations are compared directly (no frame transform needed).
+- Geometry reference: the circle's base centre is the INITIAL position, the
+  right turning point `x_mean + A`; the declared offset box is x in [-2A, 0],
+  y = 0. The body is never teleported: offset 0 at s = 0.
+- Elapsed time s = n dt from the start. Analytic position relative to the mean
+  `x(s) = A cos(2 pi s / T)`, velocity `u(s) = -U_max sin(2 pi s / T)`; paper
+  phase `phi = (360 s / T - 90) mod 360`.
+- Step n moves from s_n to s_{n+1}: target offset `x(s_{n+1}) - A`; wall
+  velocity = the single-step interval average `(x(s_{n+1}) - x(s_n)) / dt`
+  (analytic, supplied, not differenced from stored offsets). The per-step
+  force of `run(1)` / `read_force(normalize=True)` is attributed to that same
+  interval.
+- Paper cycle k = 1, 2, ... spans `s in [T/4 + (k-1) T, T/4 + k T)`; the
+  initial quarter cycle (s < T/4) is cycle 0 and never scored. Every logged
+  sample carries (k, phi). Example: phi = 330° of cycle 1 is at s = 7T/6.
+- T is chosen as a multiple of 360 native steps, so phi = 180°, 210°, 330° fall
+  exactly on step boundaries and 1° bins hold whole steps.
+
+## 2. Resolution ladder (uniform grid, fixed Mach), ENGINEERING
+
+| D (cells) | T (steps) | U_max = 5 D / T | nu_lat = U_max D / 100 | tau (3 nu + .5) |
+|---|---|---|---|---|
+| 20 | 2,520 | .039683 | .0079365 | .5238 |
+| 40 | 5,040 | .039683 | .015873 | .5476 |
+| 80 | 10,080 | .039683 | .031746 | .5952 |
+
+- MRT collision. Mach fixed (Ma ≈ .0687); a separate Mach check at D = 40
+  with T = 10,080 (U_max halved, tau .5238) is labelled MACH and not part of the
+  ladder.
+- Per-step displacement ≤ U_max ≈ .04 cells (bound .5).
+
+## 3. Domain and boundaries (finite-domain reproduction), ENGINEERING
+
+The paper's 120 D O-grid is not reproduced; our rectangular box is a
+reproduction choice. The native dense channel (zero-velocity inlet,
+pressure-NEQ outlet, bounce-back y walls) is a finite-domain approximation,
+not infinite still fluid. The G4 x-periodic / y-slip override is a separately
+labelled sensitivity family and never mixed into the primary ladder. The
+runner owner confirms the zero-velocity inlet is supported as configured
+before any run.
+
+Order (closed):
+1. Smoke + ledger at D = 40, native BC, 40 D × 40 D (finite box).
+2. Domain sensitivity before any literature statement: same BC, D = 40,
+   L ∈ {20 D, 40 D, 60 D}; record the change in Fx waveform, c_d, c_i and the
+   scored profiles.
+3. Optional labelled BC sensitivity: one x-periodic / y-slip case at D = 40,
+   40 D; reported as a delta against native only.
+4. Only after step 2 passes: the D = 20 / 40 / 80 ladder on the chosen BC and
+   domain.
+
+Domain criteria (a-priori, ENGINEERING; separate from the Table 1 bands): the
+reference is 60 D at D = 40; 20 D and 40 D are compared with it on the common
+window (same cycle indices) and the common valid point set:
+- `RMS(Fx_L - Fx_60D) / F_ref ≤ .01` over the window (per-step waveforms);
+- `|c_d,L - c_d,60D| ≤ .02` and `|c_i,L - c_i,60D| ≤ .02` (window fits);
+- `max(|u_L - u_60D|, |v_L - v_60D|)` over common points `/ U_max ≤ .02`.
+The chosen domain is the smallest of {20 D, 40 D} passing all three; if
+neither passes, the domain verdict is FAIL and the ladder is not run.
+- Memory/runtime: measured by a smoke run before each new size; measurements
+  inform scheduling only, never tolerances.
+
+## 4. Observables (raw, per step, preserved)
+
+- `obs` Fx, Fy (CME) and all `MovingTables.DIAG` columns per step: CME,
+  CME + Wen and CME + cover − uncover reported separately; crossings, eq_only,
+  no_donor (no_donor must stay 0).
+- Velocity u1, u2 on lab-fixed lines x/D = -.6, 0, .6, 1.2 (relative to the
+  mean cylinder position) versus x2, at the scored phases. Lab frame
+  throughout; if any body-frame intermediate is used, position and velocity
+  are both transformed.
+- Sampling cost: raw force and diagnostics counters are read every step
+  (small). Flags and velocity fields are read only at the steps inside the
+  three prescribed 1° phase bins (φ ∈ [180, 181), [210, 211), [330, 331),
+  T/360 steps each) of the cycles needed for settling and scoring, plus
+  sparse declared audits; never every step.
+- Point set: fixed x2/D sample points per station, identical on every grid
+  and declared before running; per point the interpolation weights are
+  recorded; the scored set is the common subset valid on all compared grids
+  at that phase, with its coverage recorded; point sets never change silently.
+- Interpolation: bilinear on cell centres using only cells that are fluid at
+  that step (flags read back via `get_flags()`); weights renormalized over the
+  fluid corners; a sample with no fluid corner, or inside the circle at that
+  step, is MISSING and logged, never set to zero. One-degree bins keep valid
+  fluid weights. The numerical average need not mimic the 200 LDA samples.
+
+## 5. Periodic-regime gate (every case, before any statistic), ENGINEERING
+
+Ledger rows, same schema for every case: dx, dt (in D and T units); U_max, nu,
+Re, KC (lattice and nondimensional); T (native steps, nondimensional);
+duration (native steps, s/T, paper cycles); discard; accepted window; cycle
+ledger; verdict PASS or FAIL-CLOSED.
+
+Scales: `F_ref = 0.5 rho U_max² D`, `U_ref = U_max`; never a near-zero mean
+force as denominator.
+
+- Settling metrics, cycle k−1 → k, phase-aligned by step within the cycle
+  (error budget: one fifth of the tightest comparison band of the same
+  observable, so residual drift cannot obscure a domain or resolution pass):
+  - waveform `RMS(dFx) / F_ref ≤ .002`;
+  - `|d mean|`, `|d RMS|`, `|d peak|` of Fx, each `/ F_ref ≤ .002`;
+  - scored profiles (fluid-only) `|du| / U_max`, `|dv| / U_max ≤ .004` at the
+    three phases × four stations;
+  - Morison `|dc_d| ≤ .004`, `|dc_i| ≤ .004`.
+- Conservative comparison: every domain and cross-resolution criterion is
+  applied to `|difference| + drift_a + drift_b`, where drift is the largest
+  pair metric of that case inside the scored window.
+- These constants (protocol.py SETTLE, DOMAIN, CROSS) are frozen before any
+  physical result; no post-result loosening.
+- Rule: all metrics for N = 3 consecutive whole paper cycles → settled.
+
+Cycle indexing (worked example, binding). Paper cycle k spans
+`s/T in [0.25 + (k-1), 0.25 + k)`, i.e. φ0 → φ0; cycle 0 is the startup
+quarter `s/T < 0.25`. Pair p_k compares cycle k−1 with cycle k.
+
+- Discarded: cycles 0, 1, 2 (s/T < 2.25). Pairs are formed only between
+  cycles ≥ 3, so the first pair is p_4 (3 → 4).
+- Settling proof for a case: three consecutive pairs all pass; K_case = the
+  first cycle AFTER the last of those pairs. Earliest possible: pairs 3→4,
+  4→5, 5→6 pass ⇒ K_case = 7.
+- Common window: K = max over compared cases of K_case; every case scores the
+  same three complete cycles K, K+1, K+2 and must stay settled continuously:
+  every pair p_j for j = its own K_case .. K+2 must pass (including the wait
+  between its local settle and the common K), otherwise that case is
+  FAIL-CLOSED.
+- Cap: cycle k ends at s/T = k + 0.25, so the last admissible scored cycle is
+  11 (ends 11.25 T) and K ≤ 9. Examples: K = 7 → cycles 7–9 (ends 9.25 T);
+  K = 9 → cycles 9–11 (ends 11.25 T); any K_case > 9 → FAIL-CLOSED.
+- Run length: cases run sequentially; each runs to the end of cycle 11
+  (11.25 T: 28,350 / 56,700 / 113,400 steps for D = 20 / 40 / 80; the 12 T
+  cap is 30,240 / 60,480 / 120,960) and keeps its scalar and profile data, then
+  the common K is chosen. An unscorable partial cycle 12 is not run.
+- Profiles: an empty common valid point set is FAIL-CLOSED; coverage, missing
+  points, bin time weights (equal per step) and the original fluid corner
+  weight sums are reported.
+- The earlier G4 timing check (100 coarse vs 400 diffusive-fine steps) was a
+  matched short transient, not periodic evidence.
+
+## 6. Metrics and per-observable criteria (ENGINEERING, not paper uncertainty)
+
+Three criteria stay separate; the G4 same-grid 2% target is not reused.
+
+- Morison fit: least squares of the normalized per-step force over the
+  accepted window against the two basis functions, each averaged over its
+  single step interval, fixed paper phase, no free phase shift; c_d and
+  added-mass c_i per force candidate.
+- Cross-resolution: every scored observable's error against its reference must
+  decrease monotonically D20 → D40 → D80 (necessary, not sufficient).
+- Against Table 1 (computed fit, not measured force): at D ≥ 40,
+  `|c_d - 2.09| ≤ .15` and `|c_i - 1.45| ≤ .15`, and monotone.
+- Force waveform against its own Morison reconstruction: residual reported
+  only, no pass/fail (the paper reports fit error above its coarse numerical
+  error and gives no percentage).
+- Fig. 8 LDA profiles: QUALITATIVE ONLY. The original figure could not be
+  accessed or rendered; no digitized ordinates and no measurement uncertainty
+  exist. After a digitization with figure number, tool and uncertainty note:
+  `RMS(|du|, |dv|) / U_max ≤ .15` at D ≥ 40 and monotone; LDA error stays
+  UNQUANTIFIED and is stated with every comparison.
+- Fy sanity (not literature): `|mean Fy| / F_ref ≤ .05` in the accepted window.
+- No force candidate is selected for an RHS by these results; each is
+  reported.
+
+Superseded (earlier drafts): the velocity-jump start, guessed stations and
+phases, "C_M" for c_i, and the uncertainty wording; cycles 4–6, the 30-cycle
+cap and the earlier tolerance numbers.
+
+## 6b. Amendment: duration-only diagnostic (declared before the run)
+
+- Background: the D40 domain stage (20 D / 40 D / 60 D, 11.25 T each) failed
+  settling in every box (no window). That result stands.
+- One declared diagnostic: D = 40, 60 D box, from rest, through cycle 31
+  (157,500 steps = 31.25 T). Physics, settling tolerances, bands and
+  production unchanged; three proof pairs plus a continuously settled
+  K..K+2 with K ≤ 29.
+- Invocation: `run.py --D 40 --box 60 --cycles 31` then
+  `analyze.py --horizon 31`; the JSON records `horizon` and `horizon_mode`.
+  Without `--horizon` the analyzer is the original cap-11 scoring.
+- Failure at 31.25 T: report and stop; no automatic extension, matrix, D80
+  or VIV. A pass shows only that this box settles with time; it is not a
+  domain or literature pass.
+- The phase-locked high-frequency force component (residual of the mean
+  waveform after its Morison reconstruction, above 20/T) is reported per case
+  as unqualified; it needs separate qualification before any Morison or
+  literature statement.
+
+## 6a. Driver unit tests (CPU, before any run)
+
+- Phase/cycle arithmetic: s ↔ (k, φ), cycle boundaries, bin membership,
+  window/cap selection for K = 7, 8, 9, 10.
+- Solid-aware interpolation: all-fluid, partial-solid (renormalized weights),
+  no-fluid (MISSING) and inside-circle cases.
+- Interval-averaged Morison bases and the two-parameter fit on a synthetic
+  waveform with known c_d, c_i.
+
+## 7. Order and scope
+
+Protocol review → one-shot Dütsch driver (analytic `set_body` + `run(1)`,
+cycle ledger, lab-fixed fluid-only station sampler, two-basis Morison fit; no
+reusable runner until the first smoke shows shared helpers pay off; no
+production change) → smoke (memory/runtime) → domain sensitivity →
+ladder → physical-validation verdict → only then single-cylinder VIV. No AMR,
+no pinball, no manuscript work.

docs/validation/jet_circle_cv.md

@@ -0,0 +1,115 @@
+# Jet-circle closed-control-volume pilot
+
+## Current experimental source provenance
+
+This development branch now includes the reviewed AMR-channel source changes originating in `5338864748ac67fe2544487c059ba149ebf916da` and `47b05bc8abfc957fe876b0c63bdb386e3c6cbaa5`. The current full-source manifest pins the latter reviewed source snapshot, including the new channel files. This is an explicit new experiment; neither source review nor host tests transfer historical d79 GPU/flow acceptance to it. The channel GPU gate has not yet run at integration time.
+
+New run JSON records the source-origin pin plus `checkout_revision` (actual Git HEAD), `checkout_dirty`, and the experimental-source label. The origin pin is not claimed to be the run's checkout commit. Numerical definitions and thresholds are unchanged. Runs require a Git checkout for this runtime identity; source hash checks remain active.
+
+Historical d79 Re100/Jet execution stays reproducible at `69e9b78de9483a5ff21e2d0c74311d240bfaf88c`; the d79 LES diagnostic checkpoint is `20ae6770924df15f31305aad56e44a54a3dd4d88`. Their manifests and existing result files are not rewritten. Use those commits to reproduce or interpret old d79 evidence. The current AMR-channel experiment requires its own GPU and applicable flow evidence.
+
+Status: CPU preparation only. No GPU run or production change. Current source origin: reviewed AMR-channel snapshot 47b05bc8abfc957fe876b0c63bdb386e3c6cbaa5; this new experiment has no inherited d79 GPU acceptance. tests/validation/data/jet_circle_cv/source_manifest.json checks all tracked source file hashes before importing GPU code.
+
+## Execute only after root-owned GPU serialization
+
+From the repository root, with REPO set to the repository root and an absent output directory:
+
+```sh
+PYTHONPATH=src python -m pytest -q tests/unit/test_jet_circle_cv.py
+python tests/validation/run_jet_circle_cv.py --repo "$REPO" --output "$OUTPUT" --plan
+CUDA_VISIBLE_DEVICES="$VERIFIED_IDLE_GPU" python tests/validation/run_jet_circle_cv.py --repo "$REPO" --output "$OUTPUT"
+```
+
+The runner does not select, reserve, or contact a GPU machine. It requires one explicit CUDA_VISIBLE_DEVICES value, at least 1 GiB free, and refuses an existing output directory. It imports existing PyCUDA; no installation. Default pilot: 800 base steps, 8 output windows, at most 1800 seconds after READY. READY is printed only after both steppers compile, execute one base/two fine warmup hops, exercise download/raw paths, and reset initial state/time. A pre-READY silence may be compilation, not stepping progress. Root owns any overall startup timeout and all launch serialization.
+
+## Physical/numerical case
+
+Periodic root box 192 by 128, center (96,64) in root cell-edge coordinates, D=24.084, U0=.03, nu=.0072252, Re_D=100, beta=Vj/U0=.1, rho0=1. Unforced D2Q9 SRT FP32, no DDF shifting, no LES. The slightly noninteger diameter was selected solely to avoid q clipping at all three planned scales. Circle is stationary. Two uniform radial sectors at pi/2 and 3pi/2, half-width pi/12: top blows outward +.003, bottom sucks inward -.003; remaining wall has zero velocity. This periodic transient is NOT DFG, infinite-stream drag, or statistical high-Re validation. End time is t*=t U0/D approximately .9965.
+
+AMR bounds (48,32,144,96). Finest dx=dt=.5 in root lattice units, nu_fine=2 nu, finest D=48.168. Full-domain fine reference is 384 by 256 with exactly the same finest spacing, timestep, viscosity, collision and storage. Root tau=.5216756, fine tau=.5433512, Mach approximately .05196.
+
+AMR uses actual public FixedPatchStepper Jet construction and raw observation. The uniform blocked reference reuses the existing test_raw_exchange_gpu.py optional-input validation adapter: production Jet-derived velocity/force-arm arrays feed the unchanged blocked curved kernel. Its normal public PeriodicBlockStepper API is passive-only. This does not claim there is no uniform Jet route anywhere: Simulation.add_jet exists, but the same-blocked-kernel adapter removes a backend/storage confound for this comparison. No new public backend is introduced. Runtime asserts matching directions, q, fallback and true hit coordinates after frame conversion; both sectors must resolve links. Unclamped q/no fallback is required.
+
+## Independent measurements and signs
+
+Two closed rectangles: (72,44,120,84) and (64,40,128,88), wholly within the finest patch. Every contour face has two active-fluid stencil layers. Capture physical postcollision populations at t=0 and every completed base interval. Collision conserves density/momentum; these are valid endpoint moments, NOT precollision stress estimates.
+
+For each contour, M and P sum fluid-cell rho and rho*u times h^2, excluding the staircase solid. Face midpoint quadrature integrates rho*u dot n and [rho*u*u+p*I-mu*(grad u+grad u.T)] dot n. Velocity gradients use centered differences in root-length units, mu=rho*nu, p=(rho-1)/3. Constant pressure subtraction integrates to zero on a closed rectangle. No raw exchange enters these field quantities.
+
+Trapezoidal time integration samples every base step over the SAME reported [step_start,step_end] as cumulative raw impulses/masses. For each window:
+
+- mass into fluid through body surface = delta M + integral outer mass flux
+- raw boundary reaction target = -delta P - integral outer momentum-minus-traction flux
+
+Raw rows are [Jx,Jy,angular impulse,mass into fluid]; each uniform fine hop scales by [.25,.25,.125,.25], exactly as the AMR interval ledger. Both fine hops are accumulated. AMR observation time endpoints and the public raw reduction are checked. Reports separate total, wall, aperture, blowing and suction raw rows. Coefficients divide force by .5*rho0*U0^2*D. These are momentum reactions including aperture transport; neither raw aperture nor total raw reaction is labelled solid-only hydrodynamic traction.
+
+Independent aperture mass estimates integrate measured rho*u dot e_r over true arcs using 64-point Gauss quadrature and nearest active-fluid samples. No target velocity or raw row enters this estimate. Reports include maximum sampling distance, actual signed raw mass rates and nominal signed volume flux ±2*(pi/12)*R*Vj. Near-wall nearest-node sampling is only a first-order diagnostic, not certified wall extrapolation. Nominal volume flux is not asserted to equal measured mass flow at finite density variation.
+
+Inventory near the circle is a staircase-cell approximation; its geometric error and face/time quadrature errors can appear in CV residuals. Two-contour spread and grid refinement are essential. No exact continuum force value, solid traction recovery, jet hardware load, or physics acceptance is claimed. Output status is deliberately PILOT_DIAGNOSTIC_ONLY even on successful execution.
+
+## Scope, refinement, resources
+
+Default one pilot only. Estimated device envelope 128 MiB, required free 1 GiB; bounded JSON only, conservatively under 2 MiB, no population snapshots or per-step logs. Every base step downloads both fields for independent quadrature, so PCIe/CPU diagnostic cost is intentional. Six CPU tests cover descriptor/source identity, uniform flux cancellation, affine convective divergence, quadratic viscous sign/coefficient, matched geometry/Jet selection and diffusive scaling.
+
+Optional --scale 2 or 4 doubles/quadruples all lengths and divides U,V by that scale, holds lattice nu fixed, and scales steps/windows by scale^2: physical Re and t* match, Mach decreases. Source and geometry guards repeat. Device estimate scales as scale^2; memory gate requires twice the estimate or 1 GiB, whichever is greater. Scale 4 is not part of default authorization/readiness. --re 400 requires --allow-re400 and a separate reviewed root launch decision after Re100 evidence; no automatic promotion.
+
+Compare AMR/reference velocity error, signed reaction coefficients, each contour's independently measured reaction and residual, contour spread, signed mass budgets, and measured aperture flux. Freeze numerical tolerances only after agreeing a scientifically appropriate convergence criterion; this preparation imposes only structural/finite-state guards. A completed pilot cannot establish convergence.
+
+Follow-on design retained: porous Couette crossflow with u=U*expm1(Re_V*y/H)/expm1(Re_V), v=V and unequal exact wall shear. It requires validation-only planar geometry and is intentionally not implemented here.
+
+### Amplitude, geometry, and high-Re limits
+
+Both Jet amplitudes are constant throughout the run and every fine substep; geometry is fixed. There is no runtime switch, per-step forcing schedule, or moving-wall velocity in this campaign. Construction/packing happens once, with identical uploaded amplitudes in the uniform adapter. This avoids any substep timing ambiguity from amplitude changes.
+
+Every case records actual tau_root and tau_fine. For this fixed s=1 geometry and speed, Re400 would give nu=.0018063, tau_root=.5054189 and tau_fine=.5108378, close to the SRT limit .5. The implemented Re choices are a bounded campaign menu, not a universal physical Reynolds-number ceiling. Higher-Re evidence may require a larger initial resolved geometry or a different justified grid/relaxation design before launch. Diffusive refinement at constant lattice nu improves spatial/Mach resolution but does not move tau farther from .5; simply selecting scale=2 does not cure a poor tau. No all-Re, LES or three-dimensional realism claim follows from this pilot.
+
+The source guard checks production file content against the current reviewed source origin, not validation-branch HEAD. This runner is validation-only; generated results and frozen execution-package archives are not committed.
+
+## Measurement-only continuation (frozen design before execution)
+
+The original 800-step pilot and its audit remain historical evidence, not an acceptance target. The following adds diagnostics only; it neither modifies production kernels nor adjusts velocity commands to improve measured flux. Use the canonical validation Git branch, with the same source-manifest check and checkout provenance record. No standalone replacement source archive is needed.
+
+Run the pair serially under root-owned GPU allocation, from the checked-out repository:
+
+```sh
+python tests/unit/test_jet_circle_cv.py -v
+python tests/unit/test_jet_cv_measurements.py -v
+CUDA_VISIBLE_DEVICES="$VERIFIED_IDLE_GPU" python tests/validation/run_jet_circle_cv.py --repo "$PWD" --output "$NEW_OUTPUT_S1" --continuation --steps 3200 --scale 1
+CUDA_VISIBLE_DEVICES="$VERIFIED_IDLE_GPU" python tests/validation/run_jet_circle_cv.py --repo "$PWD" --output "$NEW_OUTPUT_S2" --continuation --steps 3200 --scale 2
+python tests/validation/analyze_jet_cv_continuation.py "$NEW_OUTPUT_S1" "$NEW_OUTPUT_S2" --output "$COMPARISON_JSON"
+```
+
+Both output directories must be absent. `--plan` prints configuration without CUDA. `--continuation` deliberately accepts only Re100, scale1/2, and 3200 reference steps: a bounded campaign, not a physical Re ceiling. Actual steps are 3200 and 12800, reaching the same t*=3.986048829. Physical circle/box/contours and beta remain fixed; all root lengths grow by s, U and jet speed shrink by s, lattice nu remains .0072252. Both runs retain tau_root=.5216756 and tau_fine=.5433512, with Mach .0519615/s. This diffusive refinement changes the finite-Mach/compressibility error as well as grid resolution; it is not an isolated spatial-error order study.
+
+### Units, cadence, and reconstructibility
+
+Reference length/time are one scale-1 root lattice length/time; density reference is one. Convert scale-s root quantities by: length /s, time /s², velocity times s, mass /s², momentum and impulse /s, force times s, angular impulse /s², pressure times s². Volume and mass rates are unchanged. The nominal signed aperture volume rate is ±.0189155293672 in reference units at every scale. A mass flux divided by rho_ref times that rate is a reference-density diagnostic, not an actual-volume-flow ratio. Saved Q and M remain separate.
+
+Exact raw observations accumulate every completed base interval, including both fine substeps. Field downloads occur only at shared reference times 0..100 at dt=1, then 100..3200 at dt=4: 876 samples per run, compared with 3201/12801 possible every-base samples. Every 100-reference-time window boundary is included. Trapezoidal integration uses the actual variable time gap, with the raw ledger covering exactly the same endpoints. No missing sample is silently treated as unit dt. Sampling is denser during abrupt startup; it is not a guarantee of resolving all high-frequency acoustic modes. Offline coarsening can expose some time-quadrature sensitivity but cannot rule out unresolved-frequency aliasing.
+
+`samples_s*.npz` stores at every sample: density minima/maxima/max perturbation and max speed for uniform fluid, AMR root leaves and AMR fine leaves; composite full-domain mass; CV endpoint inventory and flux; separate advective, pressure and negative-viscous-traction momentum fluxes; nearest-fluid mass proxy; extrapolation ray primitive values; linear/quadratic reconstructed Q and M; and cumulative raw wall/aperture/total/blowing/suction rows. Associated JSON identifies axes, units, conversion factors, hashes and snapshot metadata. Composite AMR mass sums root leaves at area1 and fine leaves at area.25, then divides by s². Covered cells are excluded. Global periodic mass change minus total raw body mass is reported, so a transfer/interface mass error cannot hide behind the two contours lying wholly within the fine patch.
+
+Five compressed primitive snapshots at reference times 0,100,800,1600,3200 retain rho, reference velocity, origin and spacing for uniform, AMR root and AMR fine grids. Inactive/solid entries are NaN. These are full primitive grids at sparse times, not downsampled images or distributions. They permit independent spatial quadrature, field inspection, masks and inventory reconstruction. Per-sample split flux/inventory arrays allow independent temporal integration without rerunning GPU work. FP32 saved primitive snapshots introduce their own rounding; FP64 sampled diagnostic/ray arrays remain in the sample file.
+
+### Independent aperture estimators and limitations
+
+Thirty-two Gauss points per true aperture arc, with rays at distances 1.5,2.5,3.5 finest-cell widths into the fluid, sample rho,u,v by bilinear interpolation using only active fluid nodes. No commanded wall value or raw population enters reconstruction. Linear and quadratic outward-normal extrapolations separately reconstruct rho and u; integrate Q=integral(u.n ds) and M=integral(rho*u.n ds). Retain ray positions, normals, weights, primitive samples and coefficients, making every estimate reproducible. The nearest-fluid 64-point mass proxy is preserved for continuity with the pilot and remains explicitly a proxy.
+
+Neither estimator is an exact wall value or validated wall model. Extrapolation amplifies noise and may yield unphysical density; do not clamp it to force agreement. Sector endpoints contain nonsmooth prescribed velocity changes, and interpolation may mix their neighborhood. Linear-versus-quadratic spread, ray density extrema, resolution changes and analytic manufactured tests constrain interpretation, but their agreement is not proof of low bias. Two grids alone cannot establish asymptotic convergence. Nominal geometry/profile flux is exact for the commanded uniform radial profile; comparison with reconstructed Q diagnoses estimator plus numerical-boundary error, not automatically a Jet defect. Raw reaction remains momentum transport plus traction; no nozzle-load or solid-only force claim.
+
+### Predeclared comparison criteria
+
+These criteria are fixed before the continuation runs. There is no new physical acceptance threshold and no tolerance fitted to the pilot:
+
+1. Structural validity: exact source/provenance, matched geometry/parameters, unclamped q/no fallback, both apertures resolved, finite positive active-node density and finite velocity at every saved field sample, complete scheduled samples, contiguous matching raw intervals, and all declared files/hashes. Runtime does not promise positivity between saved samples.
+2. Report every window's signed and gross quantities, maximum sampled errors, and early (reference t<=800) versus later (t>800) norms separately. Normalize mass residual by rho_ref*abs(Q_command)*window_duration, and reaction residual by .5*rho_ref*U_ref²*D_ref*duration. Avoid dividing by a near-zero net mass or instantaneous force.
+3. Recompute contour residuals using the complete sampled grid and every second/fourth sample, always retaining endpoints. Save their changes as a temporal-sensitivity proxy, not an error bound. Compare both contours and both backends; show mass, Cx and Cy components separately.
+4. A directionally resolved reduction in a component's RMS CV residual is flagged only if coarse-minus-fine RMS exceeds twice the largest observed temporal coarsening change. This is an evidence-of-trend flag, never a physics PASS. If a component plateaus or grows, decompose temporal/spatial/staircase/boundary effects before proposing production changes.
+5. Compare reconstructed Q/command and M/(rho_ref*command) separately, at identical physical windows, retaining both extrapolations. Regard refinement improvement as persuasive only when it exceeds estimator spread and temporal variation. Inspect density and global mass alongside it. Agreement of AMR and uniform ledgers alone cannot validate their shared boundary treatment.
+6. Four D/U in a periodic unforced domain remains transient consistency evidence. Two scales do not prove order, stable shedding, infinite-stream drag, all-Re capability, or readiness to promote Re400. Formal physical acceptance needs an additional reference/error budget and appropriate time/domain evidence.
+
+### Runtime and storage budget
+
+Actual earlier scale-1 pilot cost was 52.3884s launch-to-exit, 46.1414s after READY for800 steps with full-field diagnostics every base step. A naive same-diagnostic3200-step scale-1 extrapolation is about210s; the new876 field samples reduce transfer count but add ray diagnostics and compression. Use conservative planning envelopes210–500s for scale1 and900–3200s for scale2, not timing guarantees. The scale2 conservative envelope accounts for4x cells and4x root steps; sparse sampling mitigates but does not eliminate that cost. Post-READY safety caps are1200s and5400s respectively, replacing the unsuitable fixed1800s assumption. Root owns compilation/startup timeout and serial launch decisions.
+
+Device-envelope estimates remain128/512MiB for s1/s2, at least1GiB free (or twice estimate). Output estimate is under64MiB per run including five primitive snapshots and876 sample records; no all-time populations are saved. Plan/metadata and sampled files are rewritten at each100-reference-time window to retain bounded partial evidence if interrupted. READY still follows compiled warmup and state/time reset, before measured stepping begins.

docs/validation/les_helpers.md

@@ -0,0 +1,40 @@
+# Smagorinsky baseline/candidate helper diagnostic
+
+This validation-only diagnostic compares exact d79 production headers with a temporary candidate. It does not modify production source. The candidate changes only the D2Q9 and D3Q19 closed-form factors from 18 to 18 sqrt(2), plus comments defining |S| = sqrt(2 S:S) and self-consistent effective tau. The small reviewed patch and expected header hashes are in `tests/validation/les/data`; no copied headers, solver trees, raw results, or binary fixtures are versioned.
+
+## Prepare and verify on the CPU
+
+From the repository root, choose a new output directory:
+
+```sh
+python tests/validation/les/prepare.py --output-dir output/les-host/candidate
+python tests/validation/les/test_candidate.py --candidate-dir output/les-host/candidate --output output/les-host/host_results.json
+```
+
+Preparation checks both actual production header hashes against d79, copies only `descriptors.cuh` and `turbulence_smag.cuh` into output-local baseline/patched include trees, applies the reviewed patch only to the latter, and verifies all four resulting hashes. It refuses an existing candidate directory. The host test verifies candidate hashes again and refuses an existing evidence file. The Git branch HEAD may include validation commits; header content, rather than HEAD identity, is the pin.
+
+The independent host oracle constructs second-order Hermite populations and solves the independently derived quadratic by bisection:
+
+    tau * (tau - tau0) = 9 Cs^2 ||Pi_neq|| / (sqrt(2) rho)
+
+There are **736 parameter cases**, covering D2Q9/D3Q19; Cs=0,.08,.16,.24; tau0=.6,.8,1.2; rho=.7,1,1.3; equilibrium, isotropic stress, pure shear, and trace-free diagonal extension; all coordinate planes and both signs; density-scaled Pi and separate fixed-Pi/nonunit-rho probes. The test checks quadratic residuals, closed/default-three/converged-200 iterations, bit-identical unchanged iterative output, and an additional explicit cap-active manufactured probe. Existing g++ and Python stdlib are sufficient; no installation is attempted. Compilation products are temporary. Previously reviewed host maxima were omega error 1.394302e-7 and quadratic residual 1.201202e-7; this is not CUDA fast-math evidence.
+
+## Authorized GPU diagnostic
+
+Use the existing working PyCUDA/NumPy environment and an explicitly selected device, through the same serialized GPU launch owner as the other campaigns:
+
+```sh
+CUDA_VISIBLE_DEVICES="$VERIFIED_IDLE_GPU" python tests/validation/les/run_gpu.py --run-gpu --device 0 --output-dir output/les-gpu
+```
+
+Device 0 is the logical device after CUDA visibility filtering. The output directory must not exist. The runner materializes and verifies the isolated include trees under `output/les-gpu/candidate`, then runs baseline and patched processes sequentially. Each process compiles one SourceModule at a time synchronously and synchronizes each probe. There are no background jobs, worker pools, or parallel compiler calls. No machine contact, device selection, reservation, or environment setup is performed by the runner.
+
+Each version has exactly **48 scalar GPU cases**, 96 total: D2Q9/D3Q19, Cs=.16/0, equilibrium/shear/isotropic/cap-active manufactured stress, and closed/default-three/converged-200 branches. This is the frozen GPU matrix, not the expanded 736-case host matrix. Outputs `baseline.json` and `patched.json` contain raw scalar omega values and device name. Completion means only the diagnostic executed; an independent comparison against the declared host oracle is still required. A failed run leaves partial evidence for inspection and must not be overwritten.
+
+## Interpretation and limits
+
+Full-stress versus deviatoric-stress selection, iterative viscosity cap, iteration count/relaxation, omega guards, collision dispatch, and AMR guards remain unchanged. Closed and iterative paths intentionally remain different for isotropic or cap-active stresses. No settings or Cs defaults change. High stress is a helper diagnostic, not an admissible flow-state claim.
+
+The corrected scalar formula is justified only under the stated stress-strain estimate. MRT full-trace stress does not generally share one shear relaxation rate, so its bulk coupling remains uncertified. Force-corrected non-equilibrium stress and Guo-force interaction also remain uncertified. These manufactured tests are unforced and do not cover full TRT/MRT collision, streaming modes, shifted storage, walls/Jets, flow solutions, or 3D turbulence. Existing guard statements are preserved, not newly comprehensively tested; the main matrix is guard-inactive. No AMR LES support is added or enabled.
+
+Production integration and removal of this temporary candidate fixture are separate decisions after GPU and applicable flow evidence. CPU success alone does not approve a production change.

docs/validation/moving_bodies_stage1.md

@@ -0,0 +1,46 @@
+# Moving circles — stage-1 evidence (development level)
+
+Owner criterion (Yanqi via TRON): prescribed motion and one free VIV case both
+"reasonably close" to a predeclared reference = development-stage success.
+This is practical closeness, not a formal validation claim. Every number
+below is from Astra's receipts as posted in Slack C0C78UFKGRM thread
+1793335557.460509; raw outputs stay on Horsea under `/tmp/celeris-results-*`
+and the Mac evidence directory (not in git).
+
+## Code
+
+- Production: `src/` identical to `653fd997` (slices S1 `983020b6`,
+  S2a `b920a303`, S3a `653fd997`). CPU suites and GPU hold/crossing gates
+  passed on those slices (G0a/G0b population-bitwise; X1 crossing ledger).
+- Research drivers: `research/duetsch_re100_kc5/` (`dd37883d`, capture
+  `a0aea3b9`) and `research/viv_re150/` (`fb507aa1`), run as committed.
+
+## Prescribed in-line oscillation (Dütsch et al. 1998, Re 100, KC 5)
+
+- Protocol: `docs/validation/duetsch_re100_kc5_protocol.md`.
+- Frozen settling gate (.002 F_ref waveform): **FAILED** and kept on record:
+  D40 domain stage (20/40/60 D, 11.25 T) and the 60 D duration diagnostic
+  (31.25 T, 0/28 pairs; last waveform drift .00613 F_ref).
+- Unscored late-cycle CME fits c_d ≈ 2.02–2.05, c_i ≈ 1.46–1.48 vs the
+  paper's computed (2.09, 1.45); fields clean and symmetric (owner view).
+  The owner accepts ~0.61 % cycle drift at D40 for this stage; the gate is
+  not re-scored.
+- Fig. 8 LDA profiles: qualitative only (no digitized ordinates).
+
+## Free transverse VIV (Kolahdouz §4.1.1 setup, Qin §4.5 target)
+
+- Predeclaration: `docs/validation/viv_re150_predeclare.md` (agreed at
+  `1abfe954` under its former name `leontini_viv_predeclare.md`); run at `fb507aa1`, single case, D = 40, 75 D × 60 D.
+- Result: status `scored`, 336,384 steps (t U/D = 336.4); A_max = .5464 D vs
+  .520 D (+5.1 %, inside the declared ±10 % band); mean half peak-to-peak
+  .5448 D; f/f_n = .955; block drifts .78/.29/.18 %, last-five spreads
+  .15/.11/.10 %; finite, no_donor = 0, no seed; 337.7 s, ~1.0 ms/step.
+
+## Limitations (binding)
+
+- One resolution (D40) per case; no grid or time convergence.
+- Structural RHS = CME + Wen is a theory-motivated stage choice; CME-only
+  and node-impulse variants were not run as RHS; no force law is validated.
+- Boundary mismatches: NEQ outlet with backflow clamp vs traction outlet;
+  finite box; the strict Dütsch settling failure is unexplained.
+- No mass correction at curved walls; ~1 ms/step host-coupled overhead.

docs/validation/refined_dfg.md

@@ -0,0 +1,70 @@
+# Matched SRT uniform / refined DFG Re100 preparation
+
+Status: CPU-preflight checked; **not GPU executed or approved to execute**. No physical acceptance or speedup claim. No production source changes. Root owns GPU admission and integration.
+
+## Frozen setup
+
+Canonical source snapshot: integrated commit `cd3a657f9d3833e812c3cca173525f165b48710a`. Production origin remains candidate `47b05bc8abfc957fe876b0c63bdb386e3c6cbaa5` (on `5338864`, on `69e9b78`); production files are byte-identical. The integrated Re100 helper header/PIN records that origin explicitly. Both commit identities are retained in the manifest. `tests/validation/data/refined_dfg/source_manifest.json` hashes all production source files plus the existing DFG geometry/pressure helper, periodicity helper and official reference cycle. An integrated checkout may have a different commit but must have identical pinned file contents. No MRT external-reference run is reused as the matched uniform control.
+
+Both cases: SRT, shifted FP32, double buffer, no LES, no applied force, stationary cylinder, local Zou–He parabolic inlet, halfway y walls, identical pressure-NEQ outlet with **all nine nonequilibrium components damped by 0.5**, backflow clamp disabled. This outlet is not the exact canonical DFG do-nothing condition. Raw cylinder reaction observation is a diagnostic, not applied forcing.
+
+Physical units use D=0.1 m, mean U=1 m/s, ν=0.001 m²/s, density reference=1; domain 2.2×0.41 m, cylinder center (0.2,0.2) m. Uniform D80: 1761×330, dx=0.00125 m, dt=0.0000125 s, ν_lattice=.008. Refined root D40: 881×166, dx=.0025 m, dt=.000025 s, ν_lattice=.004; fine dx/dt/ν match uniform D80. All lattice mean speeds are .01.
+
+Fixed half-open patch **(40,24,320,140)** in root edge coordinates maps to x=[.09875,.79875] m, y=[.0575,.3475] m. The body and about six diameters of downstream wake are fine; wall layers and far wake remain coarse. Bounds are frozen before outcomes, not tuned afterward. Geometry-only leaf-count and nominal collision-work ratios to uniform are ~.419 and ~.321. These omit real launch/transfer/halo/measurement costs and are not measured speedups. The narrow root block height is legal but potentially expensive; do not infer speed from leaf count.
+
+Exact root dimensions are tiled by (by,bx)=(2,881); no padding. Fine allocated shape (240,568), including four-cell halos, uses (8,8). `host_geometry` calls production channel transfer-overlap checks and complete fine cut-link/donor/transfer guards before any CUDA import.
+
+### Half-cell conversion
+
+Uniform integer nodes have physical coordinates (i*dx, (j-.5)*dx). Root edge coordinates therefore map to ((X-.5)*dx_root, (Y-1)*dx_root). Body edge center=(80.5,81), radius=20; wall edges Y=1,165; source planes X=.5,880.5. Fine local body nodes are `(body_edge - fine_origin)/.5 - .5`.
+
+Body and physical wall planes match exactly. The axes have different phases. With fine origin O=(38,22):
+
+- x_f = [O_x+(j+.5)/2-.5] dx40 = (j+75.5) dx80, versus x_uniform = i dx80. Fine x samples have a half-fine-cell (quarter-root-cell) offset.
+- y_f = [O_y+(k+.5)/2-1] dx40 = (k+42.5) dx80, versus y_uniform = (l-.5) dx80. The y samples align exactly for l=k+43.
+
+This difference follows from the inlet's ghost-node plane versus the half-way y-wall planes. The host phase test checks both mappings. Compare interpolated observables, not pointwise arrays or bitwise equality; x-phase error, the different fine collision arithmetic, wall resolution, and coarse/fine transfer effects all contribute to discrepancies. No field-difference acceptance is claimed by this runner. Initial fluid state samples the same analytic parabolic equilibrium as uniform production initialization; root boundary ghosts start at rest. It is not asserted to be bitwise identical across different grids/arithmetic.
+
+## Observations and gates
+
+- Every AMR base step is individually followed by `read_raw_exchange(..., window='last_base_step')`: two fine substeps, root-lattice per-unit-depth impulse integrated over [n,n+1]. `step(n)` alone retains only its last base interval, so it cannot support averaging the whole batch.
+- Uniform `Simulation.run(batch)` / `read_force` gives the mean over that batch; multiply by batch before accumulating. Cd/Cl divide the interval mean reaction by 0.5 U_lattice² D_lattice in each case. Force unit is ρ dx³/dt² per depth, so fine-uniform lattice force is twice root force for the same physical load.
+- Force timestamps are observation-interval midpoints. Pressure uses physical decoded postcollision density at the interval end, extrapolated from fluid-only points one/two **fine** cells outside the cylinder using existing `pressure_probes`. Pressure difference is normalized by ρ_ref U_physical². Existing periodic helpers align pressure onto force cycles.
+- Public AMR downloads exclude nonleaves. Fixed geometry masks, not state-dependent finiteness masks, check all fluid populations and sum ρ dx_level²; covered root cells, body, boundaries and fine halos are excluded. Corrupt NaN fluid cannot disappear from the mass check. Mass is per-unit-depth ρ_ref·m². Uniform uses its physical fluid flags and dx². Different sampling of the circular boundary means initial discrete fluid volume can differ slightly; compare temporal stability, not identical absolute mass.
+- Flux samples root/uniform x-index 2 and -3, summed with dx and physical velocity conversion. Those planes differ by grid-scale offsets; cycle-average inlet/outlet balance is the gate, not direct pointwise flux equality.
+- Dense measurement width Δt*=.02 in the pilot and for t*≥240, otherwise .5. Pilot ends t*=5; full ends t*=300. Same existing five-cycle periodicity, mass, flux, and reference gates are imported without modification. Both official-reference diagnostics and refined-versus-uniform cycle comparisons are written. `matched_case_pass` refers only to matched SRT agreement, not certification of canonical DFG or the broader suite.
+- Safety stop: nonfinite state/reaction, Mach>.2, or density outside [.5,1.5]. GPU durations include required exchange reads and synchronization in stepping; full wall time also includes host measurements. Do not report pure-kernel throughput from these numbers.
+
+## Commands
+
+From the repository root, CPU only:
+
+```sh
+PYTHONPATH=src python tests/unit/test_refined_dfg.py
+python tests/validation/run_refined_dfg.py --mode plan --output /tmp/refined-dfg-plan-new
+```
+
+Fourteen CPU tests are retained in tests/unit/test_refined_dfg.py. Plan JSON is configuration output only; no preparation result files are committed. The initial attempt to use pytest was unavailable in this interpreter; tests use standard-library unittest and NumPy instead.
+
+Only after root channel GPU gates pass and root explicitly admits an idle physical GPU, root may run:
+
+```sh
+CUDA_VISIBLE_DEVICES=<admitted-device> timeout --signal=TERM --kill-after=30s <caller-hard-budget>s python tests/validation/run_refined_dfg.py --mode pilot --gpu-gates-approved --max-wall-seconds <caller-soft-budget> --output <new-pilot-directory>
+CUDA_VISIBLE_DEVICES=<admitted-device> timeout --signal=TERM --kill-after=30s <caller-hard-budget>s python tests/validation/run_refined_dfg.py --mode full --gpu-gates-approved --max-wall-seconds <caller-soft-budget> --pilot-results <completed-pilot-directory> --output <new-full-directory>
+```
+
+`--gpu-gates-approved` is a caller attestation, not proof that GPU tests ran. Full mode additionally requires both matched healthy pilots through t*=5 with identical source hashes, bounds and runner hash. No GPU/Mac/remote operation has been performed for this preparation. Pilot/full outputs must be new/empty. Uniform runs first; an unhealthy case stops the campaign. A full run that fails periodic/matched gates exits nonzero.
+
+## Bounded execution and receipt validation
+
+No pilot throughput is known yet; the caller must set a finite positive `--max-wall-seconds` rather than treating an invented estimate as calibration. After valid pilots, the full-run calibrated budget is 3 × sum_over_cases[startup_seconds + 60 × (pilot_wall_seconds − startup_seconds)]. The full run uses the smaller of that estimate and the caller's explicit ceiling. This uses total measured pilot evolution/observation cost and the full/pilot physical-time ratio (300/5); 3× is a declared safety margin, not a runtime guarantee. The plan records both budgets.
+
+The campaign deadline begins before the first case initialization. Cooperative checks surround initialization, every AMR root step or uniform ≤100-step batch, and measurements. On observed expiry, the runner stops, writes a nonpassing `wall_time_limit` receipt, and exits 3. A blocking CUDA call cannot be interrupted by these checks: the external `timeout` watchdog is required, with a hard budget chosen slightly above the soft budget to permit cleanup. Hard termination may leave partial CSV data and no final receipt; that never qualifies as a completed pilot.
+
+Each case emits `READY` with strict finite JSON and saves `ready.json` only after its first healthy complete observation, after initialization, actual stepping, force readback, macro/pressure/mass/flux paths and CSV flush all succeeded. No early initialization-only READY is emitted.
+
+Full-run pilot validation rejects nonfinite JSON constants and numeric overflow, wrong case/mode/status, nonboolean health, missing/duplicate/out-of-order rows, wrong step counts or observation times, missing numeric observations, health-limit violations, absent/mismatched READY receipts and invalid timing calibration. It requires exactly 250 observations spanning the full dense t*=5 pilot, source/runner hashes and frozen bounds. Tests include the reviewer's exact NaN-endpoint regression and malformed receipt variants. Synthetic test fixtures exist only in temporary directories and are not simulation results.
+
+## Integrated source import guard
+
+The runner's source defaults to this repository root. Before geometry or GPU work, it verifies the pinned source/helper/reference contents and requires the imported CelerisLab package to be exactly `<source>/src/CelerisLab/__init__.py`. An installed DynamisLab copy or another cached checkout is rejected. Integration changes paths/readability and this explicit import assertion; geometry, numerical definitions, gates, and receipt validation remain frozen. Any new path-formatted runner has its own hash, so old preparation pilot receipts cannot authorize a full run of this integrated runner.

docs/validation/refined_dfg_mrt.md

@@ -0,0 +1,71 @@
+# Matched MRT DFG pilot preparation
+
+Preparation only: this test-only extension reuses the existing runner and existing MRT
+operator. GPU admission awaits reviewed MRT capability results; no pilot/full execution
+is implied by CPU preflight. No production, historical SRT manifest, reference data,
+periodic gate, geometry, initialization or observation algorithm is changed here.
+
+## Selection and provenance
+
+Use `--collision MRT` for **both** uniform D80 and refined root D40/fine D80. There are
+no independently selectable collision models per case. Default remains SRT.
+
+MRT verifies `data/refined_dfg/source_manifest_mrt.json`, pinned to reviewed numerical
+source snapshot `3ea131e92c057843034f11a1c574301a2430dfce`, including the shared geometry,
+pressure/cycle helpers and official reference. Test-only commits may change HEAD without
+changing this numerical source pin. Plan, READY, case summaries and comparison separately
+record `checkout_revision` and `checkout_dirty` using existing source-provenance helper;
+the runner hash remains separate. Collision is recorded in every receipt, and full-mode
+validation rejects missing or different collision labels in plan, either summary or either
+READY receipt, in addition to existing source/runner/health/time checks.
+
+The historical SRT manifest remains byte-for-byte unchanged. SRT on the MRT candidate
+checkout deliberately fails that source pin; use a matching historical checkout via
+`--source` for SRT. No fallback or automatic repinning is permitted. Historical SRT
+failure/diagnostic evidence remains attached to its original source and runner hashes;
+it cannot authorize an MRT full run. The existing failed-observation step-reporting
+undercount is not changed in this narrowly scoped selection patch.
+
+## Frozen physical comparison
+
+All settings remain those documented in `refined_dfg.md`: U_lattice=.01, physical mean
+U=1 m/s, D=.1 m, shear ν=.001 m²/s, fixed physical domain/body/wall planes, patch
+(40,24,320,140), shifted FP32 double buffers, no LES/forcing/Jets, finest dx=.00125 m,
+finest dt=.0000125 s, unchanged half-cell frame conversion and axis-specific phase.
+Force interval accumulation, physical leaf mass, pressure interpolation, flux sampling,
+safety thresholds, t*=5 pilot and t*=300 cap are unchanged. Existing accuracy/periodicity
+criteria are imported unchanged. Both MRT cases are fresh runs; old MRT or SRT results
+are not substituted as controls.
+
+Both cases use the **existing MRT pressure-NEQ branch**: only unknown directions q2/6/8
+are extrapolated. This differs from SRT's all-nine .5-damped branch; the retained
+`srt_neq_damp=.5` configuration value is inactive under MRT. Backflow clamp remains off.
+The outlet is still noncanonical relative to exact DFG do-nothing conditions.
+
+The reused MRT operator keeps fixed kinetic rates `s_e=s_eps=s_q=1.2` on all levels;
+only the shear rate follows existing per-level viscosity. Physical bulk relaxation
+therefore differs between coarse and fine levels. Transfer operators and subcycling
+are unchanged. This is the candidate's declared behavior, not a new fully mode-scaled
+MRT transfer scheme. Do not tune rates, the patch or gates after seeing outcomes.
+Capability smoke/parity gates do not establish DFG accuracy or speedup.
+
+## CPU and admission commands
+
+From this checkout:
+
+```sh
+python tests/unit/test_refined_dfg.py
+python tests/validation/run_refined_dfg.py --collision MRT --mode plan --output /tmp/new-mrt-dfg-plan
+```
+
+After root verifies the candidate MRT root/parity/refinement capability results and admits
+an idle device, the paired pilot may use the existing bounds and external watchdog:
+
+```sh
+CUDA_VISIBLE_DEVICES=<admitted-device> timeout --signal=TERM --kill-after=30s <hard-budget>s python tests/validation/run_refined_dfg.py --collision MRT --mode pilot --gpu-gates-approved --max-wall-seconds <soft-budget> --output <new-mrt-pilot-directory>
+```
+
+The flag is caller attestation, not evidence. An unhealthy first case prevents the second.
+Existing strict pilot receipt validation and calibrated wall-time controls remain; full
+mode is not being admitted as part of this preparation. Root must review both healthy
+pilot outcomes and separately decide any full-run admission.

docs/validation/refined_dfg_timing.md

@@ -0,0 +1,58 @@
+# Refined DFG MRT timing harness (measurement only)
+
+`tests/validation/time_refined_dfg.py` times the matched MRT refined/uniform DFG Re100 setup of
+`run_refined_dfg.py` (same configuration, geometry and initial state functions). No numerical,
+physics-gate or production change; no force or accuracy result is produced.
+
+| Variant | Loop | Force reads |
+|---|---|---|
+| A | refined `step(1)` + `read_raw_exchange` per base step | runner-like force-read workload (values discarded) |
+| B | refined `step(1)` only, no host reads (`observe_raw_exchange` stays on) | timing-only |
+| C | refined single `step(N)` | timing-only; ledger keeps the final base interval only |
+| E | uniform `sim.run(<=100)` + `read_force` | runner-like force-read workload (values discarded) |
+| E' | uniform single `sim.run(2N)` | timing-only; at most a whole-window average, different summation order |
+
+- No variant retains a valid force history; A/E omit the runner's interval aggregation and
+  validation, and no variant includes macro/probe/CSV costs. Results are not full benchmark
+  throughput.
+- Status lines: `CONSTRUCTED` (construction/JIT complete) and `WARM_READY` (first warm-up and
+  health check passed) per case.
+- Equal simulated duration: N refined base steps vs 2N uniform D80 steps.
+- Every repeat starts from the same fresh state (refined `initialize`, uniform `snapshot/restore`)
+  and the same warm-up; construction/JIT, warm-up, downloads and parity checks are untimed.
+- The actual stepping stream is synchronized explicitly before and after each timed loop; the
+  wall timer (`time.perf_counter`) is the only source. No CUDA-event span is called kernel time.
+- `--max-wall-seconds` is required for GPU runs (outer timeout, checked between variants and
+  every 100 steps in per-step loops).
+- Final populations and NaN masks must be bitwise identical to the first A repeat (A/B/C) or the
+  first E repeat (E/E'); refined and uniform grids are never compared. Leaf/fluid populations
+  must be finite. Physical health (finite leaf/fluid macros, rho in [0.5, 1.5], max Mach <= 0.2,
+  the existing runner limits) is checked after warm-up and after each timed window. Matching NaN
+  is accepted only as a storage mask; any infinity or level-count mismatch fails parity. All
+  parity/health checks are untimed.
+- Cases run sequentially (uniform, then refined) in one process with startup serialized;
+  variants are interleaved within each repeat. A-B and B-C are measured comparative
+  differences under GPU variability, not exact causal decompositions.
+
+Usage (root selects one verified idle GPU):
+
+    PYTHONPATH=src python -m unittest tests/unit/test_time_refined_dfg.py
+    python tests/validation/time_refined_dfg.py --output <new> --plan
+    CUDA_VISIBLE_DEVICES=<gpu> python tests/validation/time_refined_dfg.py --output <new> --max-wall-seconds <s>
+
+Defaults: 2000 base steps, 200 warm-up base steps, 3 repeats. Profiler capture and the
+`observe_raw_exchange=False` variant are deferred until these measurements exist.
+
+## A versus observation-window ledger (`tests/validation/time_window_dfg.py`)
+
+Measurement-only comparison on the same shifted-MRT refined setup: A (per-base `step(1)` +
+`read_raw_exchange`, summed per 80-base-step interval), W (`start_exchange_window`, `step(80)`,
+one window read) and W1 (window with 80 x `step(1)`, isolating the read pattern from call
+batching). Same fresh state, warm-up and simulated duration; populations must be bitwise equal
+to the first A repeat and per-interval total impulses within the documented engineering
+tolerance, all outside timing. The candidate source is recorded (checkout revision, dirty flag,
+file hashes); frozen refined-DFG manifests/results are not used or changed.
+
+    PYTHONPATH=src python -m unittest tests/unit/test_time_window_dfg.py
+    python tests/validation/time_window_dfg.py --output <new> --plan
+    CUDA_VISIBLE_DEVICES=<gpu> python tests/validation/time_window_dfg.py --output <new> --max-wall-seconds <s>

docs/validation/refined_dfg_window.md

@@ -0,0 +1,117 @@
+# Opt-in observation-window ledger in the DFG runner
+
+This test-only integration adds `--exchange-window` to `run_refined_dfg.py`. It uses the
+existing production ledger; no collision, boundary, transfer, physical setup, reference,
+periodicity gate or acceptance threshold changes. Default remains the historical
+per-base-step observation path. Uniform stepping/force accumulation is unchanged.
+
+For the refined case, each existing observation interval opens a new ledger at completed
+base step `begin`, advances exactly the same `n` base intervals, and reads the integrated
+root-lattice impulse for `[begin, begin+n]`. The contract requires root units, `window`
+kind, `2*n` fine samples, matching endpoints, and fine dt=.5. The existing coefficient
+calculation still divides this impulse by `n` and `.5*U_lattice**2*D_root`; force timestamps
+remain `(begin+n/2)*U_lattice/D_root`. It does not divide an already averaged force again.
+Pressure/macro/physical-leaf mass measurements and safety checks remain at the original
+interval end. Pilot interval is 80 root steps; early full-run intervals remain 2000, and
+any final shortened interval uses its actual `n`.
+
+The opt-in uses one `step(n)` call and one window read per observation, rather than `n`
+Python calls/readbacks. Internal subcycling and per-base synchronization remain owned by
+the same backend. Cooperative deadline checks surround that complete interval; unlike
+the default path they cannot interrupt between base steps inside `step(n)`. The existing
+external hard watchdog is still required. The full-run cadence/cap is documented here,
+but this preparation does not admit a full run or a GPU operation.
+
+## Provenance and receipt separation
+
+`source_manifest_window.json` pins the reviewed a233c9032487a6006e950d1e327079b00466c410
+snapshot (production ledger origin d930) plus existing helper/reference files. Both SRT
+and MRT are supported by this explicit opt-in source pin; collision selection remains
+independent and shared by the two cases. Existing SRT and MRT manifests are untouched.
+Default mode continues to reject the changed candidate under those historical pins;
+use a matching historical `--source` checkout to run its default path. There is no
+silent repinning, source fallback, or reuse of historical outputs as candidate evidence.
+
+Plan, READY, summaries, timeout/comparison receipts now record `observation_mode` as
+`last_base_step` or `window`, alongside collision and actual checkout provenance. On a
+uniform receipt this labels its **paired campaign's refined observation mode**, not a
+change to uniform observation. Full-mode pilot validation rejects missing or mismatched
+mode labels in the plan, either case summary, and either READY receipt. Source/runner
+hash, collision, completeness and health checks remain. Cross-mode pilot reuse is denied.
+
+The earlier short A/W/W1 timing/capability evidence is not a full-run speedup or accuracy
+claim. Mathematical impulse integration/units are unchanged; floating-point reduction
+order can differ, so bitwise equality of force sums is not promised. Physics acceptance
+continues to use the existing frozen gates. Historical failures/results are untouched.
+
+CPU preparation commands, from the repository root:
+
+```sh
+python tests/unit/test_refined_dfg.py
+PYTHONPATH=src python -m unittest tests.unit.test_raw_exchange_window tests.unit.test_time_window_dfg -v
+python tests/validation/run_refined_dfg.py --collision MRT --exchange-window --mode plan --output /tmp/new-window-dfg-plan
+```
+
+Root must independently review and admit any execution. An admitted paired pilot uses
+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

@@ -0,0 +1,161 @@
+# Periodic 2D Taylor–Green AMR campaign (prepared, not GPU-qualified)
+
+This validation harness complements DFG Re100 and Jet/body tests. It measures
+smooth 2D periodic decay and errors crossing fixed refinement interfaces at
+Re_L=100 and 1000. It does **not** certify 3D turbulence, LES, Jet performance,
+wall conditions, dynamic refinement or general high-Re flows.
+
+## Reference and conventions
+
+Primary implementation-author documentation, checked 2026-10-18:
+- TensorMesh, exact velocity and pressure with a consistent phase:
+  https://docs.tensor-mesh.com/example_gallery/fluid/taylor_green.html
+- AeroSim Nassu, 2D decay, energy and lattice-length Re definition:
+  https://docs.aerosim.io/nassu/validation/analytical/04_taylor_green_vortex_2d/README.html
+
+We use the TensorMesh phase, rescaled to length L=N root cells:
+
+    k = 2*pi/L; A(t) = U*exp(-2*nu*k*k*t)
+    ux = -A*cos(k*x)*sin(k*y)
+    uy =  A*sin(k*x)*cos(k*y)
+    p/rho0 = -A*A/4 * (cos(2*k*x)+cos(2*k*y))
+    E = <|u|^2>/2 = U*U/4 * exp(-4*nu*k*k*t)
+
+Pressure is kinematic, with rho0=1. A global velocity sign reversal leaves
+pressure unchanged; exchanging sine/cosine without the corresponding pressure
+phase can reverse its sign. CPU tests independently check momentum residuals.
+The nonlinear acceleration is a pressure gradient, **not zero**; the AeroSim
+page's prose calling advection zero is not adopted. Do not mix phase variants
+from different references. The formulas above are verified by substitution,
+not by trusting a copied pressure expression.
+
+Re_L=U*L/nu, not Re_k=U/(nu*k)=Re_L/(2*pi). U=.03 in lattice units,
+Ma=U/cs=.0519615, cs^2=1/3, nu_root=.03*N/Re_L. Acoustic refinement uses
+h_l=dt_l=2^-l: lattice velocity stays U, nu_l=2^l*nu_root and
+ tau_l=.5+3*nu_l. The worst root tau is .50288 (N32/Re1000), omega=1.98855,
+inside the existing config guard. No viscosity clamping or guard override.
+
+All initial arrays are physical FP64 equilibrium populations, supplied to the
+public shifted-FP32 postcollision-G initializer. rho=1+3p at each true cell
+center. These are valid equilibrium postcollision states, but do not include
+Chapman–Enskog nonequilibrium stress; startup acoustic/kinetic error remains in
+the measurements and is shared with uniform baselines. The incompressible
+reference is not an exact finite-Mach LBM solution. This is why resolution alone
+need not remove the full error floor.
+
+## Geometry and workload
+
+All patches use level-wide union form, so origins are zero, including fine
+arrays with holes. Coordinates are (index+.5)*2^-level. Metrics integrate only
+ACTIVE leaves, each weighted by 4^-level. Covered cells and halo cells never
+enter norms or mass. Geometry tests prove exact single coverage at root-cell
+resolution. All blocks are 8x8, and both root dimensions are periodic.
+
+At each root N=32,64:
+- 2 levels: L1 rectangle (N/8,N/8,7N/8,3N/4), in L0 indices.
+- 3 levels: same L1 plus L2 rectangle (3N/4,N/2,3N/2,5N/4), in L1 indices.
+
+These off-axis boundaries cross nonzero flow and gradients rather than sitting
+only on symmetry or stagnation lines. Whole geometry scales with N.
+
+16 cases: at each Re, uniform N=32,64,128,256 plus AMR (root32/root64)x(depth2/depth3).
+Each AMR case therefore has both a same-root uniform baseline and a uniform
+baseline at its finest spacing. Uniform N is its own lattice length, so nu and
+step count are scaled to represent the same nondimensional solution.
+Samples t*=tU/L = 0,.12,.24,.36,.48. End time is 16*N base steps, a meaningful
+.48 domain turnover or 3.016 vortex-scale turnover times (scale 1/k).
+At Re1000 energy decays about 7.3%; at Re100 about 53.1%. No plots or full fields;
+each case writes five diagnostic rows and provenance, incrementally.
+
+## Running (GPU owner must schedule launches)
+
+CPU checks, from the repository root:
+
+    PYTHONPATH=src python -m unittest discover -s tests/validation/taylor_green -p 'test_*.py' -v
+
+One GPU case, on the scheduled worker after checking occupancy:
+
+    CUDA_VISIBLE_DEVICES=<physical-id> python tests/validation/taylor_green/run_case.py --repo /path/to/reviewed/checkout --re 100 --n 32 --depth 1 --output output/taylor_green/re100_n32_d1.json
+
+Depth 1 is uniform. Run uniform cases before AMR for each Re; inspect baseline
+screening failures before proceeding. For a complete matrix, repeat the uniform
+call with N=32,64,128,256 and AMR calls with N=32,64 / depth=2,3, at each Re.
+Use serial process startup on the parent's assigned Horsea GPUs. This harness
+does not schedule or acquire GPUs. No GPU was used during preparation.
+
+    python tests/validation/taylor_green/assess.py output/taylor_green/re*_n*_d*.json --output output/taylor_green/assessment.json
+
+The local API/geometry review used clean staging commit
+cd3a657f9d3833e812c3cca173525f165b48710a. This is **not** a claim of results on d79
+or any historical commit. Each runtime output records actual Git HEAD/dirty
+state, an aggregate source-tree hash, plus SHA256 of all harness Python files. Assessment refuses dirty checkouts and mixed source
+or harness identities. Keep reports outside the checkout or .gitignore them so
+new outputs do not change its dirty flag between cases. The source-tree hash excludes bytecode caches; production qualification requires
+a clean checkout.
+The runner uses the existing PeriodicBlockStepper / FixedPatchStepper periodic
+paths only. It does not depend on the new channel-root implementation.
+
+## Preregistered assessment, before any GPU results
+
+All sampled times must satisfy finite screening ceilings:
+- Relative composite velocity L2 <= 5%
+- Relative globally gauge-adjusted pressure L2 <= 15%
+- Relative kinetic-energy error <= 5%
+- Composite mass drift from downloaded t0 <= 1e-5
+
+These are screening budgets, not literature-certified tolerances. Acceptance
+also requires all 16 cases, common source/harness, correct nondimensional times
+and viscosity, and baseline-relative checks on worst post-startup-sample errors:
+- AMR error <= max(2 * same-root uniform error, declared numerical floor).
+- Root64 AMR error <= max(.9 * root32 AMR error, floor), for each depth/Re.
+- Uniform256 error <= max(.9 * uniform32 error, floor).
+
+Floors: velocity .002, pressure .02, energy .004. They are declared low-Mach /
+equilibrium-startup budgets, not fitted to observed results. Ma^2=.0027 motivates
+their scale; it is an asymptotic expectation, not a proof of those coefficients.
+The coarse baseline sets the AMR budget because much of the domain remains
+coarse. The finest uniform error and AMR/fine ratio are always reported, with no
+claim that partial refinement should match a fully fine domain. A pass below a
+floor is bounded accuracy, not a measured convergence order. Report errors and
+ratios even for a pass. Failure requires diagnosis or a separately preregistered
+follow-up, never retroactive tolerance tuning. Higher Re is deliberately absent;
+Re100/1000 must first be stable, resolved and reviewed.
+
+Diagnostics use one global pressure gauge, direct cell-center analytic values,
+kinetic energy per unit reference mass, and actual leaf cell areas. Composite
+midpoint quadrature introduces a small initial energy integration error, retained
+rather than subtracted. Mass drift is relative to downloaded t0, so density
+initialization and mixed-grid quadrature do not masquerade as time drift.
+
+## Pilot scheduling and transfer-consistency scope
+
+Start with one uniform case and one matched AMR case; the 16-case matrix is a
+qualification plan, not authorization to launch every case automatically. The
+GPU owner reviews the pilot before expanding it. Each process prints a flushed
+READY only after initialization, a real base step exercising every level's
+kernel/halo/transfer path, and a finite positive-density download check. That
+step belongs to the measured trajectory; it is not discarded warmup. PROGRESS
+messages contain each of the five diagnostic samples. READY alone is not an
+accuracy pass. Reports include per-level active cells, hops and collision updates.
+
+The complete matrix costs 768,540,672 active collision updates and 21,504 root
+intervals, excluding ghost streaming, halos, transfers and diagnostic work.
+Uniform N256 is the largest case (268,435,456 updates / 4096 intervals per Re).
+AMR N64/depth3 needs 50,987,008 updates / 1024 intervals. These are work counts,
+not GPU wall-time estimates. Baseline comparisons remain available on failed
+screens and partial pilots; absent/nonfinite operands are null, never passing.
+
+Acoustic viscosity scaling and unchanged lattice velocity do not by themselves
+prove nonequilibrium-stress consistency across refinement interfaces. A smooth
+collocated Chapman–Enskog postcollision nonequilibrium has a (tau-1)*h factor;
+the existing implementation instead uses volumetric piecewise-constant explosion
+and stream-only ghosts. Whether that actual transfer construction achieves the
+needed stress accuracy is an unresolved question for this pilot to measure.
+It is not a proven defect, and a collocated-state scaling factor must not be
+inserted into this different transfer operator without a separate derivation
+and validation. This campaign measures the current operator and makes no
+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.

docs/validation/uniform_les_flow.md

@@ -0,0 +1,90 @@
+# Bounded uniform-grid LES flow validation: prepared, GPU NOT RUN
+
+## Status and scope
+
+Prepared for independent review, then an explicitly authorized Horsea run only. No production files were edited, no normalization patch was applied to a full solver checkout, and no GPU was used. This is a small end-to-end **wall-bounded, x-periodic** shear-decay test, not a fully periodic 2D test. It exercises the actual production Simulation → Stepper → OneStep → Smagorinsky → SRT dispatch and double-buffer pull streaming, plus existing halfway bounce-back walls.
+
+The original fully periodic-y plan is unsupported at the pinned revision: both `one_step_double.cu:90` and `one_step_esopull.cu:133` replace wall-adjacent incoming populations for every fluid node on y=1 and NY-2 regardless of its neighboring flags. `tests/validation/run_poiseuille.py:1–10` already documents this. Merely changing all flags to FLUID does not remove this behavior. The present test deliberately matches those real walls; it does not modify the kernels or claim a periodic-y public API.
+
+Only unforced SRT, D2Q9, FP32 shifted storage and double-buffer streaming are included. No MRT/TRT, force correction, EsoPull, AMR, Jet, 3D turbulence or physical LES coefficient calibration is certified. In continuum this unidirectional incompressible shear is trace-free; small finite-Mach/discretization stresses in the LBM are not asserted to vanish exactly. The underlying scalar-helper audit remains the cleaner normalization isolation.
+
+## Exact source contract
+
+Baseline is explicitly repinned to the production snapshot in `cd3a657f9d3833e812c3cca173525f165b48710a`, whose reviewed AMR-channel source origin is `47b05bc8abfc957fe876b0c63bdb386e3c6cbaa5`. This new experiment does not inherit historical d79 GPU/flow acceptance. The original preparation remains associated with d79; its results are not rewritten.
+
+`tests/validation/data/les_flow/source_pins.json` records all 101 tracked production source files from that snapshot. The runner checks every hash before importing CelerisLab or touching a GPU. It accepts only:
+
+- `--variant baseline`: all baseline hashes, including helper SHA256 `ff7f000297ee0817e255ad9fcb6a13b647e3ddd5b206518d35f38d2895a9f501`.
+- `--variant corrected`: the same source bytes except helper SHA256 `a3db46c2e7d27530b2d1436e65cdbed0b72cc7e047bfbeef2a640877271b51aa`, from the independently reviewed `tests/validation/les/data/smagorinsky_normalization.patch` artifact.
+
+The runner records the actual checkout commit and exact imported package. It never applies a patch itself. Run it against separate isolated full checkouts. The patch candidate's minimal header tree is not a runnable solver checkout. A source mismatch is a blocker, not permission to regenerate pins from an arbitrary new checkout.
+
+Relevant pinned implementation evidence:
+
+- `tests/integration/test_numerical_gpu.py:24–85`: equilibrium construction, installation of spatial postcollision state, count=1 adapter, raw population observation and x-periodic/walled flags.
+- `tests/validation/run_poiseuille.py:29–78`: production Simulation use with periodic x, halfway y walls and downloaded populations.
+- `src/CelerisLab/lbm/kernels/core/layout.cuh:87–104`: actual modulo neighbors.
+- `src/CelerisLab/lbm/kernels/boundary/bounce_back.cuh:18–38`: incoming populations copied from opposite local input directions.
+- `src/CelerisLab/lbm/kernels/operators/helpers.cuh:53–61`: LES effective omega feeds actual SRT collision.
+- `src/CelerisLab/cuda/compiler_v2.py:56–95`: compiler snapshots into private temporary build directories; package sources are not rewritten.
+
+## Geometry, units and initial state
+
+8×34 nodes: 8 periodic-x columns, 32 fluid rows, 2 ghost-wall rows. Relative to the bottom physical wall, fluid centers are y=0.5,...,31.5; physical halfway walls are y=0 and 32. Every x edge fluid node is explicitly FLUID; all top/bottom ghost nodes are SOLID|BC_WALL. Thus unused inlet/outlet configuration has no inlet/outlet flags to act on. There are no bodies, Jets or external forces.
+
+Lattice units: dx_LBM=dt_LBM=1, rho=1, nu=0.02, tau0=0.56, U=0.04, H=32. Initial u_x(y)=U sin(pi y/H), u_y=0. The maximum Mach number is 0.0693. Height-based Re=U H/nu=64; a wavelength-based Re would differ and is not used. No dimensional physical length/time/viscosity is asserted without a user-supplied unit mapping.
+
+Initialize equilibrium populations, encode shifted FP32, upload both DB buffers and set completed-count=1 following the existing integration-test adapter. That count is storage metadata: physical elapsed time starts at 0 after installation. Observe density and momentum directly from current postcollision populations, adding the descriptor weights in float64; do not mix in cached macro fields. This uses a clearly labeled validation-only raw state/flag adapter, not a promised public `set_periodic` or `set_velocity_profile` API.
+
+Cases: LES enabled/closed-form with Cs=0 (molecular control), Cs=.16 (ordinary-coefficient sanity), then Cs=1 (amplified normalization diagnostic). Cs=1 is intentionally not a physically recommended SGS coefficient. Initial peak modeled nu_t/nu = Cs² Δ² U(pi/H)/nu = 0.19635; estimated effective tau remains near 0.56–0.5718, far from omega guards. Standard default Cs=.16 yields a much weaker signal at these safe parameters and is not used to make a decisive short-run normalization claim. No defaults are changed.
+
+Observe at elapsed steps 519, 1038, 2075, approximately 0.1, 0.2, 0.4 molecular decay times. Three cases total 6225 measured advancing launches plus 3 warm-up launches per checkout (6228 total), three snapshots each. Population buffers contain only 272×9 FP32 entries each (about 9.6 KiB), apart from ordinary driver/compiler/context overhead. No frames, trajectories or heavy output. Full result JSON is a few tens of KiB. Runtime depends on compilation/device; no performance claim is made.
+
+## Independent continuum reference
+
+For u=(u(y),0), |S|=sqrt(2 S:S)=|du/dy|. Therefore
+
+    du/dt = d/dy [(nu + (Cs Delta)^2 |du/dy|) du/dy],
+    u(0,t)=u(H,t)=0.
+
+`tests/validation/les_flow_oracle.py` integrates this equation directly with centered finite-volume face fluxes and SSPRK2, at 128 and 256 cells on the same physical H=32 domain. Stability step size uses the nonlinear flux derivative nu+2(Cs Delta)^2|gradient|. Boundary face gradients use the zero Dirichlet value across a half cell. It does not import or reproduce the LBM quadratic/helper. A separate fixed-n=256 test halves the CFL factor from .4 to .2 for Cs=0,.16,1 at every checkpoint, requiring relative changes below 1e-8; measured maximum is 1.8141e-10. This isolates temporal error from the spatial-refinement test.
+
+Crucially the SGS filter Delta=1 stays fixed as the CPU oracle mesh changes from dy=.25 to .125. Confusing oracle spacing with filter width would change the PDE and invalidate convergence. Future LBM grid refinement also needs an explicit physical-unit/filter-width scaling contract; this artifact does not silently reinterpret Cs or Delta when resizing H.
+
+Cs=0 is checked directly against U sin(pi y/H) exp[-nu(pi/H)^2 t]. The nonlinear reference includes evolving higher harmonics, rather than assuming it remains a sine. At the final time, host oracle predicts 5.1706% SGS reduction in the fundamental amplitude and 1.5409% full-profile separation between standard and old coefficient conventions. The old convention reference is computed by changing continuum Cs to Cs/2^(1/4), purely as a diagnostic; it does not replace standard acceptance.
+
+## Predeclared criteria (do not tune after seeing GPU results)
+
+- Initial decoded profile relative L2 <= 1e-5; otherwise no advancing test.
+- Molecular Cs=0 profile error against analytic decay <= 0.003 at every checkpoint.
+- Cs=1 full-profile error against standard nonlinear oracle <= 0.005 at every checkpoint.
+- Oracle 128/256-grid interpolated relative difference <= 8e-5 at every checkpoint.
+- Relative error in SGS fundamental-amplitude decrement <= 0.15 at the last two checkpoints. Decrement is measured from actual Cs=0 amplitude minus actual Cs=1 amplitude; reference uses analytic Cs=0 minus the nonlinear oracle. The first checkpoint remains a transient diagnostic for this increment gate.
+- Fluid mean-density drift <= 5e-5, max |u_y| <= 1e-5 and x-column velocity spread <= 1e-6 at every checkpoint; finite populations, strictly positive finite fluid density and finite decoded velocity/profile/diagnostics required throughout observations, including startup and warm-up.
+
+Reasons: molecular 0.3% leaves room for finite-lattice dispersion, equilibrium-start kinetic transient and FP32 error at H=32; nonlinear 0.5% is substantially below the predicted 1.54% old-vs-standard separation. The 15% increment tolerance is below the old convention's approximately 29% viscosity-coefficient deficit, while allowing continuum/lattice differences. Directly subtracting the two measured amplitudes reduces common lattice error. Oracle convergence is over 60 times tighter than the nonlinear profile bound. These are declared engineering test gates, not GPU-validated uncertainty estimates; a failure requires diagnosis/refinement and an explicitly revised experiment, never a post-hoc tolerance edit to obtain a pass.
+
+Both baseline and candidate are judged against the same standard convention. Baseline is expected to fail SGS criteria if the flow reproduces the scalar finding; an exit 1 with valid evidence is useful. The runner reports old-convention profile error but never masks baseline failure. Candidate passing alone is insufficient if baseline does not demonstrate meaningful discrimination. Review both results and source pins together.
+
+## Host verification and later GPU commands
+
+From the repository root, using existing Python/NumPy and the existing pytest environment:
+
+    PYTHONDONTWRITEBYTECODE=1 PYTHONPATH=src python -m pytest -q tests/unit/test_les_flow_oracle.py tests/unit/test_les_flow_runner.py
+
+Nine tests cover analytic decay, independent-oracle mesh convergence, symmetry/positivity/energy decay, filter invariance, fixed-grid timestep halving, signal discrimination, invalid density/velocity rejection, source pins/candidate/tamper rejection and the no-GPU-without-opt-in CLI guard. The integrated tests preserve those checks. No PyCUDA import or GPU run is required for them. Cs=.16 uses the same 0.5% full-profile safety/sanity bound; its SGS increment is not a discriminatory normalization gate.
+
+The source-guard tests materialize temporary candidate headers with the existing reviewed LES preparation tool; the GPU entrypoint uses `tests/validation/run_uniform_les_flow.py`, `tests/validation/les_flow_oracle.py`, and `tests/validation/data/les_flow/source_pins.json` in that repository layout.
+
+After review, make isolated full baseline and corrected checkouts of the exact base. Apply only `tests/validation/les/data/smagorinsky_normalization.patch` to the corrected checkout; do not edit the benchmark/production tree. On authorized Horsea, with existing NumPy, PyCUDA, nvcc and driver, run sequentially and select the authorized physical GPU explicitly:
+
+    CUDA_VISIBLE_DEVICES=<physical-GPU> PYTHONDONTWRITEBYTECODE=1 python tests/validation/run_uniform_les_flow.py --run-gpu --device 0 --root <isolated-baseline> --variant baseline --output <new-evidence-dir>/baseline.json
+    CUDA_VISIBLE_DEVICES=<physical-GPU> PYTHONDONTWRITEBYTECODE=1 python tests/validation/run_uniform_les_flow.py --run-gpu --device 0 --root <isolated-corrected> --variant corrected --output <new-evidence-dir>/corrected.json
+
+`--device 0` is the logical ordinal within CUDA_VISIBLE_DEVICES. Do not use a shell `&&` between these: baseline's expected standard-criterion failure must not suppress the corrected run. Existing output files are refused. A JSON `READY` line is printed separately for each case only after source verification, compilation, initialization, raw-state installation, one actual advancing OneStep launch, post-warm-up macro validation, complete restoration of both DB buffers/flags/count to the initial state, profile readback and CUDA synchronization. It gives source identity, device, Cs, warm-up/reset confirmation, installed-profile error and maximum measured steps. This is the first trustworthy startup checkpoint, not a statement that the physics passed. `DONE` is printed after all three cases and all criteria; failures/compile errors before that remain incomplete runs.
+
+Deliver both JSON files and stdout/stderr with artifact hashes. Review before any production integration. AMR LES guards remain untouched.
+
+## Isolated candidate preparation
+
+Use the current validation commit for two separate full checkouts, preserving the baseline. In the corrected checkout only, apply `tests/validation/les/data/smagorinsky_normalization.patch` with `git apply`; do not commit that experimental production change or update the pins. The runner requires exactly the baseline bytes plus the reviewed helper hash. The header-only scalar diagnostic tree is insufficient for this end-to-end flow. Baseline and corrected commands must run as separate Python processes; package import caching must never combine their implementations. Both reject an imported CelerisLab package outside the explicitly supplied checkout, including an installed DynamisLab copy. Retain the actual checkout commit, variant, exact header hash, and experimental source label with each result.

docs/validation/viv_re150_predeclare.md

@@ -0,0 +1,155 @@
+# Single-cylinder free transverse VIV, Re 150 (Kolahdouz/Qin) — PREDECLARATION (agreed at 1abfe954)
+
+(File renamed from `leontini_viv_predeclare.md`; the Leontini Re 200 case is only the queued second case below.)
+
+Stage goal (Yanqi via TRON): prescribed Dütsch case + one VIV case both
+"reasonably close" to a predeclared reference = development-stage success, then
+cleanup. The frozen Dütsch settling failure (0/28 pairs at 31.25 T) stays on
+record. Practical closeness is not a formal validation claim. Agreed by
+Claude, Grok and Astra at 1abfe954; implemented in research/viv_re150/.
+
+## Primary case (one case)
+
+- Reference: Qin et al., arXiv:2003.12186, §4.5 (maximum amplitudes at
+  U_red = 3…8: .075, .551, .520, .459, .370, .084 D in the text, as quoted by
+  Grok/Astra) for the target; setup from Kolahdouz et al., arXiv:2003.12046,
+  §4.1.1 (read 2026-10-30 via ar5iv): U* sweep 3–8 with amplitudes only in
+  Fig. 3(b) (no text values), domain [−30, 45] D × [−30, 30] D with the
+  cylinder "initially at rest and centered at the origin", uniform inflow on
+  the left, zero normal traction and tangential velocity at the outlet, zero
+  normal velocity and tangential traction on y = ±30 D; no initial
+  perturbation and no total simulated time stated.
+- Re = 150, U* = U/(f_n D) = 5, m/(rho D²) = 2 (m* = rho_s/rho_f = 8/pi),
+  zeta = 0, f_n = sqrt(K/M)/(2 pi) in vacuum. Transverse DOF only.
+- Target: A_max = .520 D (peak amplitude, Qin §4.5). Multi-code reference
+  (Kolahdouz ILE-NS, Qin II-LBM). Reference uncertainty: not stated; the
+  spread between codes is not quantified here.
+
+## Our reproduction (declared differences)
+
+- D = 40, MRT, dense double buffer; U_lat = .04, nu = U D / 150 = .010667,
+  tau = .532.
+- Nominal 75 D × 60 D lattice allocation (3000 × 2400), based on the
+  Kolahdouz §4.1.1 layout. Coordinate clarification of the existing run:
+  the driver uses `(30 D, (ny - 1)/2)` = `(1200, 1199.5)` in lattice
+  coordinates, or `(30 D, 29.9875 D)`. The earlier `(30 D, 30 D)` wording
+  described the nominal box, not the exact executed centre.
+  Free-slip reflection planes are at `y = .5` and `y = ny - 1.5 = 2398.5`;
+  their separation is 2398 cells = 59.95 D, with the centre exactly midway,
+  29.975 D from each wall. Node counts are not physical wall-to-wall lengths.
+  This corrects the description, without changing the historical geometry
+  or results. Qin's own box ([0, 40 D] × [0, 20 D], centre (10 D, 10 D)) is
+  the target paper's, not ours.
+- Boundaries: uniform Zou–He inlet, NEQ outlet (rho = 1, backflow clamp),
+  free-slip y walls. Kolahdouz uses a traction outlet: declared mismatch.
+- Qin's own VIV box (40 D × 20 D) is not used; a smaller box would be a
+  declared cost cut with more blockage, not "the same case".
+- Allowed y offset ±1.5 D; peak transverse speed ≈ .026 cells/step (bound .5).
+
+## Structure, coupling and time levels
+
+- M = 2 rho D² (lattice rho = 1), f_n = U/(5 D) = 2e-4 per step, K = M (2 pi f_n)²,
+  zeta = 0. Equation of motion uses the structural mass only.
+- Per-step sequence (binding): known (y_n, v_n) and the last completed force
+  F_last → candidate (y_{n+1}, v_{n+1}) by the update below → `set_body` with
+  offset y_{n+1} and wall velocity (y_{n+1} − y_n)/dt with lattice dt = 1 (interval average; a
+  different quantity from the endpoint v_{n+1}) → `run(1)` → only on success:
+  commit y_n ← y_{n+1}, v_n ← v_{n+1}, F_last ← force read for that step (failure
+  semantics: see the window section). Whether the
+  measured force represents the interval's start, midpoint or end is not
+  asserted; the one-step lag is declared, not corrected.
+- Initial state: fluid initialized by `Simulation.initialize()` to the uniform
+  inlet velocity U everywhere (the code's actual initial condition; the
+  source gives no fluid initial condition), body at rest at the declared
+  centre, y_0 = v_0 = 0, F_last = 0.
+- Structural update over one step with constant force F = F_last (exact
+  harmonic solution, zeta = 0): y_e = F/K, w = 2 pi f_n,
+  y^{n+1} = y_e + (y^n − y_e) cos w + (v^n / w) sin w,
+  v^{n+1} = −(y^n − y_e) w sin w + v^n cos w.
+- Primary RHS (single coupled run): CME + Wen (theory-motivated stage choice:
+  Galilean-invariant link correction; G4 could not separate it from CME).
+  Raw CME and the node terms are logged as diagnostics of that trajectory;
+  the node impulse is not added. A run with CME-only as RHS is a separate,
+  labelled sensitivity case, decided separately. Neither RHS is claimed proven.
+
+## Window, failure semantics, acceptance (engineering, development stage)
+
+Clocks: lattice dt = 1; T_n = 1/f_n = 5,000 steps. Response cycles are
+counted from the measured signal; T_n is used only for the seed check.
+
+- Start: body at rest at the declared centre (the only initial condition the
+  source states), y_0 = v_0 = 0, F_last = 0; fluid uniform at U (as
+  initialized by the code; our choice, not the source's).
+- Seed (conditional, one time, declared): at step n_seed = 200,000
+  (t = 40 T_n), if max |y_t| over states t in [175,000, 200,000) is below
+  .01 D, then
+  in that step, after the check and before the candidate update, set
+  v_n += 2 pi f_n (.01 D) (F_last unchanged) and proceed normally; the
+  geometry moves continuously through the update. `seed_applied`, step and
+  size are logged; never repeated or changed.
+- Cycle boundary (discrete, fixed threshold): step n closes a cycle iff
+  y[n−1] < 0 and y[n] ≥ 0 (upward crossing of the equilibrium y = 0);
+  y_0 = 0 is not a crossing; no boundary fewer than 2 samples after the
+  previous one.
+- Per cycle: positive peak max(y), negative peak min(y), mean offset
+  (time-mean of y), amplitude a = (max − min)/2 (the only amplitude used for
+  settling).
+- Eligibility: a completed cycle is counted (toward the settling proof and
+  the 150 budget) only if a ≥ .01 D; ineligible cycles are logged, never
+  counted, so near-zero motion cannot settle or pass.
+- Seed reset: if the seed is applied, the incomplete cycle at n_seed is
+  discarded and the settling proof starts empty; the 150 budget and the
+  native cap keep running from t = 0.
+- Windows: adjacent non-overlapping blocks of 10 counted cycles;
+  W_k = mean amplitude of block k (W_k ≥ .01 D by eligibility, so no zero
+  denominator).
+- Block rule R(k), k ≥ 2: |W_k − W_{k−1}| / W_{k−1} ≤ .02 and, for the last 5
+  cycles of block k, max_i |a_i − ā_5| / ā_5 ≤ .01 with ā_5 their mean.
+- Settled at the end of block k when R(k) holds. Scoring = the next two
+  blocks k+1, k+2 (20 counted cycles); both must satisfy R. If one fails,
+  that block becomes the new reference: the settling proof restarts from it
+  and continues within the caps (deterministic; no other retry). A pass
+  requires one complete stable 20-cycle scoring window before a cap; success
+  stops after its 20th cycle.
+- Caps (both always armed; the first hit wins and is reported): 150 counted
+  response cycles including the 20 scoring cycles (so settling must complete
+  by counted cycle 130) → `timeout_response_cycles`; 1,000,000 native steps
+  (200 T_n) → `timeout_native_steps`.
+- Durations reported: total steps, t U/D, counted and uncounted cycles,
+  measured T_resp (mean boundary interval); N_resp / f_n only as a labelled
+  secondary clock.
+- Growth is not a failure: initial VIV growth is physical. Checked every
+  step (FAIL-CLOSED): non-finite y, v or force; |y| > 1.0 D (the tighter
+  gate; about twice the largest reference peak, .551 D) or the ±1.5 D offset
+  box reached; no_donor > 0; a failed upload/step/sync.
+- On any failure the driver stops and reports; it never retries,
+  sub-iterates, retunes the RHS or parameters, or starts a second case.
+  Device-side failures (upload/step/sync, no_donor) mark the Simulation
+  failed through the existing lifecycle; input rejection by `set_body`
+  (offset box, speed, step bound) and timeouts end the driver run without
+  that mark.
+- Target metric over the 20 scoring cycles: A_max/D = max over those cycles
+  of max(|positive peak|, |negative peak|) about y = 0 (Qin reports "maximum
+  amplitude"); also reported: mean amplitude, positive and negative peaks,
+  mean offset, f/f_n (no target).
+- Acceptance: |A_max − .520 D| ≤ .052 D (±10 %), stated together with the
+  boundary mismatch and the absence of a quoted reference uncertainty. A pass
+  is "reasonably close" for the stage: not grid convergence, not force-RHS
+  validation, and it does not touch the Dütsch settling record.
+- Driver reads force and the small diagnostics per step only; field reads
+  only at a few predeclared snapshots. No runtime claim: there is no measured
+  timing on this grid yet (the D40/60D receipt is a different, sampled case).
+
+## Plumbing smoke (not the benchmark)
+
+`run.py --smoke --D 20 --steps 32` runs exactly 32 steps of the same BC
+package and coupling loop (no seed, settle or score; never scored);
+status `smoke_ok` iff every step is finite, no_donor stays 0 and the body
+stays inside its box. The physical case is only the default invocation
+(`--D 40`, no `--smoke`).
+
+## Queued, not in this stage
+
+Leontini et al. JFS 22 (2006) Re = 200, m* = 10, zeta = 0.01, U* = 5.0 (needs
+the owners' c_crit convention and a Fig. 1 digitization). D80, literature
+claims, pinball, AMR, BC redesign, threshold changes.

examples/fixed_patch_circle.py

@@ -0,0 +1,123 @@
+"""Public API demo: fixed 2:1 patch with a stationary, optionally actuated circle.
+
+From this checkout, after checking the selected physical GPU is idle:
+    PYTHONPATH="$PWD/src" CUDA_VISIBLE_DEVICES=0 python examples/fixed_patch_circle.py
+    ... --speed -0.002 --mode slot_reservoir
+Both levels use blocked storage (--base-block, --fine-block tiles).
+
+A short smoke run (default 128 coarse steps): it shows setup, stepping and
+fluid-only diagnostics, not a developed flow, accuracy or long-time stability.
+Normal blowing/suction injects/extracts mass, so leaf mass is expected to change.
+No files, plots or checkpoints are written.
+"""
+import argparse
+from pathlib import Path
+
+import numpy as np
+
+import CelerisLab
+from CelerisLab.body.geometry.circle import CircleGeometry
+from CelerisLab.body.objects import SimObject, SurfaceActuation
+from CelerisLab.config import LBMConfig
+from CelerisLab.cuda.context import CudaContext
+from CelerisLab.lbm.descriptors import D2Q9_EX, D2Q9_EY, SOLID
+from CelerisLab.lbm.equilibrium import compute_feq_d2q9
+from CelerisLab.lbm.refinement import ACTIVE
+from CelerisLab.lbm.refinement_stepper import FixedPatchStepper
+
+NX, NY, BOUNDS = 32, 24, (8, 6, 24, 18)  # coarse cells; patch is half-open (x0, y0, x1, y1)
+CENTER, RADIUS = (16.0, 12.0), 2.15       # coarse CELL-EDGE frame: cell I spans [I, I+1)
+
+
+def config(mode):
+    if mode == "periodic":  # x and y periodic coarse level
+        return LBMConfig(nx=NX, ny=NY, viscosity=.1)
+    # Bottom on-site velocity slot, top fixed-density reservoir, x periodic.
+    return LBMConfig(nx=NX, ny=NY, viscosity=.1, velocity=0, wall_normal_velocity=.001,
+                     wall_slot_width=8, y_wall_bc="on_site_velocity", top_wall_bc="reservoir")
+
+
+def leaf_masks(run, mode):
+    """Known fluid leaves: uncovered coarse cells (minus wall rows in slot mode)
+    and fine ACTIVE cells outside the body."""
+    p = run.hierarchy.pairs[0]
+    x0, y0, x1, y1 = p.bounds
+    coarse = np.ones(p.coarse_shape, bool)
+    coarse[y0:y1, x0:x1] = False
+    if mode == "slot_reservoir":
+        coarse[[0, -1]] = False
+    solid = (run.boundaries[1].flags.reshape(p.fine_shape) & SOLID) != 0
+    return coarse, (p.fine_kind == ACTIVE) & ~solid
+
+
+def leaf_diagnostics(coarse, fine, masks):
+    """Fluid leaves only; a non-finite population or rho <= 0 there is an error.
+
+    Mass counts a fine cell as 1/4 of a coarse cell (2D, 2:1)."""
+    out = {}
+    for name, g, leaf, area in (("coarse", coarse, masks[0], 1.0), ("fine", fine, masks[1], .25)):
+        f = g[:, leaf].astype(np.float64)
+        rho = f.sum(axis=0)
+        if not np.isfinite(f).all() or (rho <= 0).any():
+            raise RuntimeError(f"non-finite population or non-positive density on a {name} fluid leaf")
+        ux = (np.array(D2Q9_EX)[:, None] * f).sum(axis=0) / rho
+        uy = (np.array(D2Q9_EY)[:, None] * f).sum(axis=0) / rho
+        out[name] = (area * rho.sum(), rho.min(), rho.max(), np.hypot(ux, uy).max())
+    return out
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("--mode", choices=("periodic", "slot_reservoir"), default="periodic")
+    parser.add_argument("--speed", type=float, default=.002,
+                        help="normal surface velocity, coarse lattice units (+ blows, - sucks, 0 passive)")
+    parser.add_argument("--base-block", type=int, nargs=2, metavar=("BY", "BX"), default=(12, 8),
+                        help="root tile; must divide the 24 x 32 root")
+    parser.add_argument("--fine-block", type=int, nargs=2, metavar=("BY", "BX"), default=(16, 20),
+                        help="fine tile; must divide the whole fine allocation (32 x 40 here)")
+    parser.add_argument("--steps", type=int, default=128)
+    args = parser.parse_args()
+    if args.steps < 0:
+        parser.error("--steps must be nonnegative")
+    root = Path(__file__).resolve().parents[1]
+    if Path(CelerisLab.__file__).resolve() != root / "src/CelerisLab/__init__.py":
+        raise RuntimeError(f"Set PYTHONPATH to {root / 'src'}")
+
+    # Aperture centred at angle 0.7 rad, half-width 0.85 rad (the tested fixture).
+    spec = SurfaceActuation(0.7, 0.85, args.speed) if args.speed else None
+    body = SimObject(0, geometry=CircleGeometry(*CENTER, RADIUS), center=CENTER, radius=RADIUS,
+                     surface_actuation=spec)
+    cfg = config(args.mode)
+    # The caller owns the CUDA context; the stepper must be closed first (the
+    # nested with-statement does that).
+    with CudaContext(0) as context, FixedPatchStepper(
+            cfg, context=context, coarse_boundary=args.mode, refinements=[BOUNDS],
+            level_blocks=[tuple(args.base_block), tuple(args.fine_block)],
+            level_objects=[(), (body,)]) as run:
+        p = run.hierarchy.pairs[0]
+        # Rest equilibrium is already postcollision G, so no initial collision is
+        # needed. Non-leaf entries (covered, ghost, solid) are discarded by initialize.
+        rest = np.asarray(compute_feq_d2q9(1.0, 0.0, 0.0), np.float32)[:, None, None]
+        run.initialize(np.broadcast_to(rest, (9, *p.coarse_shape)),
+                       np.broadcast_to(rest, (9, *p.fine_shape)))
+        storage = f"blocked root {tuple(args.base_block)} fine {tuple(args.fine_block)}"
+        print(f"mode={args.mode} storage={storage} speed={args.speed:+g} "
+              f"(fine allocation {p.fine_shape[0]}x{p.fine_shape[1]}, fine origin {p.fine_origin})")
+        masks = leaf_masks(run, args.mode)
+        start = leaf_diagnostics(*run.download(), masks)
+        for _ in range(0, args.steps, 32):
+            run.step(min(32, args.steps - run.step_count))
+            coarse, fine = run.download()  # synchronized postcollision G, NaN on non-leaves
+            d = leaf_diagnostics(coarse, fine, masks)
+            mass = d["coarse"][0] + d["fine"][0]
+            rho_lo = min(d["coarse"][1], d["fine"][1])
+            rho_hi = max(d["coarse"][2], d["fine"][2])
+            speed = max(d["coarse"][3], d["fine"][3])
+            print(f"coarse step {run.step_count:4d}: leaf mass {mass:.9f} "
+                  f"(change {mass - start['coarse'][0] - start['fine'][0]:+.3e}) "
+                  f"rho [{rho_lo:.6f}, {rho_hi:.6f}] max |u| {speed:.3e}")
+        print("smoke run only: storage/stepping demonstration, not accuracy or stability evidence")
+
+
+if __name__ == "__main__":
+    main()

examples/fixed_patch_jet.py

@@ -0,0 +1,206 @@
+"""Low-Re startup flow in an x-periodic confined domain; nozzle remains coarse.
+
+From this checkout, after checking the selected physical GPU is idle:
+  PYTHONPATH="$PWD/src" CUDA_VISIBLE_DEVICES=0 python examples/fixed_patch_jet.py --output /tmp/patch-jet
+
+The fixed-amplitude start includes acoustic transients, not a developed jet.
+Only native leaf cells are plotted. No interpolation, restart or flow oracle.
+Scale estimates use the continuous peak A=.02, not inlet mean speed: W/A=600,
+H/A=2250, W**2/nu=1440, H**2/nu=20250, where H=NY-3=45 between on-site planes.
+An acoustic crossing (~78 steps) does not imply that transients have disappeared.
+Mach is sampled over all leaves every 50 steps and is usually inlet dominated;
+the discrete inlet peak is slightly below continuous A. This is not an accuracy test.
+The 120s checks are cooperative, not an exact interruption deadline. main elapsed
+includes construction, advancement and plotting; it is not pure CFD timing.
+"""
+import argparse
+from dataclasses import replace
+import json
+import os
+from pathlib import Path
+import tempfile
+import time
+
+import numpy as np
+
+import CelerisLab
+from CelerisLab.config import load_lbm_config
+from CelerisLab.cuda.context import CudaContext
+from CelerisLab.lbm.equilibrium import compute_feq_d2q9, compute_macro_from_ddf
+from CelerisLab.lbm.refinement import ACTIVE
+from CelerisLab.lbm.refinement_stepper import FixedPatchStepper
+
+BOUNDS, AMPLITUDE, WIDTH = (16, 4, 32, 28), .02, 12
+LEVEL_BLOCKS = [(12, 8), (8, 8)]  # blocked storage: 48x48 root, 56x40 fine window
+TIMES, MAX_MACH, MAX_SECONDS = (0, 300, 1200), .1, 120
+
+
+def measure(arrays, masks, centers, initial_mass):
+    fields = []
+    for array, mask in zip(arrays, masks):
+        if not np.isfinite(array[:, mask]).all():
+            raise RuntimeError("Nonfinite leaf populations")
+        field = np.full((*mask.shape, 3), np.nan)
+        field[mask] = [compute_macro_from_ddf(f) for f in array[:, mask].T]
+        fields.append(field)
+    leaves = np.concatenate([f[m] for f, m in zip(fields, masks)])
+    speed = np.hypot(leaves[:, 1], leaves[:, 2])
+    mass = sum(area*a[:, m].sum(dtype=np.float64)
+               for area, a, m in zip((1, .25), arrays, masks))
+    record = dict(finite=bool(np.isfinite(leaves).all()), rho_min=float(leaves[:, 0].min()),
+                  rho_max=float(leaves[:, 0].max()), speed_max=float(speed.max()),
+                  sampled_max_Mach=float(speed.max()*np.sqrt(3)),
+                  density_deviation=float(np.abs(leaves[:, 0]-1).max()),
+                  discrete_leaf_mass=float(mass), mass_change=float(mass-initial_mass))
+    if not record['finite'] or record['rho_min'] <= 0 or record['sampled_max_Mach'] > MAX_MACH:
+        raise RuntimeError(f"Finite/positive-density/Ma<={MAX_MACH} guard failed: {record}")
+    walls = fields[0][[1, -2]]
+    record['macro_sum_rho_v'] = dict(zip(('Q_in', 'Q_out'),
+                                       (walls[:, :, 0]*walls[:, :, 2]).sum(axis=1).tolist()))
+    record['centerline'] = []
+    for level, y in ((1, 16.25), (0, 32.5)):
+        xs, ys = centers[level]
+        columns = np.argsort(np.abs(xs-24))[:2]
+        row = int(np.flatnonzero(ys == y)[0])
+        values = fields[level][row, columns].mean(axis=0)
+        record['centerline'].append(dict(level=level, x=24, y=y,
+            sampled_x=sorted(xs[columns].tolist()), rule='arithmetic mean of two neighboring native columns',
+            rho_ux_uy=values.tolist()))
+    return fields, record
+
+
+def draw(out, snapshots, masks, centers):
+    import matplotlib
+    matplotlib.use('Agg')
+    import matplotlib.pyplot as plt
+    from matplotlib.collections import PolyCollection
+
+    def decorate(ax):
+        ax.set(xlim=(0, 48), ylim=(1.5, 46.5), aspect='equal', xlabel='X', ylabel='Y')
+        ax.plot([16, 32, 32, 16, 16], [4, 4, 28, 28, 4], color='tab:red', lw=1)
+        ax.axhline(1.5, color='black', lw=1)
+        ax.axhline(46.5, color='black', lw=1, ls='--')
+        ax.plot([18, 30], [1.5, 1.5], color='tab:orange', lw=4, clip_on=False)
+
+    fig, ax = plt.subplots(figsize=(6, 6), constrained_layout=True)
+    for mask, (xs, ys), dx in zip(masks, centers, (1, .5)):
+        yy, xx = np.meshgrid(ys, xs, indexing='ij')
+        cells = np.stack((xx[mask], yy[mask]), axis=-1)
+        vertices = cells[:, None, :] + dx*np.array([[-.5, -.5], [.5, -.5], [.5, .5], [-.5, .5]])
+        ax.add_collection(PolyCollection(vertices, facecolors='none', edgecolors='0.55', linewidths=.3))
+    decorate(ax)
+    ax.set_title('Native leaf grid: coarse dx=1, fine dx=0.5\n'
+                 'Red: internal patch; orange: coarse slot; dashed: reservoir\n'
+                 'Flow may cross patch sides; patch does not contain all startup flow', fontsize=10)
+    fig.savefig(out/'layout.png', dpi=150, bbox_inches='tight', pad_inches=.15)
+    plt.close(fig)
+    vmax = max(1., *(np.nanmax(np.hypot(f[..., 1], f[..., 2]))/AMPLITUDE
+                    for fields in snapshots for f in fields))
+    fig, axes = plt.subplots(1, 3, figsize=(12, 4.8), constrained_layout=True)
+    for ax, step, fields in zip(axes, TIMES, snapshots):
+        for field, mask, (xs, ys), dx in zip(fields, masks, centers, (1, .5)):
+            speed = np.ma.masked_where(~mask, np.hypot(field[..., 1], field[..., 2])/AMPLITUDE)
+            image = ax.pcolormesh(np.r_[xs-dx/2, xs[-1]+dx/2],
+                                 np.r_[ys-dx/2, ys[-1]+dx/2], speed,
+                                 shading='flat', cmap='viridis', vmin=0, vmax=vmax, rasterized=True)
+            stride = int(4/dx)
+            yy, xx = np.meshgrid(ys, xs, indexing='ij')
+            selection = np.zeros_like(mask)
+            selection[::stride, ::stride] = mask[::stride, ::stride]
+            ax.quiver(xx[selection], yy[selection], field[..., 1][selection], field[..., 2][selection],
+                      angles='xy', scale_units='xy', scale=AMPLITUDE/3, width=.005, color='white')
+        decorate(ax)
+        ax.set_title(f'coarse t={step}, fine steps={2*step}')
+    fig.colorbar(image, ax=axes, label='speed / imposed amplitude')
+    fig.suptitle('Low-Re startup flow in an x-periodic confined domain\n'
+                 'Fixed-amplitude start includes acoustic transients; not steady/developed\n'
+                 'Nozzle remains coarse; flow may cross patch sides (not fully enclosed)', fontsize=11)
+    fig.savefig(out/'velocity.png', dpi=150)
+    plt.close(fig)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--output', type=Path, required=True)
+    out = parser.parse_args().output.resolve()
+    root = Path(__file__).resolve().parents[1]
+    if Path(CelerisLab.__file__).resolve() != root/'src/CelerisLab/__init__.py':
+        raise RuntimeError(f'Set PYTHONPATH to {root / "src"}')
+    out.mkdir(parents=True, exist_ok=False)
+    cfg = replace(load_lbm_config(str(root/'src/CelerisLab/configs/config_lbm.json')),
+                  nx=48, ny=48, viscosity=.1, velocity=0., rho=1., wall_slot_width=WIDTH,
+                  wall_normal_velocity=AMPLITUDE, y_wall_bc='on_site_velocity', top_wall_bc='reservoir',
+                  lattice_model='D2Q9', collision='SRT', streaming='double_buffer',
+                  store_precision='FP32', ddf_shifting=False, les_enabled=False)
+    report = dict(config=dict(nx=48, ny=48, bounds=BOUNDS, W=WIDTH, A=AMPLITUDE, nu=.1,
+                              rho=1, tau_coarse=.8, tau_fine=1.1, coarse_boundary='slot_reservoir',
+                              level_blocks=LEVEL_BLOCKS),
+                  guards=dict(check_every=50, positive_density=True, finite=True,
+                              max_Mach=MAX_MACH, max_seconds=MAX_SECONDS,
+                              timing='cooperative checks, not an exact interruption deadline'),
+                  scale_estimates=dict(velocity_basis='continuous peak A, not inlet mean', H=cfg.ny-3,
+                      W_over_A=WIDTH/AMPLITUDE, H_over_A=(cfg.ny-3)/AMPLITUDE,
+                      W_squared_over_nu=WIDTH**2/cfg.viscosity,
+                      H_squared_over_nu=(cfg.ny-3)**2/cfg.viscosity,
+                      acoustic_crossing=(cfg.ny-3)*np.sqrt(3)),
+                  notes='Node mass uses areas 1 and 1/4, not an exact physical volume integral. '
+                        'Q_in/Q_out are bottom/top macro sum(rho*vy), not a closed population budget. '
+                        'Mach maxima are sampled every 50 steps, not every-step peaks. '
+                        'One acoustic crossing does not imply transient decay; no steady-state claim.',
+                  samples=[], status='running', last_synchronized_coarse_step=0)
+    start, run = time.monotonic(), None
+    try:
+        with CudaContext(0) as context, FixedPatchStepper(cfg, context=context,
+                coarse_boundary='slot_reservoir', refinements=[BOUNDS],
+                level_blocks=LEVEL_BLOCKS) as run:
+            p = run.hierarchy.pairs[0]
+            masks = [np.ones(p.coarse_shape, bool), p.fine_kind == ACTIVE]
+            masks[0][[0, -1]] = False
+            masks[0][4:28, 16:32] = False
+            centers = [(origin[0]+dx*(np.arange(shape[1])+.5),
+                        origin[1]+dx*(np.arange(shape[0])+.5))
+                       for shape, origin, dx in ((p.coarse_shape, (0, 0), 1),
+                                                 (p.fine_shape, p.fine_origin, .5))]
+            initial = [np.broadcast_to(compute_feq_d2q9(1., 0., 0.)[:, None, None], (9, *m.shape)).copy()
+                       for m in masks]
+            for x in range(cfg.nx):
+                v = AMPLITUDE*max(0., 1-((2*x-(cfg.nx-1))/WIDTH)**2)**2
+                initial[0][:, 1, x] = compute_feq_d2q9(1., 0., v)
+            run.initialize(*initial)
+            mass0 = sum(area*a[:, m].sum(dtype=np.float64)
+                        for area, a, m in zip((1, .25), initial, masks))
+            snapshots = []
+            for step in range(0, TIMES[-1]+1, 50):
+                if time.monotonic()-start > MAX_SECONDS:
+                    raise TimeoutError('120 second demonstration limit reached')
+                if step:
+                    run.step(50)
+                report['last_synchronized_coarse_step'] = run.step_count
+                if time.monotonic()-start > MAX_SECONDS:
+                    raise TimeoutError('120 second demonstration limit reached after chunk')
+                fields, sample = measure(run.download(), masks, centers, mass0)
+                sample.update(t=step, coarse_steps=step, fine_steps=2*step)
+                report['samples'].append(sample)
+                print(json.dumps(sample), flush=True)
+                if step in TIMES:
+                    snapshots.append(fields)
+        with tempfile.TemporaryDirectory(prefix='.plot-', dir=out) as cache:
+            os.environ['MPLCONFIGDIR'] = cache
+            draw(out, snapshots, masks, centers)
+        if time.monotonic()-start > MAX_SECONDS:
+            raise TimeoutError('120 second demonstration limit reached after plotting')
+        report['status'] = 'complete'
+    except BaseException as exc:
+        report.update(status='failed', error=f'{type(exc).__name__}: {exc}',
+                      last_synchronized_coarse_step=run.step_count if run is not None else 0)
+        raise
+    finally:
+        report['elapsed_seconds'] = time.monotonic()-start
+        report['elapsed_scope'] = 'main construction, advancement and plotting; not pure CFD time'
+        (out/'summary.json').write_text(json.dumps(report, indent=2)+'\n')
+        print(f'{report["status"]}: last synchronized coarse step '
+              f'{report["last_synchronized_coarse_step"]}; output={out}', flush=True)
+
+
+if __name__ == '__main__':
+    main()

examples/fixed_periodic_patch.py

@@ -0,0 +1,77 @@
+"""Public API demo: small periodic shear, one fixed 2:1 patch, eight coarse steps.
+
+From this checkout, after checking the selected physical GPU is idle:
+    PYTHONPATH="$PWD/src" CUDA_VISIBLE_DEVICES=0 python examples/fixed_periodic_patch.py
+
+This demonstrates initialization/stepping/leaf output, not interface accuracy.
+There are no walls, objects, forces, checkpoint files or plots.
+"""
+from dataclasses import replace
+from pathlib import Path
+
+import numpy as np
+
+import CelerisLab
+from CelerisLab.config import load_lbm_config
+from CelerisLab.cuda.context import CudaContext
+from CelerisLab.lbm.equilibrium import compute_feq_d2q9, compute_macro_from_ddf
+from CelerisLab.lbm.refinement import ACTIVE
+from CelerisLab.lbm.refinement_stepper import FixedPatchStepper
+
+
+def shear_equilibrium(shape, origin, dx, period):
+    """Sample ux(y)=1e-3*sin(2*pi*y/period) at physical cell centers.
+
+    Centers are origin + dx*(index+.5); this shear is independent of x.
+    Fine origin includes patch offset AND the four-cell halo, with dx=.5.
+    Equilibrium is already postcollision G, so no initial collision is needed.
+    """
+    y = origin[1] + dx * (np.arange(shape[0]) + .5)
+    ux = 1e-3 * np.sin(2*np.pi*y/period)
+    rows = np.stack([compute_feq_d2q9(1.0, float(u), 0.0) for u in ux], axis=1)
+    return np.repeat(rows[:, :, None], shape[1], axis=2)
+
+
+def leaf_summary(coarse, fine, coarse_leaf, fine_leaf):
+    """Use the same leaf masks/areas for initial and final mass."""
+    c, f = coarse[:, coarse_leaf], fine[:, fine_leaf]
+    mass = c.sum(dtype=np.float64) + .25*f.sum(dtype=np.float64)
+    macros = np.array([compute_macro_from_ddf(v) for v in np.concatenate((c, f), axis=1).T])
+    return mass, macros.min(axis=0), macros.max(axis=0)
+
+
+def main():
+    root = Path(__file__).resolve().parents[1]
+    if Path(CelerisLab.__file__).resolve() != root / "src/CelerisLab/__init__.py":
+        raise RuntimeError(f"Set PYTHONPATH to {root / 'src'}")
+    cfg = replace(load_lbm_config(str(root / "src/CelerisLab/configs/config_lbm.json")),
+                  nx=16, ny=16, viscosity=.1, velocity=1e-3, rho=1.0,
+                  lattice_model="D2Q9", collision="SRT", streaming="double_buffer",
+                  store_precision="FP32", ddf_shifting=False, les_enabled=False)
+    with CudaContext(0) as context, FixedPatchStepper(cfg, context=context, refinements=[(4, 4, 12, 12)],
+                                                           level_blocks=[(16, 16), (24, 24)]) as run:
+        p = run.hierarchy.pairs[0]
+        coarse = shear_equilibrium(p.coarse_shape, (0, 0), 1.0, cfg.ny)
+        fine = shear_equilibrium(p.fine_shape, p.fine_origin, .5, cfg.ny)
+        coarse_leaf = np.ones(p.coarse_shape, dtype=bool)
+        x0, y0, x1, y1 = p.bounds
+        coarse_leaf[y0:y1, x0:x1] = False
+        fine_leaf = p.fine_kind == ACTIVE
+        coarse[:, ~coarse_leaf] = np.nan
+        fine[:, ~fine_leaf] = np.nan
+        run.initialize(coarse, fine)
+        initial_mass, _, _ = leaf_summary(*run.download(), coarse_leaf, fine_leaf)
+        run.step(8)
+        coarse, fine = run.download()  # Both levels synchronized, stored postcollision G.
+        assert np.isnan(coarse[:, ~coarse_leaf]).all() and np.isnan(fine[:, ~fine_leaf]).all()
+        assert np.isfinite(coarse[:, coarse_leaf]).all() and np.isfinite(fine[:, fine_leaf]).all()
+        mass, low, high = leaf_summary(coarse, fine, coarse_leaf, fine_leaf)
+        print(f"periodic patch API demo: synchronized coarse_steps={run.step_count}, fine_steps={2*run.step_count}")
+        print(f"leaf mass: initial={initial_mass:.12g} final={mass:.12g} drift={mass-initial_mass:+.6e}")
+        for name, lo, hi in zip(("rho", "ux", "uy"), low, high):
+            print(f"leaf {name}: [{lo:.9g}, {hi:.9g}]")
+        print("covered coarse / fine halo: NaN; functional demonstration only")
+
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -7,7 +7,7 @@ name = "CelerisLab"
 version = "0.5.1"
 description = "GPU-accelerated Lattice Boltzmann Method (LBM) CFD solver using CUDA"
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 license = {text = "MIT"}
 authors = [
     {name = "Frank14f"}
@@ -19,8 +19,6 @@ classifiers = [
     "Topic :: Scientific/Engineering :: Physics",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
 ]

research/duetsch_re100_kc5/analyze.py

@@ -0,0 +1,224 @@
+"""Ledger, settling, common window and Morison fits for Dütsch cases (numpy only).
+
+    python analyze.py CASE_DIR [CASE_DIR ...]   # cases of one comparison
+"""
+from __future__ import annotations
+
+import json
+import math
+import os
+import sys
+
+import numpy as np
+
+import protocol as p
+
+
+def load(path):
+    with open(os.path.join(path, "case.json")) as fh:
+        case = json.load(fh)
+    raw = np.load(os.path.join(path, "raw.npz"))
+    case.update(force=raw["force"], diag=raw["diag"], samples=raw["samples"], path=path)
+    return case
+
+
+def cycle_slices(case):
+    """{k: slice of step indices m whose interval [m, m+1] lies in paper cycle k}."""
+    T, q = case["T"], case["T"] // 4
+    return {k: slice(q + (k - 1) * T, q + k * T)
+            for k in range(1, case["cycles"] + 1) if q + k * T <= len(case["force"])}
+
+
+def coarse_wave(case, k, r=1):
+    """Normalized per-step Fx of cycle k, averaged over r native steps per sample."""
+    f = case["force"][cycle_slices(case)[k], 0] / case["F_ref"]
+    return f.reshape(-1, r).mean(axis=1)
+
+
+def profiles(case, k):
+    """{(phase, station, x2): (u, v)} of cycle k, time-averaged over the bin steps
+    (equal weights per step) from valid samples only."""
+    s = case["samples"]
+    acc = {}
+    for _, _, ph, xs, x2, u, v, _ in s[s[:, 1] == k]:
+        if not (math.isnan(u) or math.isnan(v)):
+            acc.setdefault((ph, xs, x2), []).append((u, v))
+    return {key: tuple(np.mean(vals, axis=0)) for key, vals in acc.items()}
+
+
+def coverage(case, k):
+    s = case["samples"]
+    rows = s[s[:, 1] == k]
+    missing = int(np.isnan(rows[:, 5]).sum())
+    return dict(samples=len(rows), missing=missing, bin_steps=len(set(rows[:, 0])),
+                min_fluid_weight=float(np.nanmin(np.where(rows[:, 7] > 0, rows[:, 7], np.nan)))
+                if len(rows) else math.nan)
+
+
+def common_points(dicts):
+    keys = set(dicts[0])
+    for d in dicts[1:]:
+        keys &= set(d)
+    return sorted(keys)
+
+
+def candidates(case):
+    """Per-step Fx of each reported force candidate (none is selected as an RHS)."""
+    d = case["diag"]
+    return {"cme": d[:, 0], "cme_wen": d[:, 0] + d[:, 2], "cme_node": d[:, 0] + d[:, 6] - d[:, 9]}
+
+
+def cycle_morison(case, ks, fx=None):
+    T = case["T"]
+    fx = case["force"][:, 0] if fx is None else fx
+    idx = np.concatenate([np.arange(len(fx))[cycle_slices(case)[k]] for k in ks])
+    b = np.array([p.interval_bases(int(m), T) for m in idx])
+    return p.morison_fit(fx[idx] / case["F_ref"], b[:, 0], b[:, 1])
+
+
+def pair_metrics(case, k):
+    a, b = coarse_wave(case, k - 1), coarse_wave(case, k)
+    pa, pb = profiles(case, k - 1), profiles(case, k)
+    common = common_points([pa, pb])  # empty set -> inf -> pair fails (FAIL-CLOSED)
+    prof = max((max(abs(pa[c][0] - pb[c][0]), abs(pa[c][1] - pb[c][1])) for c in common),
+               default=math.inf) / case["u_max"]
+    (cd0, ci0), (cd1, ci1) = cycle_morison(case, [k - 1]), cycle_morison(case, [k])
+    m = dict(wave=float(np.sqrt(np.mean((b - a) ** 2))),
+             scalar=float(max(abs(b.mean() - a.mean()), abs(np.sqrt(np.mean(b * b)) - np.sqrt(np.mean(a * a))),
+                              abs(np.abs(b).max() - np.abs(a).max()))),
+             profile=float(prof), morison=float(max(abs(cd1 - cd0), abs(ci1 - ci0))),
+             profile_points=len(common))
+    m["pass"] = all(m[key] <= tol for key, tol in p.SETTLE.items())
+    return m
+
+
+def hf_component(case, ks):
+    """Unqualified phase-locked high-frequency force component (reported, not checked):
+    mean CME waveform over cycles ks minus its two-basis Morison reconstruction,
+    split at 20/T; cycle differencing does not remove it."""
+    T = case["T"]
+    if not ks:
+        return dict(label="unqualified phase-locked HF force component, not checked", cycles=[])
+    mean = np.mean([coarse_wave(case, k) for k in ks], axis=0)
+    c_d, c_i = cycle_morison(case, ks)
+    q = T // 4
+    b = np.array([p.interval_bases(q + m, T) for m in range(T)])
+    resid = mean - (c_d * b[:, 0] - (np.pi ** 2 * c_i / p.KC) * b[:, 1])
+    spec = np.fft.rfft(resid)
+    high = spec.copy()
+    high[:21] = 0.0
+    energy = one_sided_energy(spec, T)
+    return dict(label="unqualified phase-locked HF force component, not checked",
+                cycles=list(ks), hf_rms_over_F_ref=float(np.sqrt(np.mean(np.fft.irfft(high, T) ** 2))),
+                hf_energy_fraction=float(energy[21:].sum() / max(energy.sum(), 1e-300)),
+                top_harmonics=[int(j) for j in np.argsort(energy[21:])[::-1][:5] + 21])
+
+
+def one_sided_energy(spec, n):
+    """Parseval-consistent energy per rfft bin: interior bins count twice, DC and
+    (for even n) Nyquist once."""
+    w = np.full(len(spec), 2.0)
+    w[0] = 1.0
+    if n % 2 == 0:
+        w[-1] = 1.0
+    return w * np.abs(spec) ** 2
+
+
+def ledger(case, horizon=p.LAST_SCORED):
+    ks = [k for k in sorted(cycle_slices(case)) if k <= horizon]
+    pairs = {k: pair_metrics(case, k) for k in ks if k - 1 > p.DISCARD}
+    return pairs, p.settled_start({k: v["pass"] for k, v in pairs.items()})
+
+
+def main(argv):
+    """argv: CASE_DIR ... [--reference CASE_DIR]; the reference defaults to the
+    largest D (resolution ladder); domain runs name the 60 D case explicitly."""
+    ref_path = None
+    if "--reference" in argv:
+        i = argv.index("--reference")
+        ref_path, argv = argv[i + 1], argv[:i] + argv[i + 2:]
+    horizon, explicit = p.LAST_SCORED, "--horizon" in argv  # default: original scoring
+    if explicit:
+        i = argv.index("--horizon")
+        horizon, argv = int(argv[i + 1]), argv[:i] + argv[i + 2:]
+    paths = argv if ref_path is None or ref_path in argv else argv + [ref_path]
+    cases = [load(path) for path in paths]
+    for c in cases if explicit else ():  # complete cycles 1..N; never pad or shift
+        if c["cycles"] < horizon or len(c["force"]) < round((0.25 + horizon) * c["T"]):
+            raise SystemExit(f"{c['path']}: run does not contain complete cycles 1..{horizon}")
+    ledgers = [ledger(c, horizon) for c in cases]
+    window = p.common_window([k for _, k in ledgers],
+                             [{k: v["pass"] for k, v in pairs.items()} for pairs, _ in ledgers],
+                             last_scored=horizon)
+    report = dict(window=window, horizon=horizon, cases=[],
+                  horizon_mode="default-cap" if horizon == p.LAST_SCORED else
+                  "extended duration diagnostic (declared amendment, D40/60D only)")
+    for case, (pairs, k_case) in zip(cases, ledgers):
+        limit = round((0.25 + horizon) * case["T"])  # events inside the horizon only
+        entry = {key: case[key] for key in ("path", "D", "T", "box", "n", "u_max", "nu", "tau", "A",
+                                            "steps", "cycles", "F_ref")}
+        entry.update(duration_T=case["steps"] / case["T"], K_case=k_case, pairs=pairs,
+                     coverage={k: coverage(case, k) for k in sorted(cycle_slices(case))
+                               if p.DISCARD < k <= horizon},
+                     no_donor=float(case["diag"][:limit, 13].sum()),
+                     eq_only=float(case["diag"][:limit, 12].sum()),
+                     hf_component=hf_component(case, window or tuple(
+                         [k for k in sorted(cycle_slices(case)) if p.DISCARD < k <= horizon][-3:])))
+        if window:  # residual drift inside the scored window (pairs K..K+2)
+            entry["window_drift"] = {key: max(pairs[k][key] for k in window)
+                                     for key in ("wave", "profile", "morison")}
+            entry["morison_obs"] = cycle_morison(case, window)
+            entry["morison"] = {name: cycle_morison(case, window, fx)
+                                for name, fx in candidates(case).items()}
+            entry["fy_mean"] = float(np.mean(np.concatenate(
+                [case["force"][cycle_slices(case)[k], 1] for k in window])) / case["F_ref"])
+        report["cases"].append(entry)
+    if window and len(cases) > 1:  # cross-resolution waveform against the finest case
+        fine = (next(c for c in cases if c["path"] == ref_path) if ref_path
+                else max(cases, key=lambda c: c["D"]))
+        report["reference"] = fine["path"]
+        ref = np.concatenate([coarse_wave(fine, k) for k in window])
+        for case, entry in zip(cases, report["cases"]):
+            r = fine["T"] // case["T"]  # 1 for equal-D domain runs
+            ref_c = ref.reshape(-1, r).mean(axis=1)
+            own = np.concatenate([coarse_wave(case, k) for k in window])
+            entry["wave_rms_vs_finest"] = float(np.sqrt(np.mean((own - ref_c) ** 2)))
+        for k in window:  # profiles on the common valid point set of all compared cases
+            per_case = [profiles(c, k) for c in cases]
+            keys = common_points(per_case)
+            report.setdefault("common_profile_points", {})[k] = len(keys)
+            if not keys:
+                report["verdict"] = "FAIL-CLOSED: empty common profile set"
+                continue
+            fine_p = per_case[cases.index(fine)]
+            for case, entry, prof in zip(cases, report["cases"], per_case):
+                d = max(max(abs(prof[key][0] - fine_p[key][0]), abs(prof[key][1] - fine_p[key][1]))
+                        for key in keys) / case["u_max"]
+                entry.setdefault("profile_max_vs_finest", {})[k] = float(d)
+        ref_entry = report["cases"][cases.index(fine)]
+        for entry in report["cases"]:  # conservative: difference + both drifts
+            if entry is ref_entry:
+                continue
+            drift = {key: entry["window_drift"][key] + ref_entry["window_drift"][key]
+                     for key in ("wave", "profile", "morison")}
+            dm = max(abs(entry["morison"]["cme"][0] - ref_entry["morison"]["cme"][0]),
+                     abs(entry["morison"]["cme"][1] - ref_entry["morison"]["cme"][1]))
+            entry["conservative"] = dict(
+                wave=entry["wave_rms_vs_finest"] + drift["wave"],
+                profile=max(entry.get("profile_max_vs_finest", {}).values(), default=math.inf)
+                + drift["profile"],
+                morison_cme=dm + drift["morison"])
+            bands = p.DOMAIN if ref_path else p.CROSS  # domain runs name the 60 D reference
+            c = entry["conservative"]
+            entry["pass_scope"] = (
+                ("wave+profile+morison_cme" if "morison" in bands else "wave+profile")
+                + ": conservative (|diff| + both window drifts) on the obs/CME Fx waveform and "
+                "simulation-to-simulation profiles; CME+Wen and CME+node reported, not checked; "
+                "no Fig. 8 / literature verdict")
+            entry["pass"] = (c["wave"] <= bands["wave"] and c["profile"] <= bands["profile"]
+                             and ("morison" not in bands or c["morison_cme"] <= bands["morison"]))
+    print(json.dumps(report, indent=1, default=float))
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

research/duetsch_re100_kc5/capture.py

@@ -0,0 +1,52 @@
+"""Research-only field capture helpers for the Dütsch driver (numpy only).
+
+Snapshots are taken at the first step of the scored phase bins in declared
+cycles: a near-body crop at full resolution and a fluid-weighted block-mean
+downsample of the whole domain; plus scalar trends at every bin read.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+CROP_X, CROP_Y, DOWN = 8.0, 6.0, 8      # crop half-widths in D; downsample factor
+STRIP = 2.0                             # inlet/outlet strip width in D
+
+
+def crop_box(xm, ym, D, n, body_extent):
+    """Inclusive integer crop (x0, x1, y0, y1); fail closed if it leaves the domain
+    interior or does not contain the body's swept extent (x_lo, x_hi, y_lo, y_hi)."""
+    x0, x1 = int(round(xm - CROP_X * D)), int(round(xm + CROP_X * D))
+    y0, y1 = int(round(ym - CROP_Y * D)), int(round(ym + CROP_Y * D))
+    if x0 < 1 or y0 < 1 or x1 > n - 2 or y1 > n - 2:
+        raise ValueError("capture crop leaves the domain interior")
+    bx0, bx1, by0, by1 = body_extent
+    if not (x0 <= bx0 and bx1 <= x1 and y0 <= by0 and by1 <= y1):
+        raise ValueError("capture crop clips the body's swept extent")
+    return x0, x1, y0, y1
+
+
+def downsample(field, fluid, f=DOWN):
+    """Fluid-weighted f x f block means; NaN where a block has no fluid cell."""
+    ny, nx = field.shape
+    h, w = ny // f, nx // f
+    v = np.where(fluid, field, 0.0)[:h * f, :w * f].reshape(h, f, w, f).sum(axis=(1, 3))
+    c = fluid[:h * f, :w * f].reshape(h, f, w, f).sum(axis=(1, 3))
+    with np.errstate(invalid="ignore", divide="ignore"):
+        return np.where(c > 0, v / np.maximum(c, 1), np.nan).astype(np.float32)
+
+
+def fluid_mean(field, fluid, xs=slice(None), ys=slice(None)):
+    m = fluid[ys, xs]
+    return float(field[ys, xs][m].mean()) if m.any() else float("nan")
+
+
+def trend_row(s, k, ph, rho, ux, uy, fluid, D, n, crop):
+    """(s, cycle, phase, <rho>, <ux>, <uy>, <rho>_crop, inlet <rho>, <ux>, outlet <rho>, <ux>)."""
+    w = max(1, int(round(STRIP * D)))
+    x0, x1, y0, y1 = crop
+    cx, cy = slice(x0, x1 + 1), slice(y0, y1 + 1)
+    inlet, outlet, inner = slice(1, 1 + w), slice(n - 1 - w, n - 1), slice(1, n - 1)
+    return (s, k, ph, fluid_mean(rho, fluid), fluid_mean(ux, fluid), fluid_mean(uy, fluid),
+            fluid_mean(rho, fluid, cx, cy),
+            fluid_mean(rho, fluid, inlet, inner), fluid_mean(ux, fluid, inlet, inner),
+            fluid_mean(rho, fluid, outlet, inner), fluid_mean(ux, fluid, outlet, inner))

research/duetsch_re100_kc5/protocol.py

@@ -0,0 +1,136 @@
+"""Pure arithmetic of the Dütsch Re 100 / KC 5 protocol (numpy only, no CUDA).
+
+docs/validation/duetsch_re100_kc5_protocol.md is the contract: elapsed time s
+in native steps from the right turning point, paper phase
+phi = (360 s / T - 90) mod 360, paper cycle k >= 1 spans
+s/T in [0.25 + (k-1), 0.25 + k); cycle 0 is the startup quarter.
+"""
+from __future__ import annotations
+
+import math
+from functools import lru_cache
+
+import numpy as np
+
+KC, RE = 5.0, 100.0
+STATIONS = (-0.6, 0.0, 0.6, 1.2)          # lab-fixed x/D from the mean position
+PHASES = (180.0, 210.0, 330.0)            # degrees; bins [p, p + 1)
+X2 = tuple(np.round(np.arange(-1.5, 1.5001, 0.05), 10))  # declared x2/D points
+DISCARD, LAST_SCORED, N_PAIRS = 2, 11, 3   # cycles 0..2 discarded, cap 12 T
+# A-priori bands. Settling is one fifth of the tightest comparison band of the
+# same observable, and comparisons add both cases' residual window drift
+# (conservative: |difference| + drift_a + drift_b <= band).
+DOMAIN = dict(wave=.01, morison=.02, profile=.02)  # vs the 60 D reference at D = 40
+CROSS = dict(wave=.02, profile=.02)                # D40 vs D80
+SETTLE = dict(wave=.002, scalar=.002, profile=.004, morison=.004)
+
+
+def amplitude(D):
+    return KC * D / (2.0 * math.pi)
+
+
+def position(s, T, A):
+    """Centre position relative to the mean: x = A cos(2 pi s / T), evaluated from the
+    native step modulo T so every cycle repeats the same geometry bit for bit."""
+    return A * math.cos(2.0 * math.pi * (int(s) % T) / T)
+
+
+def phase(s, T):
+    """Paper phase in degrees from the native step modulo T (the unwrapped cycle
+    index is kept separately by ``cycle``)."""
+    return (360.0 * (int(s) % T) / T - 90.0) % 360.0
+
+
+def cycle(s, T):
+    return 0 if s < 0.25 * T else int(math.floor(s / T - 0.25)) + 1
+
+
+def bin_phase(s, T):
+    """Scored phase whose 1-degree bin [p, p + 1) contains time s, else None."""
+    phi = phase(s, T)
+    for p in PHASES:
+        if p <= phi < p + 1.0:
+            return p
+    return None
+
+
+@lru_cache(maxsize=8)
+def _quadrature_rule(points):
+    """Reuse the nodes and weights, which depend only on quadrature order."""
+    return np.polynomial.legendre.leggauss(points)
+
+
+def interval_bases(n, T, points=16):
+    """Single-step interval averages over [n, n + 1] of cos phi |cos phi| and sin phi
+    (phi in radians = 2 pi s / T - pi / 2), Gauss-Legendre quadrature."""
+    x, w = _quadrature_rule(points)
+    s = int(n) % T + 0.5 * (x + 1.0)  # periodic: identical bases in every cycle
+    phi = 2.0 * np.pi * s / T - 0.5 * np.pi
+    c = np.cos(phi)
+    return 0.5 * float(np.sum(w * c * np.abs(c))), 0.5 * float(np.sum(w * np.sin(phi)))
+
+
+def morison_fit(f_norm, b1, b2):
+    """Least squares of f_norm = c_d b1 - (pi^2 c_i / KC) b2 (paper phase, no shift)."""
+    a = np.column_stack([b1, -(math.pi ** 2 / KC) * np.asarray(b2)])
+    (c_d, c_i), *_ = np.linalg.lstsq(a, np.asarray(f_norm), rcond=None)
+    return float(c_d), float(c_i)
+
+
+def inside_circle(x, y, centre, radius):
+    return (x - centre[0]) ** 2 + (y - centre[1]) ** 2 < radius * radius
+
+
+def sample(field, fluid, x, y, centre, radius):
+    """Profile sample: MISSING if the exact point is inside the body (checked before
+    any corner interpolation), else ``bilinear_fluid``."""
+    if inside_circle(x, y, centre, radius):
+        return None, (), 0.0
+    return bilinear_fluid(field, fluid, x, y)
+
+
+def bilinear_fluid(field, fluid, x, y):
+    """Bilinear value at (x, y) in cell coordinates from fluid cells only.
+
+    Returns (value, ((ix, iy, weight), ...), fluid_weight_sum) with weights
+    renormalized over the fluid corners and the original sum of their bilinear
+    weights, or (None, (), 0.0) when no corner is fluid (MISSING, never zero).
+    """
+    x0, y0 = int(math.floor(x)), int(math.floor(y))
+    fx, fy = x - x0, y - y0
+    corners = ((x0, y0, (1 - fx) * (1 - fy)), (x0 + 1, y0, fx * (1 - fy)),
+               (x0, y0 + 1, (1 - fx) * fy), (x0 + 1, y0 + 1, fx * fy))
+    used = [(i, j, w) for i, j, w in corners if w > 0.0 and fluid[j, i]]
+    total = sum(w for _, _, w in used)
+    if total == 0.0:
+        return None, (), 0.0
+    used = tuple((i, j, w / total) for i, j, w in used)
+    return float(sum(w * field[j, i] for i, j, w in used)), used, float(total)
+
+
+def settled_start(pairs_pass):
+    """K_case from {k: pass of pair (k-1 -> k)}: first cycle after three consecutive
+    passing pairs among cycles > DISCARD, or None."""
+    run = 0
+    for k in sorted(pairs_pass):
+        if k - 1 <= DISCARD:
+            continue
+        run = run + 1 if pairs_pass[k] else 0
+        if run == N_PAIRS:
+            return k + 1
+    return None
+
+
+def common_window(k_cases, pairs_pass_by_case, last_scored=LAST_SCORED):
+    """Common scored cycles K..K+2 with K = max K_case, or None (FAIL-CLOSED) when a
+    case never settled, K + 2 exceeds the cap, or a case fails any pair p_j for
+    j = its own K_case .. K + 2 (continuous settling, including the wait for K)."""
+    if any(k is None for k in k_cases):
+        return None
+    K = max(k_cases)
+    if K + 2 > last_scored:
+        return None
+    for k_case, pairs in zip(k_cases, pairs_pass_by_case):
+        if not all(pairs.get(j, False) for j in range(k_case, K + 3)):
+            return None
+    return K, K + 1, K + 2

research/duetsch_re100_kc5/run.py

@@ -0,0 +1,133 @@
+"""One-shot Dütsch Re 100 / KC 5 prescribed in-line oscillation driver.
+
+Protocol: docs/validation/duetsch_re100_kc5_protocol.md. Native dense channel
+(zero-velocity inlet, pressure-NEQ outlet, bounce-back y walls), MRT, lab frame.
+Writes raw per-step force/diagnostics and phase-bin profile samples to --out
+(outside the checkout); analysis is in analyze.py. No production change.
+
+    python run.py --D 40 --box 40 --cycles 11 --out /path/outside/checkout
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import tempfile
+
+import numpy as np
+
+import protocol as p
+
+
+TEMPLATE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "src",
+                        "CelerisLab", "configs", "config_lbm.json")
+
+
+def config(D, box, T):
+    """Shipped config_lbm.json (full parser schema) with only the case fields
+    overridden: grid, still fluid (velocity 0), nu from Re, MRT, uniform inlet
+    profile, bounce-back y walls. Inlet scheme and outlet mode stay the
+    template's (zou_he_local, neq_extrap) and are recorded in case.json."""
+    u = p.KC * D / T
+    n = int(round(box * D))
+    with open(TEMPLATE) as fh:
+        cfg = json.load(fh)
+    cfg["grid"].update(lattice_model="D2Q9", nx=n, ny=n, nz=1)
+    cfg["physics"].update(data_type="FP32", viscosity=u * D / p.RE, velocity=0.0, rho=1.0)
+    cfg["method"].update(collision="MRT", streaming="double_buffer", store_precision="FP32",
+                         ddf_shifting=False, y_wall_bc="bounce_back")
+    cfg["method"]["les"]["enabled"] = False
+    cfg["method"]["inlet"]["profile"] = "uniform"
+    return cfg, u, n
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--D", type=int, required=True)
+    ap.add_argument("--box", type=float, default=40.0, help="box side in D")
+    ap.add_argument("--T", type=int, default=None, help="period in steps (multiple of 360)")
+    ap.add_argument("--cycles", type=int, default=p.LAST_SCORED, help="run to the end of this cycle")
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--dump-fields", default="",
+                    help="research capture: comma-separated paper cycles, e.g. 11,21,30,31")
+    args = ap.parse_args()
+    D, T = args.D, args.T or 126 * args.D
+    if T % 360:
+        raise SystemExit("T must be a multiple of 360 steps")
+    if os.path.realpath(args.out).startswith(os.path.realpath(os.path.join(os.path.dirname(__file__), "..", ".."))):
+        raise SystemExit("--out must be outside the checkout")
+    cfg, u_max, n = config(D, args.box, T)
+    A, R = p.amplitude(D), 0.5 * D
+    xm = ym = 0.5 * (n - 1)
+    os.makedirs(args.out, exist_ok=True)
+
+    from CelerisLab.body.motion import Translation
+    from CelerisLab.simulation import Simulation
+    with tempfile.NamedTemporaryFile("w", suffix=".json", delete=False) as fh:
+        json.dump(cfg, fh)
+    sim = Simulation(fh.name)
+    try:
+        body = sim.add_body("circle", (xm + A, ym), R,
+                            translation=Translation((-2.0 * A, 0.0, 0.0, 0.0), 1.01 * u_max))
+        sim.initialize()
+        dump = {int(c) for c in args.dump_fields.split(",") if c}
+        if dump:
+            import capture
+            if max(dump) > args.cycles or min(dump) <= p.DISCARD:
+                raise SystemExit("--dump-fields cycles must lie in the scored range of this run")
+            crop = capture.crop_box(xm, ym, D, n, (xm - A - R, xm + A + R, ym - R, ym + R))
+            trend = []
+        steps = int(round((0.25 + args.cycles) * T))
+        force = np.zeros((steps, 2)); diag = []; samples = []
+        for m in range(steps):
+            x0, x1 = p.position(m, T, A), p.position(m + 1, T, A)
+            sim.set_body(body, offset=(max(x1 - A, -2.0 * A), 0.0), vx=x1 - x0)
+            sim.run(1)
+            force[m] = sim.read_force(body)[:2]
+            diag.append(sim.moving_diagnostics()[0])
+            s = m + 1  # state after the step
+            ph = p.bin_phase(s, T)
+            if ph is not None and p.cycle(s, T) > p.DISCARD:
+                fields = sim.get_macroscopic()
+                fluid = (sim.get_flags().reshape(n, n) & 1) != 0
+                ux, uy = (np.asarray(fields[k]).reshape(n, n) for k in ("ux", "uy"))
+                if dump:  # research capture only; the default path is unchanged
+                    rho = np.asarray(fields["rho"]).reshape(n, n)
+                    trend.append(capture.trend_row(s, p.cycle(s, T), ph, rho, ux, uy, fluid, D, n, crop))
+                    if p.cycle(s, T) in dump and p.phase(s, T) == ph:  # first step of the bin
+                        x0c, x1c, y0c, y1c = crop
+                        cy_, cx_ = slice(y0c, y1c + 1), slice(x0c, x1c + 1)
+                        np.savez_compressed(
+                            os.path.join(args.out, f"fields_c{p.cycle(s, T)}_p{int(ph)}.npz"),
+                            s=s, cycle=p.cycle(s, T), phase=ph, crop=np.asarray(crop),
+                            force=force[m], centre=np.asarray((xm + p.position(s, T, A), ym)),
+                            ux=ux[cy_, cx_].astype(np.float32), uy=uy[cy_, cx_].astype(np.float32),
+                            rho=rho[cy_, cx_].astype(np.float32), fluid=fluid[cy_, cx_].astype(np.uint8),
+                            down_ux=capture.downsample(ux, fluid), down_uy=capture.downsample(uy, fluid),
+                            down_rho=capture.downsample(rho, fluid))
+                centre = (xm + p.position(s, T, A), ym)  # analytic centre after the step
+                for xs in p.STATIONS:
+                    for x2 in p.X2:
+                        x, y = xm + xs * D, ym + x2 * D
+                        u, wu, wsum = p.sample(ux, fluid, x, y, centre, R)
+                        v, _, _ = p.sample(uy, fluid, x, y, centre, R)
+                        samples.append((s, p.cycle(s, T), ph, xs, x2,
+                                        math.nan if u is None else u, math.nan if v is None else v,
+                                        wsum, json.dumps(wu)))
+        if dump:
+            np.save(os.path.join(args.out, "trend.npy"), np.asarray(trend, float))
+        np.savez(os.path.join(args.out, "raw.npz"), force=force, diag=np.asarray(diag),
+                 samples=np.asarray([r[:8] for r in samples], float))
+        with open(os.path.join(args.out, "case.json"), "w") as fh:
+            json.dump(dict(D=D, T=T, box=args.box, n=n, u_max=u_max, nu=cfg["physics"]["viscosity"],
+                           tau=3 * cfg["physics"]["viscosity"] + 0.5, A=A, steps=steps,
+                           cycles=args.cycles, F_ref=0.5 * u_max ** 2 * D,
+                           inlet=cfg["method"]["inlet"], outlet=cfg["method"]["outlet"],
+                           weights=[r[8] for r in samples]), fh)
+    finally:
+        sim.close()
+
+
+if __name__ == "__main__":
+    main()

research/fine_surface_20261014/baseline.json

@@ -0,0 +1,389 @@
+{
+  "head": "6e3756c587ec08ab6a55c4a1a5f4671822d3f0a0",
+  "status": " M pyproject.toml\n M setup.py\n M src/CelerisLab/__init__.py\n M src/CelerisLab/body/__init__.py\n M src/CelerisLab/body/ddf_patch.py\n M src/CelerisLab/body/manager.py\n M src/CelerisLab/body/objects.py\n M src/CelerisLab/body/preprocess/flag_overlay.py\n M src/CelerisLab/common/__init__.py\n M src/CelerisLab/common/checkpoint.py\n M src/CelerisLab/config.py\n M src/CelerisLab/configs/CONFIG.md\n M src/CelerisLab/cuda/__init__.py\n M src/CelerisLab/cuda/compiler_v2.py\n M src/CelerisLab/cuda/context.py\n M src/CelerisLab/lbm/__init__.py\n M src/CelerisLab/lbm/curved_links.py\n M src/CelerisLab/lbm/field.py\n M src/CelerisLab/lbm/initializers.py\n M src/CelerisLab/lbm/kernels/boundary/bounce_back.cuh\n M src/CelerisLab/lbm/kernels/boundary/curved_boundary.cuh\n M src/CelerisLab/lbm/kernels/boundary/inlet/common.cuh\n M src/CelerisLab/lbm/kernels/boundary/inlet/zou_he_local.cuh\n M src/CelerisLab/lbm/kernels/boundary/inlet_outlet.cuh\n M src/CelerisLab/lbm/kernels/config/config_grid.h\n M src/CelerisLab/lbm/kernels/config/config_method.h\n M src/CelerisLab/lbm/kernels/config/config_objects.h\n M src/CelerisLab/lbm/kernels/config/config_physics.h\n M src/CelerisLab/lbm/kernels/kernel_v2.cu\n M src/CelerisLab/lbm/kernels/operators/collision_mrt.cuh\n M src/CelerisLab/lbm/kernels/operators/collision_trt.cuh\n M src/CelerisLab/lbm/kernels/operators/forcing_guo.cuh\n M src/CelerisLab/lbm/kernels/step/aux_kernels.cu\n M src/CelerisLab/lbm/kernels/step/esopull_sync.cu\n M src/CelerisLab/lbm/kernels/step/init_flow.cu\n M src/CelerisLab/lbm/kernels/step/one_step_double.cu\n M src/CelerisLab/lbm/kernels/step/one_step_esopull.cu\n M src/CelerisLab/lbm/kernels/streaming/esopull_semantic_helpers.cuh\n M src/CelerisLab/lbm/stepper.py\n M src/CelerisLab/simulation.py\n M tests/integration/test_body_sync_e2e.py\n M tests/integration/test_ddf_patch.py\n M tests/integration/test_sync_bodies_skeleton.py\n M tests/integration/test_unified_obs.py\n M tests/postproc/experiment.ipynb\n M tests/validation/run_kan99b_rotating_cylinder.py\n M tests/validation/run_sah04_st_matrix.py\n M tests/validation/test_sensor_accuracy.py\n?? docs/design/\n?? docs/multilevel_grid_architecture_analysis.md\n?? examples/\n?? research/\n?? src/CelerisLab/lbm/kernels/boundary/planar_velocity.cuh\n?? src/CelerisLab/lbm/kernels/refinement.cu\n?? src/CelerisLab/lbm/refinement.py\n?? src/CelerisLab/lbm/refinement_stepper.py\n?? \"tests/audit/body\\345\\210\\240\\345\\207\\217\\345\\212\\237\\350\\203\\275.md\"\n?? tests/integration/_cases.py\n?? tests/integration/test_numerical_gpu.py\n?? tests/integration/test_runtime_contracts_gpu.py\n?? tests/integration/test_state_gpu.py\n?? tests/integration/test_surface_actuation_gpu.py\n?? tests/unit/cpp/\n?? tests/unit/test_build_contracts.py\n?? tests/unit/test_context_ownership.py\n?? tests/unit/test_initializers.py\n?? tests/unit/test_numerical_operators.py\n?? tests/unit/test_planar_velocity.py\n?? tests/unit/test_refinement.py\n?? tests/unit/test_reservoir.py\n?? tests/unit/test_simulation_lifecycle.py\n?? tests/unit/test_slot_velocity.py\n?? tests/unit/test_state_regressions.py\n?? tests/unit/test_surface_actuation.py\n?? tests/validation/analyze_j3_saved_frames.py\n?? tests/validation/diagnose_j3_lags.py\n?? tests/validation/multigrid/\n?? tests/validation/run_j1.py\n?? tests/validation/run_j2_slot.py\n?? tests/validation/run_j3_coverage.py\n?? tests/validation/run_j3_reservoir.py\n?? tests/validation/run_poiseuille.py\n",
+  "copy_dir": "/tmp/celeris-fine-surface-baseline-z98oi6ps",
+  "hashes": {
+    "src/CelerisLab.egg-info/PKG-INFO": "0b9a8a4e8d60bc531473688723ddef0aab02c7ccc4997e31c9b6a6c35011ca77",
+    "src/CelerisLab.egg-info/top_level.txt": "cd51958ca03afabbaa9618c60b8280e486f8cc0b0359b839e10f886e7c3948f8",
+    "src/CelerisLab.egg-info/dependency_links.txt": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
+    "src/CelerisLab.egg-info/requires.txt": "36e1404178e5ea590b2fc04e8ba4d748ec9a82e7693136ccf0dfd204fe265c04",
+    "src/CelerisLab.egg-info/SOURCES.txt": "f36b29c1b34c4bd6b2acc3ccdd21c24ee5077df7e2a20a652d9fae77eedb8e21",
+    "src/CelerisLab/simulation.py": "c9d903f53fe356d7af281bea07943de1a62494127fb69848d7053fd46f7dec3e",
+    "src/CelerisLab/config.py": "2f1bba7515f5bc08cb3a8d140bcafe7fa0689e01b3b06494697bb2956a71530e",
+    "src/CelerisLab/__init__.py": "21cc469bd6e970a1f9ff5970c8eea4602065e41fc881854759ee565ee55c10c6",
+    "src/CelerisLab/cuda/compiler_v2.py": "c4cc3ec4445c8d75e6a253dd87963877117a722bc73b9d4811806fc6045d08c1",
+    "src/CelerisLab/cuda/obs_layout.py": "5ffb2c3aeeaaaaeb64f2cd8febfbcf4ad9919e5414020ad753cfade0683b21c2",
+    "src/CelerisLab/cuda/context.py": "013dd4ec6d01d2fbd11afdfb103eac6a273bd9f798d663d761b851eeb27885e9",
+    "src/CelerisLab/cuda/__init__.py": "0d01dff9f0399c8baba822aab5ca0122a135f011008ed8a499ebd9f7e5b06aea",
+    "src/CelerisLab/lbm/refinement_stepper.py": "ad57a6a3887b007488b4954b24ff06cd8cde2b12674bdafb97bfda1961ae1da4",
+    "src/CelerisLab/lbm/field.py": "0e727eacc3706add4d8d15c418e9b631050871f831698d3ac689dd5f2c701b9b",
+    "src/CelerisLab/lbm/equilibrium.py": "2fb2f2bb7ff326d23abce80fc2a4c0907b17740ea3e29fe6ae079c5044783826",
+    "src/CelerisLab/lbm/descriptors.py": "c9f025dfc14da43b989047b84cc22bd05d5cc92c9ec695c1da68fdfb788e3f2b",
+    "src/CelerisLab/lbm/initializers.py": "dacf9586963e862d6d0a98ef1a066036be6f91e9d423720661d8ef2c1fb2df6a",
+    "src/CelerisLab/lbm/curved_links.py": "00d9c29d660b41190f32dd737b12f60e10ce4214b6c9a6ab2a63438813faa594",
+    "src/CelerisLab/lbm/stepper.py": "d2ef351aa2de441ec123deb55ce35603064130222f5490b154d41756b755cd73",
+    "src/CelerisLab/lbm/__init__.py": "7f60fb3aaae81501b510d08c2fedff44fcb05657260eb10b6f5cc91e7204306b",
+    "src/CelerisLab/lbm/refinement.py": "554735c5613129eb29f339c6aeeb4f3a3bbc5aba67558be51fbf7c2fb6ac442a",
+    "src/CelerisLab/lbm/kernels/kernel_v2.cu": "c7bd3fb705b77261ba2441c52a24a7e6a7865c165cba088a1b75201c4d29c408",
+    "src/CelerisLab/lbm/kernels/refinement.cu": "025c59dc9c207a831e78e1635cb3f14fe60b64c021004a0d66e5d01fda8554b5",
+    "src/CelerisLab/lbm/kernels/config.h": "7d1124125e0b354558297934460e64c760fb68cdd7bf6d01a1238bb2eaab8c37",
+    "src/CelerisLab/lbm/kernels/kernel_v2.ptx": "a599ee30ae66800f4d4220eb79dfed35ff32991661260f01ea58023ef780f0ca",
+    "src/CelerisLab/lbm/kernels/operators/turbulence_smag.cuh": "ff7f000297ee0817e255ad9fcb6a13b647e3ddd5b206518d35f38d2895a9f501",
+    "src/CelerisLab/lbm/kernels/operators/collision_mrt.cuh": "aee444eb60c47a3fd518dca975d1af05425a0818a0ec6c3fb3f6150f60c2cb44",
+    "src/CelerisLab/lbm/kernels/operators/collision_trt.cuh": "9725b9840b9ad8b4ec7be61ff5d06d3151e86d1a87585c13f2fbf934d0d2c5f6",
+    "src/CelerisLab/lbm/kernels/operators/collision_srt.cuh": "6b7ff842f392c8f853d2d1a97cc69bfe50f21283f73e659404da07cf6c95f5e1",
+    "src/CelerisLab/lbm/kernels/operators/forcing_guo.cuh": "969a430c1af03f32e3bd0df95d805e64f56334717c44dd4ba208ba503062a24b",
+    "src/CelerisLab/lbm/kernels/operators/macro.cuh": "e27c1c410dc857be98da4596568e405eeaf88701d291ac0e398aa9cd23dee740",
+    "src/CelerisLab/lbm/kernels/operators/helpers.cuh": "0b3a4d95d7d19f5fec09e5423b8f4cc99f8a226b541967425967330da5a051ec",
+    "src/CelerisLab/lbm/kernels/core/precision.cuh": "849df14b4cce50af52399e4b8f3e997196f3ae5f1163f68e28df3e6b2507a8c4",
+    "src/CelerisLab/lbm/kernels/core/descriptors.cuh": "8440bc14857da9007982650f828a23608eec9f7cc4bf772e8c8dc1239cb45356",
+    "src/CelerisLab/lbm/kernels/core/obs.cuh": "b742b77c9f61e1f020fe9922c3838ae9d855e17b381154958b58f10a22938922",
+    "src/CelerisLab/lbm/kernels/core/params.cuh": "6e18bf730d936d940e3d85452f0714a2eaae31bf41002f9fd520ec5b372878dd",
+    "src/CelerisLab/lbm/kernels/core/flags.cuh": "0025705f24710330d9d9195f713879bfb650a85a3449baef0e196b831af104ab",
+    "src/CelerisLab/lbm/kernels/core/layout.cuh": "1fbd820021c89ac3efcde24145996cb0147769e607e498e61f308ed3e0b13706",
+    "src/CelerisLab/lbm/kernels/boundary/ibm_kernels.cuh": "e6909b547dc8d64cdd8a76a90660243a8f5fee535caa161b52b4dd8b7c29934b",
+    "src/CelerisLab/lbm/kernels/boundary/planar_velocity.cuh": "0b2f9e0bd483c199637e5672dc0ffc460bc383dd1804805befbeb4c5d8c708d1",
+    "src/CelerisLab/lbm/kernels/boundary/inlet_outlet.cuh": "de8b213a6da42c2e5e9f8966199fc66ea4541b85144a90f3f5dbad3c6ab63b97",
+    "src/CelerisLab/lbm/kernels/boundary/curved_boundary.cuh": "7bccf7e7091c012d7a3d4874a881d4d46699021faedd83d125933fbdaa562711",
+    "src/CelerisLab/lbm/kernels/boundary/bounce_back.cuh": "aba3748c564ed91b161d268ef8b737b7c7be96a823063d201f3da684dd845233",
+    "src/CelerisLab/lbm/kernels/boundary/esopull_curved_helpers.cuh": "b9b474bc4edaff05681c5443235472d04072d0d775fc0eb9c5967faef52b0258",
+    "src/CelerisLab/lbm/kernels/boundary/inlet/equilibrium.cuh": "f0964c811b2c41a5aaa1c6d99c490b06e850c634eb8749f1f05ef61f93c2de1d",
+    "src/CelerisLab/lbm/kernels/boundary/inlet/channel_stabilized.cuh": "efe077afcbb6b731256a987c2fd79a1dbc470c902f87070d60421ea6cb13d4e2",
+    "src/CelerisLab/lbm/kernels/boundary/inlet/common.cuh": "f3cec54c8873c65b3dca4375605d2c89a8727765884d3954c235242fdff9c6ba",
+    "src/CelerisLab/lbm/kernels/boundary/inlet/zou_he_local.cuh": "e73e66b853b1e4e0e30d8f4185d832aa414ce670a1813ce2b5459f2887f71f89",
+    "src/CelerisLab/lbm/kernels/boundary/inlet/regularized.cuh": "943d4a571818bacb89c70bccfaac202691121e3e385803ce6309123a0a03ddaf",
+    "src/CelerisLab/lbm/kernels/boundary/outlet/pressure_neq.cuh": "c8b2adc66d12fe602076ddc9693c5c208711fcaddb58aa9a31401a269f51c4c4",
+    "src/CelerisLab/lbm/kernels/streaming/esopull_single_buffer.cuh": "77ed4ab9a0ebc5ff62a91a7c39066ef395391ae36e9040a69fb2bd8b1626dc79",
+    "src/CelerisLab/lbm/kernels/streaming/pull_double_buffer.cuh": "b65d741ed78b7b62f99531ba0c0ce1936663d8dc9640e7d7d16c707f1baf6549",
+    "src/CelerisLab/lbm/kernels/streaming/esopull_semantic_helpers.cuh": "dd5a9091628b079efd97e53fd49e52d09dcee88529235db77a5648e02937af6e",
+    "src/CelerisLab/lbm/kernels/step/esopull_sync.cu": "c0ff3e72900c3ab89a05dd03684e96d3b740cf1672d565727fc2af165933d087",
+    "src/CelerisLab/lbm/kernels/step/init_flow.cu": "305be3bb12fc0d039acec1701baabcf0e8a35e683c49c34f2af8ca9867d2b29c",
+    "src/CelerisLab/lbm/kernels/step/esopull_macro.cu": "c73116020ca217ede1e4de27c8269c31f9d91e33433ac8252a21e9b14187c50f",
+    "src/CelerisLab/lbm/kernels/step/aux_kernels.cu": "e163257b9cbbcdd289bf2a76b5b147ed9512dd04825ddfc9518fb626c8cff00e",
+    "src/CelerisLab/lbm/kernels/step/one_step_esopull.cu": "aa223b2744ae6c9125673df311a96ce588032c1ba58bebb11fd33ecb990f8ed4",
+    "src/CelerisLab/lbm/kernels/step/one_step_double.cu": "f9f8242b38e8e0cf8425b75e2b0215bc15363c62eaa0fb43c761b8e0931bfdc9",
+    "src/CelerisLab/lbm/kernels/config/config_physics.h": "26df33c2960ba36f3283e19b55b4ea92e50e4efda705f9ebfbf3f875a4092c59",
+    "src/CelerisLab/lbm/kernels/config/config_method.h": "3db4e16ef2c6b22349d04e6aa8ab04bdfe0eb784f9f3a98277e15dbed1835d81",
+    "src/CelerisLab/lbm/kernels/config/config_grid.h": "8be3a7cf74ba30d7fd3074fed79e63dbda7311c4d03b454ea641bf298ffeaa8d",
+    "src/CelerisLab/lbm/kernels/config/config_objects.h": "dbb93c063586da278c15d95e23f84c12e728f4f5f1bbc3980fe9cedaa6fff90e",
+    "src/CelerisLab/lbm/kernels/config/config_obs.h": "c11e2249359145b5c4cbaaf0487506fa77c1f4b82c7c169ddc574aa0babcd727",
+    "src/CelerisLab/common/checkpoint.py": "b2f960aecd5ac27a3a7130b809ffad4709c44d522edef0359ab952654625410b",
+    "src/CelerisLab/common/_types.py": "aad2ff1a9033d4fd68783ad7123afb47201ddc58785cb6dc0246947037072a5f",
+    "src/CelerisLab/common/pathline.py": "a1b6efcc0a076d0f1dc8d49a595779426d7d5626b00072a59bac710ff02ad046",
+    "src/CelerisLab/common/__init__.py": "d4dbde78bc97fccc9eabac9abae8f0f15c112c10ff8e9b45bd9401d4723df1ef",
+    "src/CelerisLab/common/preprocess.py": "7fc78a08857cf8e98519500b094a1d896af189b6b15658ff9b388ed51bed4515",
+    "src/CelerisLab/common/render.py": "0e055476257eb2bcd11e733766e52195de02f8fad228f570a3511a7c831bdc29",
+    "src/CelerisLab/common/streakline/_render.py": "236cd637414ee318c4d66f9aed32110d8dc42a100d65fde06172f7cd0ba62c65",
+    "src/CelerisLab/common/streakline/_integrate.py": "3fbd4368b2c8d0e7fda40dc65aac5df02b085008b4c68acd83cb7ae45d33a13b",
+    "src/CelerisLab/common/streakline/_streakline.py": "1a3e08daa706b5f83cdeb337e9a945a36ddf7583c40af1d0bb9d825ac954df37",
+    "src/CelerisLab/common/streakline/__init__.py": "13ff1cfa416fdd721a08a659e76b5a5a99b8d3201add10a83b7b0bc654bc1eec",
+    "src/CelerisLab/common/streakline/_config.py": "a9185ef68e9c7b5d5a1dc0b04a28341e2ad91d13c145a7c106636a878cf0a605",
+    "src/CelerisLab/configs/config_lbm.json": "17e4311f1f250c6ece59177a8b6ff856b69a016c7c10267e774b030a0a390865",
+    "src/CelerisLab/configs/CONFIG.md": "41cafdbe525366c08aa9d0416ea026ccf0026ba7123b8a9b65f968a80d928e3a",
+    "src/CelerisLab/configs/config_lbm_three_cylinder_triangle.json": "eeb8e7149dbe4aa6b3a9562802735aa950750dfbe2d972a0727e788573afa817",
+    "src/CelerisLab/configs/config_lbm_flume_trt_regularized.json": "f4bba8e6a4339fc3c4eb14f6e2f57c4b22993c73703c773d853edfbe34736e56",
+    "src/CelerisLab/configs/config_body.json": "055f261f0828ca1d4f2bb694bd15b72bbcabe31d552326208f28e37f761adab1",
+    "src/CelerisLab/configs/config_lbm_flume_mrt_zouhe.json": "8f593321db05a563a42931603a228d61cbcba06dfbe113262d5cd0ad93c0fe79",
+    "src/CelerisLab/body/objects.py": "d1cf7054cc8379a83c39acc66a7c88ae62fa004f110bb0c1def2ee57137401c5",
+    "src/CelerisLab/body/action_smoother.py": "b1a23ee6bbd4850b172cb8738c5c3546ee465a54189e6af9d8044f023d4687dc",
+    "src/CelerisLab/body/registry.py": "fbb7327780adbdc6da15ebdb799980daf32df22ee974af0893d7409f177bbb68",
+    "src/CelerisLab/body/manager.py": "6a40be708c71ef6f3b5f5f0aa9c92cfafc51f2ec2a958f99656cccb850986c16",
+    "src/CelerisLab/body/ddf_patch.py": "60fcfb7441e73bf290bcff41ca3a83da3e7ddad765d7247464e8f02e3043b4e2",
+    "src/CelerisLab/body/sync_plan.py": "a73ac9ee361b2120d0b7bbebeaa2ccbf924ba27bd95d4dd4b383c10a39b2a409",
+    "src/CelerisLab/body/__init__.py": "91d1155080b3ade83d13c84c39693046df122e4bed5ef583de2df1f9453c1b76",
+    "src/CelerisLab/body/preprocess/flag_overlay.py": "831fc9e9736b758847759a085ff133eb49ec91318ace4fda76f85960138ee300",
+    "src/CelerisLab/body/preprocess/__init__.py": "dfd9d58bc07f626ab23a70053e31b88a6d9165d2e4c76a4e9f48abe674d3d2ec",
+    "src/CelerisLab/body/geometry/base.py": "cceca14361ca2f34d34a3e43730e1a79b8ca81be00f0dd62e884db32b479419f",
+    "src/CelerisLab/body/geometry/__init__.py": "ada88980ab672959aca9aa3a4c4aade3219524b2ab68110cd2a2f41e3e0ca90a",
+    "src/CelerisLab/body/geometry/circle.py": "7605ca7c21103f1d801ac73ab8dd18dffbdac425b2dee7b8858b283628a9e436",
+    "src/CelerisLab/body/coupling/soa_packer.py": "8ec26fd55ef74801bbd5ab6bd3d0a7dabc750cbd498aaac2ca4c61a0108ad3c9",
+    "src/CelerisLab/body/coupling/__init__.py": "c931f7eb318d48408c3e2febcc6917c88c8dcc1697cbf4329b1f340d94c35763",
+    "tests/conftest.py": "fa0ec26667872c9c1011d608310d2551fd24719b5d216f06d923ff4c74c73237",
+    "tests/specs/exp_ctrl_matrix.md": "5d9dd2e703582572eb68afe3a7096ea43ec82aa03418d20ed283c5365031e433",
+    "tests/specs/Sah04_validation.md": "1d122d29e281b7f50801b148f3314a0e35fdc27ee7d757c0a661243aa6185fb0",
+    "tests/specs/sah04.md": "33dbe5e0fd63738abd055c4aa403c191b6de04e6efdbc568f1942c6d23c7459f",
+    "tests/specs/Kan99b_validation.md": "0d8bf74f2361f863809af1979bf8807adaa423f98321e1104a3d86d8c7a863cf",
+    "tests/specs/kan99b.md": "b7e0669f0a6b677d902204f3427d1b3ac254bfe70c37d9cf995fb3e8f1fedfb1",
+    "tests/specs/streakline_notes.md": "cd342d214c07eb608ac2e5b8697322c44c31dbf4d27dfdb5409de46ef474df4b",
+    "tests/validation/run_perf_baseline.py": "93dde2eb1132f45ea69e1e285ff421dc97a83651a22c79571f299c1909650721",
+    "tests/validation/run_j1.py": "51b758a271ff358f931b3140a80082294a67e66c2fec0f8c19319e37f92aadc4",
+    "tests/validation/run_kan99b_rotating_cylinder.py": "323186429a100f36b41ab9b81ade2da6a47e93be3ccb7034a3a6b97f4ee8eb00",
+    "tests/validation/run_j2_slot.py": "b7d2d3aa06fcafc3ac62ed4a50892afbdb7f86e5720ce75a39ce317b6f571dad",
+    "tests/validation/run_j3_coverage.py": "329869519b7078e854d96241a7aad8ef93f35ac9be83f0be502c3a93523c3b13",
+    "tests/validation/run_sah04_st_matrix.py": "9b9c0ce063e07a316846635ee769b837ed26be6bf039f78f4219c10b516f8006",
+    "tests/validation/analyze_j3_saved_frames.py": "438f67dac682b94c4950626f8de4fdcde48c3a4e9ecf8fdf1b0ada4b6e0e781a",
+    "tests/validation/diagnose_j3_lags.py": "286fcd65b3261667a847b9b26e213d0af92cf459faa6bbd774f78c8479ce31d7",
+    "tests/validation/run_j3_reservoir.py": "47535bc3569ce68c888d38978bc4f9077fd763a17829c20c081be52bb18a2903",
+    "tests/validation/run_poiseuille.py": "e529288e2ffa8e00d281a9006723954d60a96ae4d025e8f28656c09287d4ff46",
+    "tests/validation/test_sensor_accuracy.py": "c6038a9e7a597a1738814bd15e6ecf357cfd271cdc2a132d47943c5280ac0ef9",
+    "tests/validation/multigrid/test_cpu_reference.py": "ade5d4827f971aed7174b59d83769e7aa542338e625a9fc8db1e8b1805cb74ca",
+    "tests/validation/multigrid/cpu_reference.py": "bba2a06a9f6517b32079ffff15e4060d8c3b7ed35f16ca134e1877226c9e4e1e",
+    "tests/validation/multigrid/cpu_reference_v0.2.py": "b6adbad7da625ef6a6b97958ea9625030ed92676d0cada48e061c87bcf7ca8c9",
+    "tests/validation/multigrid/test_open_corner_negative_control.py": "59a6f8ca80cdd63cb7827fbebf9b4b555c3793f19dd6bca801544ec10b5cbe1b",
+    "tests/validation/multigrid/test_refinement_followup.py": "6643e26cd877bf0d0f030e974f00a1d1c0f0350cc76d1c8affed3e8ba2f4393b",
+    "tests/validation/multigrid/local_stress_observable_v1.py": "0e2777990359a7cf2bb29884173b7b01de37c49bcf49e1f29fc59fe83d62b456",
+    "tests/validation/multigrid/test_refinement_gpu.py": "0021a39b3a131347196845cff6507c90c387b46b772fe1319d634178c5e13354",
+    "tests/validation/multigrid/shear_diagnostic_v0_2.py": "a8b1cf2f7abd00efc4d068bbd27bb2317144a6ca4c545d9b2e0dcf421eadebc6",
+    "tests/validation/multigrid/test_tron_additions.py": "8e7a6a90b85e64c7326719e7b8bca2f6d34fb4c80690f0685f7e291ab93bd2a4",
+    "tests/validation/multigrid/MULTIGRID_VERIFICATION_STRATEGY.md": "d4f3473da44abee6031a0e1bd4d0ca589077a18f15d2461836e4d2ebb98e458a",
+    "tests/validation/multigrid/shear_v0_2_evidence/stdout_horsea.txt": "0577df5b3f5cb3c7b6e1ef2de71344f8fd3e6d959117487a06cbaf7f2afa3dea",
+    "tests/validation/multigrid/shear_v0_2_evidence/stdout_grok.txt": "28ddd1267ca91a772f5a6bfc65d949c9a4ea7dac5c9ba3a0bdb168492810b670",
+    "tests/validation/multigrid/shear_v0_2_evidence/run_once.py": "6698a2e040c56be949b809387d4518eb0ba82d34cc9d99640da4f8bf3c35c23f",
+    "tests/validation/multigrid/shear_v0_2_evidence/source_manifest.json": "56fbd0259ff3d4dbd14ace52f64e249a435e9df91732b0e4027def2c344c2e6a",
+    "tests/validation/multigrid/shear_v0_2_evidence/results_horsea.json": "c2d7ce8d16a0f47baff0788a153353dcf67088da974d9cd3d521b04ecd91ee05",
+    "tests/validation/multigrid/shear_v0_2_evidence/comparison.json": "41c00372099dd04b6d323785e9eaf4fec09da1753d3d150ffa230800f904142f",
+    "tests/validation/multigrid/shear_v0_2_evidence/baseline.json": "98a7853341ea732762c7506694e3a867a7259bf110e9e461ea84f741fd9ab829",
+    "tests/validation/multigrid/shear_v0_2_evidence/manifest.json": "e42aa19e91608164698bea42da88fbbfab8b0f87cc37b27c5baf165453a4fdb0",
+    "tests/validation/multigrid/shear_v0_2_evidence/README.txt": "4306a34b6896bd6e7a5c2ca71d68e18450359239d0c7ad7a67a4e83e7155959a",
+    "tests/validation/multigrid/shear_v0_2_evidence/joint_report.md": "1860b8082108c8b8a87998af90cd0b81dce1c04e9f6c67b41e0912f9fef6cc9c",
+    "tests/validation/multigrid/local_stress_v1_evidence/stdout_horsea.txt": "882f2cfb1dbdf82cce63c011397e7c2e6307bbcfec42a3510648d328cd6ddcfe",
+    "tests/validation/multigrid/local_stress_v1_evidence/run_once.py": "e629800291ef65ffea8555f66ec80bf15200552540b2a493a677bfb53d0830b3",
+    "tests/validation/multigrid/local_stress_v1_evidence/source_manifest.json": "d2cf90b73458f493c665c9a281d06aef0c190cf0d143639fb77ab838c78f020c",
+    "tests/validation/multigrid/local_stress_v1_evidence/results_horsea.json": "f17b4644d19eb75d55deb7021ab679cb9e7922a2b46f1cacf8b6da6bfb9a2690",
+    "tests/validation/multigrid/local_stress_v1_evidence/comparison.json": "be236671a501c31c06f7e266f6e0c0c2a89aede321a483452050ff37bf84c84a",
+    "tests/validation/multigrid/local_stress_v1_evidence/baseline.json": "64f6541447afbd15b1b15d802ad6f1b5042aaf84e7d4d2414e4ed4c52cf70507",
+    "tests/validation/multigrid/local_stress_v1_evidence/manifest.json": "3a9fa8c7d691c1b8c24f05940eb724d30b890dd8ed636551068d2633d7db2f70",
+    "tests/validation/multigrid/local_stress_v1_evidence/README.txt": "4f62314876047ee437bb9ecbf84798d2a9f6e85f6a3aef260277b85bcdb35fae",
+    "tests/validation/multigrid/local_stress_v1_evidence/stdout_local_stress_observable_v1.txt": "6a826e5ad729ce45af6879a07a1c659d8b4a21403fde5b9c6d9696cc6a5b09d4",
+    "tests/validation/multigrid/local_stress_v1_evidence/TABLE_local_stress_observable_v1.md": "d8ff0568d9c473a4bb09396a8948ddc8dc5af2f0f3a23ac84d238814fc779501",
+    "tests/validation/multigrid/cpuref_0_3_evidence/stdout_horsea.txt": "457f1d2173496554c87ca6e61df518c0b8f1e0a28cdfd94b94ebbb61bc459d70",
+    "tests/validation/multigrid/cpuref_0_3_evidence/stdout_grok.txt": "73e4ef01138842981daaa534390f1463839e63833c11f4e8872f94f8eaadc717",
+    "tests/validation/multigrid/cpuref_0_3_evidence/results_horsea.json": "914389afc39752bcd4132aa21fc8d5cbcf0ca75b1efd6a49becab15c2fa3361b",
+    "tests/validation/multigrid/cpuref_0_3_evidence/baseline.json": "0daaccee41cabeb17a00e2405e2c7fd0b80d36f2d01778eb39c9fd22b13d2d47",
+    "tests/validation/multigrid/cpuref_0_3_evidence/manifest.json": "2850ecaf2e19d010ba35eb54162371d82cc1a092831e08a03b6adf75a614988b",
+    "tests/validation/multigrid/cpuref_0_3_evidence/README.txt": "1947ee0232b88b3cc2c506d0b0af5ba051ecc94aa8f7f09228ef3939cc95919b",
+    "tests/validation/multigrid/cpuref_0_3_evidence/README_grok.md": "065947e15b2242bce7d3eb05a3acdbb59939c621dcd5d31540ad4a1bd4416818",
+    "tests/audit/\u5ba1\u8ba1\u62a5\u544a_kernel_layer.md": "89893c98ed7c2699157bf728ec0e79b0dd6aff4008ee5c7b77eb052de24033f1",
+    "tests/audit/body\u91cd\u6784\u7b14\u8bb0.md": "8f978d7b01c9f49dca9eeaff0d163cec6da085e2f99ee5a5e803d72306e7a72f",
+    "tests/audit/\u517c\u5bb9\u6027\u6d4b\u8bd5.md": "9c1721a33b381b9c3810545772b022913da06617711b5ba13a3c2c991b81a7f7",
+    "tests/audit/Force_region.md": "3092080afe4a30665fe1b721803621ba9d0dd5d20ad17826984d94efc160fdac",
+    "tests/audit/\u5ba1\u8ba1.md": "0f14ad073a0725134e6391f961c324fd0013c7791fd410713e94ed1ad40b7385",
+    "tests/audit/Force_region_validation.md": "279a4484d1bfca0fd67aed4de3282d547aa048f89389420d8e5f2fd86db54fc2",
+    "tests/audit/body\u5220\u51cf\u529f\u80fd.md": "e9f308a8cd0f0e7df5441c32a15f84c0bae50bc0e56b8728f6c6f2cf78596673",
+    "tests/unit/test_initializers.py": "8b4e3358d925614984265ae73c142006b48fd1c3918cf84901f18afd9fe68c3a",
+    "tests/unit/test_simulation_lifecycle.py": "77abdc33218c35e9c8b62dbd99ceddbaccd8417e7f0b539ea8859ea0175c663a",
+    "tests/unit/test_numerical_operators.py": "6d1d560ef553a2af7adac7db3e325d96d7fe39073d5fe3e0e982439537385b27",
+    "tests/unit/test_sync_plan.py": "983313ef783143231fa5a392f85f3bac011184773ccaf5d946504c206cabb721",
+    "tests/unit/test_surface_actuation.py": "89be6f54c4eba6c2bdca0d287a5b9fa6db143de2bcd9a671d4fb8445921303ed",
+    "tests/unit/test_state_regressions.py": "0f69cfeb83428192f95688c76abcae7e5b9cf5f27c52bca4ac20c7f320044374",
+    "tests/unit/test_equilibrium.py": "1ecbcc4547b1c846b75320463d828d6a36b6aae73208084fae476b1001c1bb50",
+    "tests/unit/__init__.py": "17f57920d9c1ff46096ceb2af008eb38c4b98dc81ffa3c3d310e758e80ca1cd4",
+    "tests/unit/test_pending_edits.py": "905a0dff23b123e8e38aaf364984c810fe51c39acd64aa271e343a4701d3d024",
+    "tests/unit/test_planar_velocity.py": "b656da0880b4234b1db805544edbe0d2473cbcc7c2c869c71d8251337f62a982",
+    "tests/unit/test_body_flags.py": "ac6409157924e15a13a3d2cc2f1a09014b8b0198ba17c824f412ff20b19e2aac",
+    "tests/unit/test_build_contracts.py": "7bb237425e8bb481f312fa4841c484e280731e13c7cbb9a53dad3e7f98984ac3",
+    "tests/unit/test_context_ownership.py": "299fed30dd0f9bd4dadd8b27f50df2a6367bdb0ab2ca3f391f215fde7241f35a",
+    "tests/unit/test_reservoir.py": "e718c78a53c3941aba7feb8ae4e8bb0b1726c1145de84febf91220c1917991c9",
+    "tests/unit/test_refinement.py": "90751142f920f1c5e988577a45afa94871a6617009cdc78323a87fc7795f4634",
+    "tests/unit/test_slot_velocity.py": "6a9494de9a32c350389ccbed58af48951f6b25a21a258537d2e8b73eb67cb11d",
+    "tests/unit/cpp/semantic_regression.cpp": "99dba074c0c0a32ea76026e7d54fc60af8e6d3dc5315c8900c470b4518878f39",
+    "tests/unit/cpp/reservoir.cpp": "c3eacaf0271400eb45ad559b571a8f7faa2a809d5f1857ffeb5592addce2cd0c",
+    "tests/unit/cpp/collision_regression.cpp": "f17acdff74ab82a62dc5402b42e3f6a149c262e89b140494164d6ebd630f5e14",
+    "tests/unit/cpp/slot_profile.cpp": "31ac58ccab175bf79fa59fc46d4c0842df18ab0a5e5916be84760d9da2b75788",
+    "tests/unit/cpp/planar_velocity.cpp": "8dea266984edc69d4e0e68007e038d7a587e99f84e33478d6656a66a56680933",
+    "tests/integration/test_body_sync_e2e.py": "d29f01771f3512a4b3ad06fae4ee952327d7fd9f0476942402fe92e9e327fcec",
+    "tests/integration/test_sync_bodies_skeleton.py": "65f55a0980659b49ae0027f0642a27e2ebaead226ef083f233e878150884b07c",
+    "tests/integration/test_numerical_gpu.py": "002a6745929bd5ee86a9491ea9bc3f97602fb825ea17262ea190c9311881100e",
+    "tests/integration/test_ddf_patch.py": "dda2abba32ca13e17098232f2831a0b1b66439c35f8931d9997a0257250c1281",
+    "tests/integration/_cases.py": "ab76ca1096d2d10fb05b3539aa8ed3c7e549619bae6900ac98723f6c3c908f2d",
+    "tests/integration/test_surface_actuation_gpu.py": "3c2b4dda70db1d6493ecd92bd9b0dad6d8b438cdf6dca46410018217f8beb4da",
+    "tests/integration/__init__.py": "c354e43ba09b55a8013a2df2069438740b5f48b5917d855e52e33ab5d7da5a6c",
+    "tests/integration/test_state_gpu.py": "dde0948941e8abbc5ea10a3acb3a35abbaea576f36ecee0f1120fbcf7454d60b",
+    "tests/integration/test_runtime_contracts_gpu.py": "775e578e2e8072af32fc740b2698abbb79454235a0f3ee929ac4c75d747f8db5",
+    "tests/integration/test_unified_obs.py": "4a681536099741d92bdc258525fe3374cbdbeba0d49996e53808381a1b6a13fa",
+    "tests/output/exp_ctrl_matrix_streak_ny300/summary_C4_deceit_f1p5.json": "11dab8440d8c4f385061d2536403f4313c6f026b4e0b7672681327a9f4f37ebb",
+    "tests/output/exp_ctrl_matrix_streak_ny300/summary_C6_deceit_f2.json": "e0c4e8bcc55da5dc8de1e2fe88029aa3e67453734faa44451f5a6dfa9131557f",
+    "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C6_deceit_f2.png": "e0a66708ce2a29c4c6b854d2596b3ffca181dc6e35d99cc94e08af3e2d8c024e",
+    "tests/output/exp_ctrl_matrix_streak_ny300/summary_C3_deceit_multi.json": "24c8e433aab6d207dab67546c4079868c4244c2948c32c94cd08e4f331991807",
+    "tests/output/exp_ctrl_matrix_streak_ny300/summary_C0_no_ctrl.json": "cf3af733a08f081cc5f879e8da79d7c60104099f4452af5b2a4a96c0e6bd5889",
+    "tests/output/exp_ctrl_matrix_streak_ny300/summary_C5_deceit_multi_f1p5.json": "a4cb4ff4481b39b9ee61b1d7209416237a7fe86b22c5068d713ccec9c3f7afe4",
+    "tests/output/exp_ctrl_matrix_streak_ny300/manifest.json": "d8a20dacc92321d98354684976f771a9ca8989fc63ddcd78e15c7768c6617671",
+    "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C3_deceit_multi.png": "c6fed617cc6ffe6677157a9b58811d5f4613725eb98a5aec830fd07dc1aac38e",
+    "tests/output/exp_ctrl_matrix_streak_ny300/summary_C2_deceit.json": "7526a6b20a158461b85b1a64070b46c2b21be1e01c5ee025e6746fcf47ea3397",
+    "tests/output/exp_ctrl_matrix_streak_ny300/summary_C1_stealth.json": "63d34a0ab33e9fa8fe7311363efbd1b2875691f5b4958bb645b8c7ac38f1ad6b",
+    "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C0_no_ctrl.png": "0cfd7ce8f9d743bf22a7a694b4e5a3616557cb8f1db2f4ddf49cc4bef96efef2",
+    "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C4_deceit_f1p5.png": "4dcfc186928dcb83d28e9eb4cb2ecb4b163eb6f121d57036b4c05ab162be0951",
+    "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C1_stealth.png": "5e3cbbefda06fcef243d7d06d74a473972350cfa4ae88bdfdb349dce13943151",
+    "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C2_deceit.png": "22f1db77499bdbd1b3cd35f5b58b1a884dd94a86fdcfef07abd4157e6aaf8d19",
+    "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C5_deceit_multi_f1p5.png": "823e475cc901af3d6f4d0c56eb07822b3e73a2b9d0aa23e20e3741023fe90092",
+    "tests/output/kan99b_validation_esopull/summary_runs.json": "fe3294a953580204319fb1143434e15096d8455b6073100dfe0d5491b76af394",
+    "tests/output/kan99b_validation_esopull/summary_runs.csv": "1a44bb27ee0a7fe0270905248c37364834248cdc8710bd68142a6a79bbdad82b",
+    "tests/output/kan99b_validation_esopull/force_csv/k2_k2_inlet_control_domM_re100_a1p000_zou_he_local_mrt.csv": "9fbc7d507c129ed85c68a9a313e3eb3431470d091bd7723e63f8afd8a3d2b737",
+    "tests/output/kan99b_validation_esopull/force_csv/k2_baseline_domM_re100_a1p000_regularized_mrt.csv": "8faac43f42d6e0c70085c6e616bfff4df8de897e315fc0d2b4aa8bd635c3fa05",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C4_deceit_f1p5.json": "b613ae55fcfbd45a1a922d6d529e5274ba9d2987fdf5620fe866b889b931e48c",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C6_deceit_f2.json": "dbf54f9a183072547b22fa14334f0167e6eefb21c1208c4e8584bc196545a399",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C3_deceit_multi.json": "2100c6cc5c358a249804ce8f6f98531f3bc868e27af6d21a9d441b1b6a9e479e",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C0_no_ctrl.json": "a8b4697b7c0caeb958f80e282e32d673deac8c914008d64e6b38f7883eacc57e",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/state_C6_deceit_f2.h5": "8d0c28566d2230b422691b738cc453705496bd150be038a576c0c0fba218fc1f",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/state_C5_deceit_multi_f1p5.h5": "608767ca11d104fa4506b57204a0c8dbd739688224ebd924fe517ce9e21db823",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/state_C1_stealth.h5": "a83c988cc8b1173a7b2f13b132ed7243e98304dccab2965aa16cf4d32f8df007",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C5_deceit_multi_f1p5.json": "6f6b9300782178e0ac9308a677bd9cb1565a383a78dff4cd52dea0bd464db31d",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C6_deceit_f2.png": "21bbe2dac1ab06ca1b172ec62d00daa7bcd65d99adac0ed03c5e30bed59e871a",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C5_deceit_multi_f1p5.png": "602a6586277699968b4cb167b134c8c406577038af088aa70baff682691398c4",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C1_stealth.png": "c1e1d04f266deac5fb2815a8283da80f9139ffaccbec2219d98544296bf3152c",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C4_deceit_f1p5.png": "96dee924e89b90091192a8d7b43321f109a5491511b8a83da77cfc611ae0d93b",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/state_C2_deceit.h5": "aa5800a0cd594eeb7cf5449d6469d55e0c9033ced0ee0a3b5d59152e68c7e263",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/manifest.json": "5d28f0f5428d7f0341e20d5d1f19c17bbc6f0f9b2a441d3c95f5422f3f2b4bd4",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C2_deceit.png": "1dcb6fb959f944d7ad89c4abaaef4d1fd4a77db8901804530e86fb336b883eb5",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C2_deceit.json": "b88ff5049aef59876b349d105f1c3467c17c9ba9022a48a77a6984f20da34345",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C1_stealth.json": "515689cbfaa30a9e39d9907939ee194a4836b644a5e9124586e6b7221d2b394b",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C3_deceit_multi.png": "d69694a1a1b2f2ea0adc7b74b7526504e2ad0b5d6317bac9b3159b2e7e88cf90",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/state_C0_no_ctrl.h5": "3a858d6be0a946e1d26bbfa192c2f0ca3910c0f140b42575ec9d9529dd99155a",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/state_C4_deceit_f1p5.h5": "660e4619ea530dcd18c3afb2e7fa22cafd9cdba1be7888e31ab5b76a0902d2fc",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C0_no_ctrl.png": "6d4d3934f1c8b20c2a5c742ae080a7143f0c139741966adf009a227c27e9bb1f",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/state_C3_deceit_multi.h5": "1e72126f11b2995437cecb8cc0eeffb8807efbfa43d8f346f28711fea98ddc90",
+    "tests/output/kan99b_validation_ref/summary_runs.json": "449316c30585a8de9997538dead5d4e35a59bf00a2ac22d01b101ab600a4bc06",
+    "tests/output/kan99b_validation_ref/summary_runs.csv": "e8b9620f3772e5e421026103e456e6e844a91292f40affb96174c9dbde9b6e4e",
+    "tests/output/kan99b_validation_ref/force_csv/k2_k2_inlet_control_domM_re100_a1p000_zou_he_local_mrt.csv": "4391f41d17ebeea1092f13b901923ced4ee2a1c5b346b79ef791d692847286b5",
+    "tests/output/kan99b_validation_ref/force_csv/k2_baseline_domM_re100_a1p000_regularized_mrt.csv": "105c6eb21f1943d9d935246eab1602ff2016c415a139e24fee2793e88e006ead",
+    "tests/output/exp_ctrl_matrix_vort_ny300/summary_C4_deceit_f1p5.json": "0085a679a423621003eea81d4ac83bfe2edef2879eed7809d2a3675a212f791a",
+    "tests/output/exp_ctrl_matrix_vort_ny300/summary_C6_deceit_f2.json": "e820cf73f0e90bf93c34b24416e7692a6c2e51352ccf490fa6714d0812331ca2",
+    "tests/output/exp_ctrl_matrix_vort_ny300/summary_C3_deceit_multi.json": "571370c74ad9af589f3dc214669bff3d857efe6fc4fa13815b5d793d12b53770",
+    "tests/output/exp_ctrl_matrix_vort_ny300/summary_C0_no_ctrl.json": "ec5b89961033d8ebe0d66ce1ec7940dc2faf98130c38319bc9984ef654e60b50",
+    "tests/output/exp_ctrl_matrix_vort_ny300/state_C6_deceit_f2.h5": "2792be74d8564fa29fd0636fc8493630fba2779c165b44330197095b3e296b18",
+    "tests/output/exp_ctrl_matrix_vort_ny300/state_C5_deceit_multi_f1p5.h5": "2c64ee6c7a4ea2c42ed8f3d274402bec62de0e02ea0340e16022f0cdc92af724",
+    "tests/output/exp_ctrl_matrix_vort_ny300/state_C1_stealth.h5": "100727d94fe6c2e46d7807eed0442555bdd1e26ec9b04b4c457171a2bbba3255",
+    "tests/output/exp_ctrl_matrix_vort_ny300/summary_C5_deceit_multi_f1p5.json": "f86166f121b4eeb6d74d8176c9265e7a3ccfe2540d040f554b6f96e6a6222c16",
+    "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C6_deceit_f2.png": "fef4de0e3ac8203742f35c16a02445b19c3f556b11f73abd5d8e3ca05ca33d78",
+    "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C5_deceit_multi_f1p5.png": "9136448e6d7565ca5af3666f9cf6e154342d8a3475076abfdbdd1ff9faec34f3",
+    "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C1_stealth.png": "544537a9c500a05937fd3be17c25e7d887461d9b83a15564f9ab7063208f40f6",
+    "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C4_deceit_f1p5.png": "51e7056db99dd653affbe913d52fa41df6ec0db921109384e3c679bda06b5a83",
+    "tests/output/exp_ctrl_matrix_vort_ny300/state_C2_deceit.h5": "39d6c162085acae1612650da37d2314757715931e83a854e08bb01407d0f8efc",
+    "tests/output/exp_ctrl_matrix_vort_ny300/manifest.json": "05fbc2e7bbad4267a38e1094bbdd6bee6ad270412bdb5e92b0dfc9fa56969517",
+    "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C2_deceit.png": "07fc5817eba30371272b87ee2e023c0a1144077d1bef77efb2fd5dc284badcb7",
+    "tests/output/exp_ctrl_matrix_vort_ny300/summary_C2_deceit.json": "b1fcf76039c91a9080b830352dee2e95316d754b968cc27a8f68c51527661e76",
+    "tests/output/exp_ctrl_matrix_vort_ny300/summary_C1_stealth.json": "b78851637b9b7b93070524a2933cae1dab6d682f8894579b2849c64921e6c29e",
+    "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C3_deceit_multi.png": "2658f0747ed7287f7912fe15cc58a086e01ba284277cb98689bac01ecb6ec12b",
+    "tests/output/exp_ctrl_matrix_vort_ny300/state_C0_no_ctrl.h5": "57f73f5f8dc4b32b156bc82300b1efd1e4eddadd9b8dc51cb7e6b41fa5c966bd",
+    "tests/output/exp_ctrl_matrix_vort_ny300/state_C4_deceit_f1p5.h5": "2864b9dd086709ee8b8c3f262118a5130b0d40c86838f3ca0deab5bb898dafa8",
+    "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C0_no_ctrl.png": "2c7f3a8be2ee540afdfb66299e43a65583434bee84bde590124524a82868c900",
+    "tests/output/exp_ctrl_matrix_vort_ny300/state_C3_deceit_multi.h5": "39e0d9b032dfff8cf057b410a98973729285e7d03e89f9a6a002aaf7de3d7519",
+    "tests/output/stealth_sweep_fix_check/summary_stealth_s150_w0.02709.json": "8b1032e13975bb05c6a810fde175c8da51bacdb3dc745fd11c1049ca63bbf136",
+    "tests/output/stealth_sweep_fix_check/summary_stealth_s050_w0.00903.json": "fa7da24d5dab9fd3a3c2dea6b50d0224c7a99cd9141796e137304a6040b1ac8a",
+    "tests/output/stealth_sweep_fix_check/streakline_stealth_s050_w0.00903.png": "640928f7eb159e7caea32036123f86c281723d083cca46839ba86bce8361ada7",
+    "tests/output/stealth_sweep_fix_check/state_stealth_s050_w0.00903.h5": "187ac365f9f7370c888c4c65570c47e42465b2fccd432056c176528d45cf0c2f",
+    "tests/output/stealth_sweep_fix_check/manifest.json": "83a3f12a942fb644e470bd07a72f24921f2147d7df429110268c5c96a9953d1a",
+    "tests/output/stealth_sweep_fix_check/state_stealth_s150_w0.02709.h5": "e057e9db26b2546c0704e2c959cc7d2aac91e6a49b4c7ee75a409597a5db8716",
+    "tests/output/stealth_sweep_fix_check/vorticity_stealth_s150_w0.02709.png": "d2d202088624cf30868228f9c913ee30e1b386aaa2c22b0ea89be43dedc0712d",
+    "tests/output/stealth_sweep_fix_check/streakline_stealth_s150_w0.02709.png": "0edc7caa9caaffb754490bf1f6ac7ad7180e45a991439a3f4f83ed949a082a1a",
+    "tests/output/stealth_sweep_fix_check/vorticity_stealth_s050_w0.00903.png": "4088359b17c46ed4d7c8401d244808fe67723273b1d16d0671b69f9478c68c1a",
+    "tests/output/final_validation_round/validation_summary_report.md": "881cb7052e5a555afc87168a37268ee66e8e3fba172533706e858d996fabc7b9",
+    "tests/output/final_validation_round/sah04_mixed/s2_d48.json": "83c6c01201d90aae5c49e73ebeca88d1c7ded6cc83c13f4892a9188e6289483f",
+    "tests/output/final_validation_round/sah04_mixed/s4_reg_d96.json": "b32f03e6b347fc709cea2ecd488df0f85849c733bf6a4b9cf65ea69401c93a1d",
+    "tests/output/final_validation_round/sah04_mixed/s1_d48.json": "120e8e878f5712dc89b7cf78c7f8d0e3368d34ad5ef7494977e083b188a54c18",
+    "tests/output/final_validation_round/sah04_mixed/s3_stablecfg.json": "b38a3d197a188e65c163d974113af18f332b3abed083e2654e998d9980f6be9f",
+    "tests/output/final_validation_round/sah04_mixed/vorticity/s3_mrt_laststep.png": "dc96fcd05d458684cfb40d4cb741172213083e2f2665e2bae7e1f0267bb3575d",
+    "tests/output/final_validation_round/sah04_mixed/vorticity/s1_mrt_laststep.png": "73a3580ba3c7fe6ffeee4676a9a51b5bf678d6fb523456a61e185598389ea1e1",
+    "tests/output/final_validation_round/sah04_mixed/vorticity/s4_mrt_laststep.png": "57f2a82761f2de1a9fc2b78ee86159ca542c966494b9c704deb451da857da778",
+    "tests/output/final_validation_round/sah04_mixed/vorticity/s2_mrt_laststep.png": "786f492b96ed932254b5452e2d06ff088727f2d88c7e7c7b47d386eddfe07862",
+    "tests/output/final_validation_round/kan99b/full_summary_runs.json": "8c4a11cbf555e08a66698439170b850c57d537d8e75e4dd75beb767bbf7e38cf",
+    "tests/output/final_validation_round/kan99b/summary_runs.csv": "3fa92fdd3114f0472de44bc03006af1d4b694dfc69b06704c1667cd3627b6dab",
+    "tests/output/final_validation_round/kan99b/force_csv/k5_baseline_domM_re160_a2p000_regularized_mrt.csv": "de05e9699146f2adffc9d7c9991f9e48396aacd142afc3c08b2b64727c83c69a",
+    "tests/output/final_validation_round/kan99b/force_csv/k3_baseline_domM_re60_a1p600_regularized_mrt.csv": "53cd0dc47328b7b370eced1130508655e6815a29b727bf1fe4e4e125e4918905",
+    "tests/output/final_validation_round/kan99b/force_csv/k2_k2_inlet_control_domM_re100_a1p000_zou_he_local_mrt.csv": "4cac1ccfdb7451de3e26d921a6406cc55d1d4630e10ec0d7ec9350a4abd49404",
+    "tests/output/final_validation_round/kan99b/force_csv/k4_baseline_domM_re100_a2p000_regularized_mrt.csv": "392c98de52011ddb344a5761c4520e870f4e49bbba3e144e5a02818ba2f9250b",
+    "tests/output/final_validation_round/kan99b/force_csv/k1_baseline_domM_re100_a0p500_regularized_mrt.csv": "9e83c5175aec644c0b97c081e610deefa731b87aef04da6297abf662a71c0702",
+    "tests/output/final_validation_round/kan99b/force_csv/k2_baseline_domM_re100_a1p000_regularized_mrt.csv": "55b071f278e153aa353aa2bef85f0bce35b910a7b08103032023fe3a28169b89",
+    "tests/output/final_validation_round/kan99b/vorticity/k2_k2_inlet_control_domM_re100_a1p000_zou_he_local_mrt.png": "b91b332e7deb787975d3f08fa3325facd4a972b536694fcda52e6c01943c42cb",
+    "tests/output/final_validation_round/kan99b/vorticity/k1_baseline_domM_re100_a0p500_regularized_mrt.png": "6e7c3f6567c0ff0d00d75da8373031f5ba2a17a624cb8c5d5d6ae4f8749c33c0",
+    "tests/output/final_validation_round/kan99b/vorticity/k5_baseline_domM_re160_a2p000_regularized_mrt.png": "c4d232df2e6f7466acca711191d976aa9411ec0ade81572b531463f42a7d633a",
+    "tests/output/final_validation_round/kan99b/vorticity/k3_baseline_domM_re60_a1p600_regularized_mrt.png": "b2314c60491d20933422e1697998555dec2436d39545c71f990e9906884685b2",
+    "tests/output/final_validation_round/kan99b/vorticity/k2_baseline_domM_re100_a1p000_regularized_mrt.png": "2b2797b8f53170d04d1a70d1cdf898f7e41b3a76b9f3c1f276dfec952520ab04",
+    "tests/output/final_validation_round/kan99b/vorticity/k4_baseline_domM_re100_a2p000_regularized_mrt.png": "8135f470404fe11ac97968fa580ee35232e90dcace3c6ad94de17ef7aace24d6",
+    "tests/output/kan99b_validation/summary_runs.json": "d7239aac64884202558741074f2d644ade9e2365d94d0b7556fba68dac94868d",
+    "tests/output/kan99b_validation/summary_runs.csv": "c44da69563d58b917291a9fd402d1f57055861bffab6f9e32d7db91297428d45",
+    "tests/output/kan99b_validation/force_csv/k5_baseline_domM_re160_a2p000_regularized_mrt.csv": "27b64460923d235d34b760f2a2371ad01611a70e38edb03d6fd6a2fe7a7de6e0",
+    "tests/output/kan99b_validation/force_csv/k3_baseline_domM_re60_a1p600_regularized_mrt.csv": "76ff52f4494b7ef7650c05968732a8caaba94d2b151234c02cf624f5b3a712ab",
+    "tests/output/kan99b_validation/force_csv/k2_k2_inlet_control_domM_re100_a1p000_zou_he_local_mrt.csv": "28a83436ca8bdad38865ba21ce1bda679562a5ae1cfc6ee8fc6e86ff760ec66d",
+    "tests/output/kan99b_validation/force_csv/k4_baseline_domM_re100_a2p000_regularized_mrt.csv": "823ae04870fd951879024a18169ac5cba8db4b3201726f6a00f320f1958d04c6",
+    "tests/output/kan99b_validation/force_csv/k1_baseline_domM_re100_a0p500_regularized_mrt.csv": "a591daf2cdecd6ac3689fa2a2aba917b23053ad26e3ef1f635c81aecc451475f",
+    "tests/output/kan99b_validation/force_csv/k0_baseline_domM_re100_a0p000_regularized_mrt.csv": "e95c27c646c0c9baf8f455f876c115c8dbdb23cef9d9d550f455098bf0c03b55",
+    "tests/output/kan99b_validation/force_csv/k2_baseline_domM_re100_a1p000_regularized_mrt.csv": "3c2ea79a0e27f561215febee2e165d24b3617a648bf908981c068ba59d549c51",
+    "tests/output/stealth_steady_sweep_nx1500/streakline_stealth_s125_w0.02257.png": "a892f18c74fe13efd839bfd5068097ca0ae07acebf6c06eed89e1b867e41fcb2",
+    "tests/output/stealth_steady_sweep_nx1500/summary_stealth_s125_w0.02257.json": "7e542f59746429022ce1794854c6fb36e8ac658dd0aea3bc1140a45e83a3f1c9",
+    "tests/output/stealth_steady_sweep_nx1500/summary_stealth_s100_w0.01806.json": "b76216e0fbee00ef754edbafe5790a99ce7d53638af629947ddd9615598e4c08",
+    "tests/output/stealth_steady_sweep_nx1500/summary_stealth_s150_w0.02709.json": "42cb241d9cfb01308ce28e129756b6cb3fe2a8e9679518da84bcb8b607fe92ac",
+    "tests/output/stealth_steady_sweep_nx1500/state_stealth_s075_w0.01354.h5": "558be308dbf334832bc1d29419ba5be142969117a11b124864f6b221c8fee509",
+    "tests/output/stealth_steady_sweep_nx1500/summary_stealth_s050_w0.00903.json": "53b579811a0b651ba7cc466c230c115b9f88486c6675e0465d0715d3377a75cd",
+    "tests/output/stealth_steady_sweep_nx1500/streakline_stealth_s075_w0.01354.png": "9f4a7d89b2471becaf31e84c14402441c5fd96fc7190cea5e8a9fdd06ee62002",
+    "tests/output/stealth_steady_sweep_nx1500/streakline_stealth_s050_w0.00903.png": "5f18f56b0ff2af3350216b65540a2bc664c569520624cfc6cc2439a3c5369560",
+    "tests/output/stealth_steady_sweep_nx1500/state_stealth_s100_w0.01806.h5": "30776f333959e0e9eb5ca96b269e6a8052c5b94941a4e3b36d8a6af8076920ce",
+    "tests/output/stealth_steady_sweep_nx1500/vorticity_stealth_s075_w0.01354.png": "b5393474d99191e88dafea4144b6a8eccfbdf75107125ce4b05383b17007d06a",
+    "tests/output/stealth_steady_sweep_nx1500/state_stealth_s125_w0.02257.h5": "4ed9d8587f75ad4625ec5501fa99fb733cde037180ac53f92a210ffbb08375de",
+    "tests/output/stealth_steady_sweep_nx1500/summary_stealth_s075_w0.01354.json": "ff1c1cc649e589b5425787493c2b0d04b6c39b43043b1968d65509cb0a426e82",
+    "tests/output/stealth_steady_sweep_nx1500/state_stealth_s050_w0.00903.h5": "4de51584b24095f8cf4480b8941593a5f913332f9396061ed077c9d49eb2ee11",
+    "tests/output/stealth_steady_sweep_nx1500/manifest.json": "0dfbb2c1b5bf9093fef169e4dc6319edb5c87a1e967e8d558613e2c64a2ca734",
+    "tests/output/stealth_steady_sweep_nx1500/vorticity_stealth_s100_w0.01806.png": "60824cbdf21170cb4ffd8af0a49e8522c2d79cb2694690ab67995ee973265efa",
+    "tests/output/stealth_steady_sweep_nx1500/state_stealth_s150_w0.02709.h5": "b22d54a05cbd3138a1fe585a825246989fcff7c00f51aa9312a4185d963db933",
+    "tests/output/stealth_steady_sweep_nx1500/vorticity_stealth_s125_w0.02257.png": "c1e1d04f266deac5fb2815a8283da80f9139ffaccbec2219d98544296bf3152c",
+    "tests/output/stealth_steady_sweep_nx1500/vorticity_stealth_s150_w0.02709.png": "bcf098083a73798dc3906807218058cc571435a010234a5a350b585ba9915c78",
+    "tests/output/stealth_steady_sweep_nx1500/streakline_stealth_s150_w0.02709.png": "3bac21cc75a01429399cec308d6bf5fc8918917def1bf5d7fec1cb6003390a41",
+    "tests/output/stealth_steady_sweep_nx1500/vorticity_stealth_s050_w0.00903.png": "a675f41df763f0a1ac0a06386315806b24f2571f5dabc8693fcd871a13ed22ba",
+    "tests/output/stealth_steady_sweep_nx1500/streakline_stealth_s100_w0.01806.png": "92515588596596cc1d691c643fa48cf828492c2eaed96355dcec58109de4b5aa",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C4_deceit_f1p5.json": "0393661f08b748428fc366eeecec3b34b9d9a013aa6b151a15b33c7e3c0e1818",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C5_deceit_multi_f1p5_step080000.png": "bffef412087e426b614d8c05e59bd7580ee49bb77319279ddc4c1bf825678c49",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C6_deceit_f2.json": "de067f01ef5c11249d67bbe5e02db6f2b4c5590214de02609bca115edf8dee64",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C6_deceit_f2.png": "846badbae81b75f765d89e5a7c4f88aeb5d57f2387511e4f2f84c72a192ea9f2",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C3_deceit_multi.json": "eb21d1c69e51f01c1a6be1ce59fe86763089ea5aa667b8872d0186af035b24b2",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C0_no_ctrl.json": "780a0d329cb86990a17a088f49084410abb1fad24f659255918e5ddda6b3dabd",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C3_deceit_multi_step080000.png": "ff7836b8229d9a5dd3900f499fe3e7f0c73a61c7109b6e6e79b11a0fb459bb63",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C0_no_ctrl_step040000.png": "f2b56a7e30bcc363ed69fc19705403181ac5de90800eef03039a389a65869e30",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C5_deceit_multi_f1p5.json": "261b698723f19526a447679a2be8666c8d0cbf6df81b0c9de6d051960d77308b",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C0_no_ctrl_step060000.png": "0697e0ae06a01154afdcf00330ba870bd8f36d21561a33846ad7ba63fb731179",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C1_stealth_step040000.png": "1de3d7f54e91c5d5850f4358d1872e16fefb36d32a1b6293facb54524e32315c",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C0_no_ctrl_step100000.png": "91f0bf6ed3e854f7f83623a3f19bb12c83b4aac239e3eaa849fbe50e7baddff5",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C0_no_ctrl_step080000.png": "303c1d2d4c49b4a7495365c8cb2bcbfe9bdda7cbc0a7c7dd1f01e8aa62b3573b",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C5_deceit_multi_f1p5_step040000.png": "dd5945458a35d81b31a0e2f3a693a5023d6960474263e7dc86c22367a56cc13c",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/manifest.json": "0d97efed02f775c25dd8a2d7439f310b715d142ff8d603c9da6ddab197570ce8",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C3_deceit_multi.png": "69022ef9175acf910374ec73848640548b85fc7beb7e6950843f52c10ed7d61b",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C4_deceit_f1p5_step060000.png": "16ba30b8cca0d49e6b76be0bb4f0d14bbf276ca6ec47ebf56907c7534e15c4e0",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C5_deceit_multi_f1p5_step100000.png": "8548b6dff635cf9c92e2baa119866277e3994366eb31aeb30641b03b3d80ee9f",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C2_deceit_step060000.png": "56100f169c3e378b84bfc89c5477d2c142ca043d9f28eaa70bc5448c49c7f4d5",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C2_deceit.json": "587cd42d81b1325bbc766d9ca6c1fd3d076bf5a772efd45d056c2c4e3db742b6",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C1_stealth_step060000.png": "e43e95e7126de8cb857154353f161914c225f8c9f17eb44b1ff744249368a4d5",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C6_deceit_f2_step080000.png": "676d21ffc7180d34a6725a8bf49503ce59f48d65500450c3975d01e65162899e",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C1_stealth.json": "73040aeb7ef07c538d4687b101c599210e660202eb1c2c3e0894dfbde682d137",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C4_deceit_f1p5_step100000.png": "e22171ef86979c4398c45ada9cd0f5e4c4e5b034f271df5fa8ac9a762a8554cd",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C2_deceit_step100000.png": "0d73042be73b0de8d0a591e56c01e3c802483aa22a97f27e0300cba82c708066",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C4_deceit_f1p5_step040000.png": "a6e95fd5c24052db20d5ece200edcfe5e261c00950ca964c89df9f7335579634",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C0_no_ctrl.png": "d74061347ac3505fad878e330f6cb04d23bdb13082bfa1afa2fda0872f80f388",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C4_deceit_f1p5.png": "3156400eb59fae0638556c2711345f12ca49d951ff09e6464a2271249409a6a7",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C1_stealth_step100000.png": "d69e34c82da98b28eef7f1af29f5d11f400e90f628049f6f5f4a3a419a4a4340",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C6_deceit_f2_step040000.png": "ce1f372b517dd52fc3f3eb066145e04ab6841e43b67cb0f6bfbdb42a6738eca6",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C3_deceit_multi_step100000.png": "07cce6c99dfa7b56dd4d3aa452873a676a5a00e9f046555fa9dda30f16dde488",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C1_stealth.png": "a892f18c74fe13efd839bfd5068097ca0ae07acebf6c06eed89e1b867e41fcb2",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C6_deceit_f2_step060000.png": "80b63bd309ef11a3ebb2f1ef301b49cd8f09bcc25562097d382f859306c9fe6d",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C2_deceit.png": "1edb30dc35e29ad991695353f4b84e0507792935ec75ae9a7904ebdc007a471a",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C5_deceit_multi_f1p5_step060000.png": "93ab8e09e58a64c5dd2eedfdafd27cf4dcfe4e8fae1af64ac71eac509e6ffdaf",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C3_deceit_multi_step060000.png": "f773bdef1c8d718d01b6d6d7735182c04564dd8b5692b359e1dd2f721c774b1a",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C4_deceit_f1p5_step080000.png": "5570fe6a25c92e5c6aa9a5129aa1797ba8ee7418170c7a351f9e35b931a366c7",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C1_stealth_step080000.png": "32d3e700286eb4b46b3bcf757669481affd6ff6b53792d730b5a21da92cc57d6",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C6_deceit_f2_step100000.png": "5acfe36694bb4e628309ff8ae1e839ca0a1f684607165bbc2883436b85208bf4",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C2_deceit_step040000.png": "2c6f2b8d61cc2aaa63631eb6c98d3de26dcef705fa6b66c823ce7b9eef50e00c",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C5_deceit_multi_f1p5.png": "adbefd0021e2c981d026718de8c63594b9c8e5971901d1dc40835cb69d95b93e",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C2_deceit_step080000.png": "ce8b18e4dd976ed590fcc44075f3fb058ca7b23e15a1624726c181c4dd0c11da",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C3_deceit_multi_step040000.png": "168d21ef24ae198fbfd642f8ca315faad4c7bff2e2c09e16ff7c97e7360ea883",
+    "tests/output/screening/screening_summary.csv": "3a23c4f2bd54ed5ee9bdb5b6dcdc58eed04519fcf1b4790e0abd1e6c5288fb96",
+    "tests/output/screening/screening_summary.json": "caf64530f152b6b8ccec82a3c7ba44fa0b3aeb0e0221ef6121857bf62c031ecd",
+    "tests/output/screening/B1/force_hist.csv": "854bfebe63fb2d140823fc5dbc434a70c317c6ab0bedbd5220cec45665b524c8",
+    "tests/output/screening/B1/summary.json": "35b4d958bc0fdd6ab6c9c0d1ed50e85d89b04f7be3e34632d6c3ea95b89acb47",
+    "tests/output/screening/custom/force_hist.csv": "06da0f67b564d5c114332ef3b39167b1ba222fc50045f95303c75c14755b51d5",
+    "tests/output/screening/custom/summary.json": "1701ed75e5e9ca16127f495ccff1d87de245d81df581e94114c8fca6fbbe77fd",
+    "tests/output/screening/MR1/force_hist.csv": "f70fbfa748fd0709e225523aaaa72b761db56df4f1d48f105384b94cbc44b31f",
+    "tests/output/screening/MR1/summary.json": "3d9a0fc19710820e3634ab2143b913b282beb159336567ab9ebf3de2092947bd",
+    "tests/output/screening/MR2/force_hist.csv": "c947b3c16b8e8f8f85a203cea8cd912bdfc07f96985c1c24a470b644170195ea",
+    "tests/output/screening/MR2/summary.json": "d2344e9e2517ec76c8b56bfbe3763dd465e24721856992401c57c414763481bb",
+    "tests/output/screening/MR3/force_hist.csv": "7df1536c83ee466b7195d9c521d3d3b1309acaf142f2855bba51fb279c7612e4",
+    "tests/output/screening/MR3/summary.json": "ad188eb1b271a6cd0fb4025b456eccac5450776f60db58466f804fc5a0e0ec61",
+    "tests/postproc/run_exp_ctrl_matrix_vorticity.py": "b7e0c4113111b9b677f321750c0055656ccfa4f45c25fe7846f3ed22f30d1467",
+    "tests/postproc/vorticity_triangle_clean.png": "f831b8143b50f038d5920a0658469622655f34176d30cf7216feff108aa2ecaf",
+    "tests/postproc/run_kan99b_streakline.py": "a2bbf3fc629ea170d2d4879317dbf2b81c43378a328100ac1f2ee8d9895666cb",
+    "tests/postproc/streakline_triangle_clean.png": "aa6669de7af6f82e98af25698a15f494e9cea20cb911ad9a30fe52597d33bb79",
+    "tests/postproc/experiment.ipynb": "c6b45db1c57200f0777213ef8d44cb4996c1aa7a5fb42b968b77e56f51b4fca4",
+    "tests/postproc/run_stealth_steady_sweep.py": "3c32c4dede7da77fd6cfbd3f7b1ff43bb11390aaba621883ec96c6c7fdad5af7",
+    "tests/postproc/run_exp_ctrl_matrix_streakline.py": "529d5f31a3862080f890c65177502b589710b2d960ddf131abaf7dc2f9e2a96f",
+    "tests/screening/run_config_sweep.py": "5030c99923815ed6ad39110cb56f748c579ff4c66c7c1a368ad1a6008017e2ff",
+    "examples/fixed_periodic_patch.py": "6732e440a47c237ea341703f2d80717903d34c68fd061bdc97189e5d877be46c",
+    "examples/fixed_patch_jet.py": "9d58ac3f32478603e8e798efcdaf6ea16e9cc92346eb4780a60e438d331abced"
+  }
+}

research/fine_surface_20261014/cpu_device_guard_cmd.txt

@@ -0,0 +1 @@
+PYTHONPATH=/home/frank14f/CelerisLab/src CUDA_VISIBLE_DEVICES='' /home/frank14f/anaconda3/envs/pycuda_3_10/bin/python -m pytest tests/validation/multigrid/test_fine_surface_gpu.py::test_missing_surface_device_buffer_rejects_before_launch -q

research/fine_surface_20261014/cpu_device_guard_exit.txt

@@ -0,0 +1 @@
+0

research/fine_surface_20261014/cpu_device_guard_stdout.txt

@@ -0,0 +1,2 @@
+..                                                                       [100%]
+2 passed in 0.09s

research/fine_surface_20261014/cpu_existing_runs.json

@@ -0,0 +1,30 @@
+[
+  {
+    "name": "cpu_maps",
+    "command": [
+      "/home/frank14f/anaconda3/envs/pycuda_3_10/bin/python",
+      "-m",
+      "pytest",
+      "-q",
+      "-p",
+      "no:cacheprovider",
+      "tests/unit/test_refinement.py"
+    ],
+    "exit_code": 0,
+    "seconds": 1.8799934879643843
+  },
+  {
+    "name": "cpu_shared_kernel",
+    "command": [
+      "/home/frank14f/anaconda3/envs/pycuda_3_10/bin/python",
+      "-m",
+      "pytest",
+      "-q",
+      "-p",
+      "no:cacheprovider",
+      "tests/unit/test_numerical_operators.py::test_actual_semantic_and_auxiliary_kernels[0-0-0]"
+    ],
+    "exit_code": 0,
+    "seconds": 2.1572919980389997
+  }
+]

research/fine_surface_20261014/cpu_final_run.json

@@ -0,0 +1,14 @@
+{
+  "command": [
+    "/home/frank14f/anaconda3/envs/pycuda_3_10/bin/python",
+    "-m",
+    "pytest",
+    "-q",
+    "-p",
+    "no:cacheprovider",
+    "tests/unit/test_fine_surface.py"
+  ],
+  "exit_code": 0,
+  "seconds": 1.947228622972034,
+  "note": "Final CPU recheck after preflight aperture inputs were aligned with packed FP32 lever arms. No kernel/math or uploaded-array changes."
+}

research/fine_surface_20261014/cpu_final_stdout.txt

@@ -0,0 +1,2 @@
+...............                                                          [100%]
+15 passed in 0.59s

research/fine_surface_20261014/cpu_lifecycle_run.json

@@ -0,0 +1,14 @@
+{
+  "command": [
+    "/home/frank14f/anaconda3/envs/pycuda_3_10/bin/python",
+    "-m",
+    "pytest",
+    "-q",
+    "-p",
+    "no:cacheprovider",
+    "tests/validation/multigrid/test_refinement_followup.py::FaultGuardsCPU",
+    "tests/validation/multigrid/test_refinement_gpu.py::CoupledGPU::test_cleanup_attempts_every_allocation"
+  ],
+  "exit_code": 0,
+  "seconds": 1.620646678027697
+}

research/fine_surface_20261014/cpu_lifecycle_stdout.txt

@@ -0,0 +1,2 @@
+.....                                                               [100%]
+5 passed, 5 subtests passed in 0.25s

research/fine_surface_20261014/cpu_maps_stdout.txt

@@ -0,0 +1,2 @@
+.........                                         [100%]
+9 passed, 23 subtests passed in 0.12s

research/fine_surface_20261014/cpu_preallocation_run.json

@@ -0,0 +1,14 @@
+{
+  "command": [
+    "/home/frank14f/anaconda3/envs/pycuda_3_10/bin/python",
+    "-m",
+    "pytest",
+    "-q",
+    "-p",
+    "no:cacheprovider",
+    "tests/validation/multigrid/test_fine_surface_gpu.py::test_cross_interface_donor_rejects_before_cuda"
+  ],
+  "exit_code": 0,
+  "seconds": 1.665132363094017,
+  "CUDA_VISIBLE_DEVICES": ""
+}

research/fine_surface_20261014/cpu_preallocation_stdout.txt

@@ -0,0 +1,2 @@
+.                                                                        [100%]
+1 passed in 0.09s

research/fine_surface_20261014/cpu_shared_kernel_stdout.txt

@@ -0,0 +1,2 @@
+.                                                                        [100%]
+1 passed in 0.63s

research/fine_surface_20261014/cpu_surface_command.txt

@@ -0,0 +1 @@
+PYTHONPATH=src /home/frank14f/anaconda3/envs/pycuda_3_10/bin/python -m pytest tests/unit/test_fine_surface.py -q

research/fine_surface_20261014/cpu_surface_exit.txt

@@ -0,0 +1 @@
+0

research/fine_surface_20261014/cpu_surface_projection_command.txt

@@ -0,0 +1 @@
+PYTHONPATH=src /home/frank14f/anaconda3/envs/pycuda_3_10/bin/python -m pytest tests/unit/test_fine_surface.py -q -k 'projection_uses_cell_center or transfer_dependencies'

research/fine_surface_20261014/cpu_surface_projection_exit.txt

@@ -0,0 +1 @@
+0

research/fine_surface_20261014/cpu_surface_projection_stdout.txt

@@ -0,0 +1,2 @@
+...                                                                      [100%]
+3 passed, 12 deselected in 0.40s

research/fine_surface_20261014/cpu_surface_stdout.txt

@@ -0,0 +1,2 @@
+...............                                                          [100%]
+15 passed in 0.59s

research/fine_surface_20261014/gpu_preparation_run1.py

@@ -0,0 +1,290 @@
+"""CPU preparation for one fixed D2Q9 2:1 patch and optional interior circles.
+
+Cell indices use y*nx+x; population slots use q*(nx*ny)+cell, matching
+core/layout.cuh. Bounds are half-open (x0, y0, x1, y1) in coarse cells.
+The four fine halo cells implement the pinned CPUREF volumetric geometry.
+Base topology is independent of boundaries; prepare_fine_boundary checks them.
+"""
+from dataclasses import dataclass, replace
+from numbers import Integral
+
+import numpy as np
+
+from ..config import LBMConfig
+from .descriptors import D2Q9_EX, D2Q9_EY, FLUID, SOLID
+
+ACTIVE, INNER_GHOST, OUTER_GHOST = 0, 1, 2
+HALO = 4
+
+
+def _readonly(values, dtype):
+    array = np.ascontiguousarray(values, dtype=dtype)
+    array.setflags(write=False)
+    return array
+
+
+@dataclass(frozen=True, eq=False)
+class FixedPatch2D:
+    """Layer metadata and compact exchange tables, constructed by from_config.
+
+    Shapes are (ny, nx), including the fine halo. ``fine_origin`` is its lower
+    cell edge in coarse physical units, with coarse dx=dt=1 and fine dx=dt=.5.
+    ``ghost_fine`` and ``ghost_coarse`` pair fine cells with coarse donors.
+    ``coalesce_coarse`` contains incoming population slots; each corresponding
+    row of ``coalesce_fine`` contains four fine slots in (dy, dx) row order.
+    Weights are all 1/4. Closed corner links are included even when the coarse
+    donor is uncovered. These tables contain no DDF data and allocate no GPU.
+
+    This is preparation, not permission to advance these levels with OneStep:
+    its channel boundaries and fused collision do not implement patch coupling.
+    """
+    coarse_shape: tuple[int, int]
+    bounds: tuple[int, int, int, int]
+    tau_coarse: float
+    tau_fine: float
+    fine_kind: np.ndarray
+    ghost_fine: np.ndarray
+    ghost_coarse: np.ndarray
+    coalesce_coarse: np.ndarray
+    coalesce_fine: np.ndarray
+
+    @classmethod
+    def from_config(cls, cfg: LBMConfig, bounds) -> "FixedPatch2D":
+        """Prepare maps without changing cfg or allocating coarse-sized tables.
+
+        The initial backend contract is D2Q9/SRT/FP32/unshifted/double_buffer,
+        without LES. Two coarse cells of margin keep all halo donors in bounds;
+        this does NOT certify that those donors are fluid or periodic.
+        """
+        checked = replace(cfg)
+        checked.validate()
+        if (not checked.is_d2q9 or checked.collision != "SRT"
+                or checked.streaming != "double_buffer"
+                or checked.store_precision != "FP32"
+                or checked.ddf_shifting or checked.les_enabled):
+            raise ValueError("FixedPatch2D requires D2Q9/SRT/FP32/unshifted/double_buffer without LES")
+        bounds = tuple(bounds)
+        if len(bounds) != 4 or any(isinstance(v, (bool, np.bool_))
+                                   or not isinstance(v, Integral) for v in bounds):
+            raise ValueError("bounds must be four integers: (x0, y0, x1, y1)")
+        x0, y0, x1, y1 = bounds = tuple(map(int, bounds))
+        nx, ny = checked.nx, checked.ny
+        if not (2 <= x0 < x1 <= nx - 2 and 2 <= y0 < y1 <= ny - 2):
+            raise ValueError("patch must be nonempty with a two-coarse-cell margin")
+        fx, fy = 2 * (x1 - x0) + 2 * HALO, 2 * (y1 - y0) + 2 * HALO
+        if max(nx * ny, fx * fy) > np.iinfo(np.uint32).max:
+            raise ValueError("layer cell counts exceed uint32 indexing")
+        tau_c = 3.0 * checked.viscosity + 0.5
+        tau_f = 6.0 * checked.viscosity + 0.5
+        if not checked.omega_min <= 1.0 / tau_f <= checked.omega_max:
+            raise ValueError("fine relaxation rate lies outside configured omega guards")
+
+        kind = np.full((fy, fx), OUTER_GHOST, dtype=np.uint8)
+        kind[2:-2, 2:-2] = INNER_GHOST
+        kind[HALO:-HALO, HALO:-HALO] = ACTIVE
+        gy, gx = np.nonzero(kind != ACTIVE)
+        ghost_fine = gy * fx + gx
+        ghost_coarse = (y0 + (gy - HALO) // 2) * nx + x0 + (gx - HALO) // 2
+
+        targets, sources = [], []
+        # Only the outside ring can receive fine-to-coarse populations.
+        # Integer doubled midpoints include all eight diagonal corner passes.
+        for y in range(y0 - 1, y1 + 1):
+            xs = range(x0 - 1, x1 + 1) if y in (y0 - 1, y1) else (x0 - 1, x1)
+            for x in xs:
+                for q in range(1, 9):
+                    mx, my = 2 * x + 1 - D2Q9_EX[q], 2 * y + 1 - D2Q9_EY[q]
+                    if 2 * x0 <= mx <= 2 * x1 and 2 * y0 <= my <= 2 * y1:
+                        targets.append(q * nx * ny + y * nx + x)
+                        a, b = HALO + 2 * (x - x0), HALO + 2 * (y - y0)
+                        sources.append([q * fx * fy + (b + dy) * fx + a + dx
+                                        for dy in (0, 1) for dx in (0, 1)])
+        return cls((ny, nx), bounds, tau_c, tau_f,
+                   _readonly(kind, np.uint8),
+                   _readonly(ghost_fine, np.uint32),
+                   _readonly(ghost_coarse, np.uint32),
+                   _readonly(targets, np.uint64),
+                   _readonly(sources, np.uint64).reshape(-1, 4))
+
+    @property
+    def fine_shape(self) -> tuple[int, int]:
+        return self.fine_kind.shape
+
+    @property
+    def fine_origin(self) -> tuple[float, float]:
+        return self.bounds[0] - HALO / 2, self.bounds[1] - HALO / 2
+
+    @property
+    def table_bytes(self) -> int:
+        return sum(a.nbytes for a in (self.fine_kind, self.ghost_fine,
+                                     self.ghost_coarse, self.coalesce_coarse,
+                                     self.coalesce_fine))
+
+    def check_synchronization(self, coarse_steps: int, fine_steps: int, *, phase: str) -> None:
+        """Check a proposed backend handoff; does not convert or collide data.
+
+        Production storage is g=C(f), while CPUREF returns arrival_f. A future
+        g-to-g coarse step must collide coarse cells once and fine cells twice;
+        fine halo ghosts never collide. Coalescence must precede coarse collision.
+        Converting reference f to g for comparison is an observation operation,
+        not an additional production collision. Counts here are completed steps.
+        """
+        if phase != "postcollision_g":
+            raise ValueError("patch backend handoff requires postcollision_g")
+        for value in (coarse_steps, fine_steps):
+            if isinstance(value, (bool, np.bool_)) or not isinstance(value, Integral) or value < 0:
+                raise ValueError("step counts must be nonnegative integers")
+        if fine_steps != 2 * coarse_steps:
+            raise ValueError("levels are not synchronized: fine_steps must equal 2*coarse_steps")
+
+
+@dataclass(frozen=True, eq=False)
+class FineBoundary2D:
+    """Fixed local projection plus auditable, finite transfer dependency sets.
+
+    transfer_reads rows are (hop, direction, cell), traced from coalescence at
+    hop 2 back to exploded G at hop 0. No previous coarse interval is traversed.
+    Cell footprints also include the whole explosion write/donor tables.
+    """
+    objects: tuple
+    flags: np.ndarray
+    curved_host: tuple
+    boundary_cells: np.ndarray
+    transfer_fine_cells: np.ndarray
+    transfer_coarse_cells: np.ndarray
+    transfer_reads: np.ndarray
+
+
+def _transfer_footprint(patch):
+    ny, nx = patch.fine_shape
+    cells = nx * ny
+    pending = [(2, *divmod(int(slot), cells)) for slot in patch.coalesce_fine.ravel()]
+    reads = set()
+    while pending:
+        hop, q, k = pending.pop()
+        if (hop, q, k) in reads:
+            continue
+        reads.add((hop, q, k))
+        if hop == 0:
+            continue
+        y, x = divmod(k, nx)
+        kind = patch.fine_kind[y, x]
+        if kind == OUTER_GHOST:
+            raise ValueError("Transfer reads an invalid post-hop outer ghost")
+        # A collided output depends on all nine arrivals; ghosts only stream.
+        for direction in (range(9) if kind == ACTIVE else (q,)):
+            sx, sy = x - D2Q9_EX[direction], y - D2Q9_EY[direction]
+            if not (0 <= sx < nx and 0 <= sy < ny):
+                raise ValueError("Transfer dependency leaves the fine allocation")
+            pending.append((hop - 1, direction, sy * nx + sx))
+    fine = set(map(int, patch.ghost_fine)) | {k for _, _, k in reads}
+    coarse = set(map(int, patch.ghost_coarse)) | set(map(
+        int, patch.coalesce_coarse % np.prod(patch.coarse_shape)))
+    return fine, coarse, _readonly(sorted(reads), np.int64)
+
+
+def prepare_fine_boundary(cfg, patch, objects, *, wall_aware=False):
+    """Project fixed circles and reject boundary/transfer overlap before CUDA.
+
+    Input centers/radii are in coarse physical coordinates (dx=dt=1).
+    SurfaceActuation retains its lattice-velocity meaning: input coarse units
+    are converted into independent fine-local objects with dx=dt=.5.
+    Original objects are not retained or mutated. No runtime geometry updates.
+    """
+    if not objects:
+        return None
+    checked = replace(cfg)
+    checked.validate()
+    if (patch.coarse_shape != (cfg.ny, cfg.nx) or not checked.is_d2q9
+            or checked.collision != "SRT" or checked.streaming != "double_buffer"
+            or checked.store_precision != "FP32" or checked.ddf_shifting or checked.les_enabled
+            or patch.tau_coarse != 3*checked.viscosity+.5):
+        raise ValueError("Fine boundary requires the matching fixed-patch configuration")
+    from ..body.geometry.circle import CircleGeometry
+    from ..body.objects import SimObject
+    from ..body.coupling.soa_packer import pack_cut_links_to_soa
+
+    ny, nx = patch.fine_shape
+    fine_cfg = replace(cfg, nx=nx, ny=ny, viscosity=2 * cfg.viscosity)
+    flags = np.full(nx * ny, FLUID, np.uint16)
+    active = patch.fine_kind.ravel() == ACTIVE
+    local, links = [], []
+    x0, y0, x1, y1 = patch.bounds
+    dx = dt = .5
+    for bid, obj in enumerate(objects):
+        if (type(obj.geometry) is not CircleGeometry or obj.is_sensor or obj.is_force_region
+                or any(getattr(obj.state, name) != 0 for name in ("vx", "vy", "omega"))
+                or any(vars(obj.control).values())):
+            raise ValueError("Fine boundaries require stationary circles without other roles")
+        cx, cy = obj.geometry.center
+        radius = obj.geometry._radius
+        if (not np.isfinite([cx, cy, radius]).all() or radius <= 0
+                or cx-radius < x0 or cx+radius > x1 or cy-radius < y0 or cy+radius > y1):
+            raise ValueError("Entire fine circle must lie inside the physical patch")
+        center = tuple((v-o)/dx-.5 for v, o in zip((cx, cy), patch.fine_origin))
+        spec = obj.surface_actuation
+        if spec is not None:
+            spec = replace(spec, normal_velocity=spec.normal_velocity * dt / dx)
+        item = SimObject(bid, geometry=CircleGeometry(*center, radius/dx),
+                         center=center, radius=radius/dx, surface_actuation=spec)
+        item.validate_surface_actuation(fine_cfg)
+        mask = item.get_flag_mask(nx, ny)
+        solid = (mask & SOLID) != 0
+        if not solid.any() or np.any(solid & ~active) or np.any(flags[solid] & SOLID):
+            raise ValueError("Fine solids must be resolved, disjoint and entirely active")
+        flags[solid] = mask[solid]
+        local.append(item)
+    for item in local:
+        cut = item.geometry.build_cut_links(nx, ny, domain_flags=flags)
+        if not cut:
+            raise ValueError("Fine circle has no resolved cut links")
+        if item.surface_actuation is not None:
+            _, aperture = item.surface_actuation.project(
+                np.array([link.rx for link in cut]), np.array([link.ry for link in cut]))
+            if not aperture.any():
+                raise ValueError("Surface aperture hits no resolved cut links")
+        for link in cut:
+            link.body_id = item.obj_id
+        links.extend(cut)
+
+    boundary, writers, receivers = set(), set(), set()
+    for link in links:
+        r, q = link.fluid_idx, link.dir
+        y, x = divmod(r, nx)
+        sx, sy = x + D2Q9_EX[q], y + D2Q9_EY[q]
+        s = sy * nx + sx
+        if not (active[r] and flags[r] & FLUID and active[s] and flags[s] & SOLID):
+            raise ValueError("Cut-link receiver/source must be active fluid/solid")
+        writer = (s, q+1 if q % 2 else q-1)
+        if writer in writers:
+            raise ValueError("Duplicate fine boundary writer")
+        writers.add(writer)
+        receivers.add((r, q))
+        boundary.update((r, s))
+        if link.q < .5:
+            dx_, dy_ = x - D2Q9_EX[q], y - D2Q9_EY[q]
+            if not (0 <= dx_ < nx and 0 <= dy_ < ny and active[dy_*nx+dx_]):
+                raise ValueError("q<.5 donor crosses the fine active interface; fallback cannot hide it")
+            boundary.add(dy_*nx+dx_)
+    # Reverse coverage: every fluid pull across a solid neighbor needs a writer.
+    required = set()
+    for r in np.flatnonzero(active & ((flags & FLUID) != 0)):
+        for q in range(1, 9):
+            if flags[r + D2Q9_EX[q] + nx*D2Q9_EY[q]] & SOLID:
+                required.add((int(r), q))
+    if required != receivers:
+        raise ValueError("Fine solid pull coverage does not match the cut links")
+    fine, coarse, reads = _transfer_footprint(patch)
+    if fine & (boundary | set(map(int, np.flatnonzero(flags & SOLID)))):
+        raise ValueError("Boundary stencil overlaps the two-hop transfer footprint")
+    for k in coarse:
+        y, x = divmod(k, cfg.nx)
+        if x0 <= x < x1 and y0 <= y < y1:
+            raise ValueError("Transfer coarse donor/target is not an uncovered bulk cell")
+        if wall_aware and (y <= 2 or y >= cfg.ny-3):
+            raise ValueError("Transfer footprint touches the coarse wall reconstruction stencil")
+    return FineBoundary2D(tuple(local), _readonly(flags, np.uint16),
+                          tuple(_readonly(a, a.dtype) for a in pack_cut_links_to_soa(links)),
+                          _readonly(sorted(boundary), np.uint32),
+                          _readonly(sorted(fine), np.uint32),
+                          _readonly(sorted(coarse), np.uint32), reads)

research/fine_surface_20261014/gpu_run.json

@@ -0,0 +1,48 @@
+{
+  "start_utc": "2026-10-14T05:08:55.958692+00:00",
+  "preflight_gpu": "0, GPU-e8853ae7-a302-6a17-bcfa-aa767e9ed20c, Tesla V100-SXM2-16GB, 5, 16140, 0\n1, GPU-f1c9fd5a-e917-56e0-21fb-24035ba44a36, Tesla V100-SXM2-16GB, 5, 16140, 0\n2, GPU-b8c11c01-c91f-aa0b-abf6-dad35085cc76, Tesla V100-SXM2-16GB, 5, 16140, 0\n3, GPU-8b71b032-1b75-2891-935c-ce106a53034a, Tesla V100-SXM2-16GB, 5, 16140, 0",
+  "preflight_apps": "",
+  "preflight_ram_bytes": 64091750400,
+  "physical_gpu_uuid": "GPU-e8853ae7-a302-6a17-bcfa-aa767e9ed20c",
+  "command": [
+    "/home/frank14f/anaconda3/envs/pycuda_3_10/bin/python",
+    "-c",
+    "import CelerisLab,pytest; print('SOURCE', CelerisLab.__file__, flush=True); assert CelerisLab.__file__.startswith('/home/frank14f/CelerisLab/src/'); raise SystemExit(pytest.main(['-q', '-s', '-p', 'no:cacheprovider', 'tests/validation/multigrid/test_fine_surface_gpu.py', 'tests/validation/multigrid/test_refinement_followup.py::NormalBuildGPU::test_offcenter_rectangle_margin_two_one_step', 'tests/validation/multigrid/test_refinement_followup.py::NormalBuildGPU::test_slot_reservoir_eight_steps']))"
+  ],
+  "cwd": "/home/frank14f/CelerisLab",
+  "env": {
+    "PYTHONPATH": "/home/frank14f/CelerisLab/src",
+    "PYTHONNOUSERSITE": "1",
+    "PYTHONDONTWRITEBYTECODE": "1",
+    "OPENBLAS_NUM_THREADS": "1",
+    "CUDA_VISIBLE_DEVICES": "GPU-e8853ae7-a302-6a17-bcfa-aa767e9ed20c",
+    "CUDA_CACHE_DISABLE": "1",
+    "TMPDIR": "/tmp/celeris-fine-surface-gpu-e9g3hz7z"
+  },
+  "preflight_temp_bytes": 1637890,
+  "limits": {
+    "wall_seconds": 120,
+    "temp_bytes": 2000000000,
+    "ram_reserve_bytes": 6409175040,
+    "vram_reserve_MiB": 1614
+  },
+  "note": "Sampled own process group; no fixed RSS/address-space cap.",
+  "exit_code": 1,
+  "elapsed_seconds": 25.39498820400331,
+  "peak_group_rss_bytes": 386883584,
+  "peak_temp_bytes": 3585985,
+  "min_ram_bytes": 63638339584,
+  "min_vram_free_MiB": 15826,
+  "termination_reason": null,
+  "scratch_removed": true,
+  "source_hashes_captured_during_run": {
+    "src/CelerisLab/lbm/kernels/refinement.cu": "129f3d91da93b4324f88a0da73a4da1e5390f72c14cce574ee63306712da9895",
+    "src/CelerisLab/lbm/kernels/step/aux_kernels.cu": "578a5b20a157241ee678547059abb1372dd5a589ad06bb2c15b987eb01ca1013",
+    "src/CelerisLab/lbm/kernels/step/curved_double.cu": "bfa7a1df1e939020314d49755045f7a85fe4a19cc1c68dbe62653c66c5e7c2b3",
+    "src/CelerisLab/lbm/refinement.py": "b3fe9e58118369adb1bdfc618fbfbd917d508a563beaf2555f656b59aeff4425",
+    "src/CelerisLab/lbm/refinement_stepper.py": "9178224089ee6584420b79f10cf1d91441645b668e8b6898641d19eac757687b",
+    "src/CelerisLab/lbm/stepper.py": "0dcb7cd7ae87e33e3dc67a38b6aa43042fbe673e37d9ad165342ee1d695933ce",
+    "tests/unit/test_fine_surface.py": "b232b55e75eef52480f06a35c401d72b6145892bb8b79d1d1b3cfed965b3506c",
+    "tests/validation/multigrid/test_fine_surface_gpu.py": "3dd0658f63a4e7a1c41eecf433842c872f8fecb391ea4b44d0b48947643d5189"
+  }
+}

research/fine_surface_20261014/gpu_stdout.txt

@@ -0,0 +1,79 @@
+SOURCE /home/frank14f/CelerisLab/src/CelerisLab/__init__.py
+speed=0.0 audit=True BFL=7.4505806e-09 ledger=[1.604948192834854e-05, -5.038455128669739e-07, -6.919726729393005e-07] budget=0.00221051117 boundary=[4.0978193283081055e-08, 0.0, 0.0] transfer=[0.0, 0.0, 0.0] drive_mass=+4.09781933e-08; counts=PASS
+speed=None audit=False BFL=7.4505806e-09 ledger=[1.604948192834854e-05, -5.038455128669739e-07, -6.919726729393005e-07] budget=0.00221051117 boundary=[4.0978193283081055e-08, 0.0, 0.0] transfer=[0.0, 0.0, 0.0] drive_mass=+4.09781933e-08; counts=normal build
+.speed=0.002 audit=True BFL=9.73073444e-09 ledger=[1.597730442881584e-05, -5.154870450496674e-07, -7.622875273227692e-07] budget=0.00221052543 boundary=[0.0071802823804318905, 0.003110995050519705, 0.0026390845887362957] transfer=[0.0, 0.0, 0.0] drive_mass=+0.00620033871; counts=PASS
+.speed=-0.002 audit=True BFL=7.4505806e-09 ledger=[1.66366808116436e-05, -5.881302058696747e-07, -7.147900760173798e-07] budget=0.00221049693 boundary=[-0.007164992857724428, -0.0030983122996985912, -0.00262861093506217] transfer=[0.0, 0.0, 0.0] drive_mass=-0.00618575338; counts=PASS
+.FF.normal rectangle 17x13 bounds=(2, 2, 6, 5) fine=16x14 steps=1: max_population=1.14050047e-07 device_arrays=35288; halo/stride PASS
+host_peak_rss=279.887 MiB
+.slot/reservoir steps=8 max_population=1.78241457e-07 max_BC_error=2.21654773e-07 discrete_leaf_mass_change=+0.0309633738 final_sum_rho_v_bottom=0.00426894613 top=0.000960694626; raw halos/corners/fine BC isolation PASS
+host_peak_rss=279.887 MiB
+.
+=================================== FAILURES ===================================
+_ test_missing_surface_device_buffer_rejects_before_launch[surface_velocity_gpu] _
+
+missing = 'surface_velocity_gpu'
+
+    @pytest.mark.parametrize("missing", ["surface_velocity_gpu", "link_exchange_gpu"])
+    def test_missing_surface_device_buffer_rejects_before_launch(missing):
+        backend = implementation.FixedPatchStepper.__new__(implementation.FixedPatchStepper)
+        backend.fine_boundary = SimpleNamespace(objects=[object_spec(.002)])
+        backend._fine_curved = SimpleNamespace(surface_velocity_gpu=object(), link_exchange_gpu=object())
+        setattr(backend._fine_curved, missing, None)
+        backend._curved = Mock()
+        with pytest.raises(RuntimeError, match="Surface boundary device buffers are missing"):
+>           backend._apply_fine_boundary(object())
+
+tests/validation/multigrid/test_fine_surface_gpu.py:289: 
+_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
+
+self = <CelerisLab.lbm.refinement_stepper.FixedPatchStepper object at 0x761fb9325480>
+buffer = <object object at 0x761fb937c570>, kw = {}
+cl = namespace(surface_velocity_gpu=None, link_exchange_gpu=<object object at 0x761fb937c630>)
+
+    def _apply_fine_boundary(self, buffer, **kw):
+        """Stage solid source slots; exchange buffer holds this fine substep only."""
+        cl = self._fine_curved
+        if cl is None:
+            if self.fine_boundary is not None:
+                raise RuntimeError("Fine boundary device buffers are missing")
+            return
+>       if self._curved is None or cl.fluid_idx_gpu is None:
+E       AttributeError: 'types.SimpleNamespace' object has no attribute 'fluid_idx_gpu'
+
+src/CelerisLab/lbm/refinement_stepper.py:195: AttributeError
+_ test_missing_surface_device_buffer_rejects_before_launch[link_exchange_gpu] __
+
+missing = 'link_exchange_gpu'
+
+    @pytest.mark.parametrize("missing", ["surface_velocity_gpu", "link_exchange_gpu"])
+    def test_missing_surface_device_buffer_rejects_before_launch(missing):
+        backend = implementation.FixedPatchStepper.__new__(implementation.FixedPatchStepper)
+        backend.fine_boundary = SimpleNamespace(objects=[object_spec(.002)])
+        backend._fine_curved = SimpleNamespace(surface_velocity_gpu=object(), link_exchange_gpu=object())
+        setattr(backend._fine_curved, missing, None)
+        backend._curved = Mock()
+        with pytest.raises(RuntimeError, match="Surface boundary device buffers are missing"):
+>           backend._apply_fine_boundary(object())
+
+tests/validation/multigrid/test_fine_surface_gpu.py:289: 
+_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
+
+self = <CelerisLab.lbm.refinement_stepper.FixedPatchStepper object at 0x761fb92299c0>
+buffer = <object object at 0x761fb937f700>, kw = {}
+cl = namespace(surface_velocity_gpu=<object object at 0x761fb937f710>, link_exchange_gpu=None)
+
+    def _apply_fine_boundary(self, buffer, **kw):
+        """Stage solid source slots; exchange buffer holds this fine substep only."""
+        cl = self._fine_curved
+        if cl is None:
+            if self.fine_boundary is not None:
+                raise RuntimeError("Fine boundary device buffers are missing")
+            return
+>       if self._curved is None or cl.fluid_idx_gpu is None:
+E       AttributeError: 'types.SimpleNamespace' object has no attribute 'fluid_idx_gpu'
+
+src/CelerisLab/lbm/refinement_stepper.py:195: AttributeError
+=========================== short test summary info ============================
+FAILED tests/validation/multigrid/test_fine_surface_gpu.py::test_missing_surface_device_buffer_rejects_before_launch[surface_velocity_gpu]
+FAILED tests/validation/multigrid/test_fine_surface_gpu.py::test_missing_surface_device_buffer_rejects_before_launch[link_exchange_gpu]
+2 failed, 6 passed in 23.73s

research/fine_surface_20261014/gpu_test_run1.py

@@ -0,0 +1,316 @@
+"""Two coarse/four fine steps: isolated fine circle, no flux-accuracy claim.
+
+Run only through the bounded GPU runner after a fresh resource check. The test
+hooks read actual kernel inputs/outputs; they never change the stepping order.
+"""
+import importlib.util
+from contextlib import nullcontext
+from pathlib import Path
+from threading import RLock
+from types import SimpleNamespace
+from unittest.mock import Mock, patch
+
+import numpy as np
+import pycuda.driver as cuda
+import pytest
+
+import CelerisLab
+from CelerisLab.body.geometry.circle import CircleGeometry
+from CelerisLab.body.objects import SimObject
+from CelerisLab.config import LBMConfig
+from CelerisLab.cuda import compiler_v2 as compiler
+from CelerisLab.cuda.context import CudaContext
+from CelerisLab.lbm import refinement_stepper as implementation
+from CelerisLab.lbm.descriptors import FLUID, SOLID
+
+
+ROOT = Path(__file__).resolve().parents[3]
+CX = np.array([0, 1, -1, 0, 0, 1, -1, 1, -1])
+CY = np.array([0, 0, 0, 1, -1, 1, -1, -1, 1])
+OPP = np.array([0, 2, 1, 4, 3, 6, 5, 8, 7])
+W = np.array([4/9]+[1/9]*4+[1/36]*4)
+MOMENTS = np.stack((np.ones(9), CX, CY))
+GEOMETRY = ("fluid_idx", "dir", "q", "body_id", "rx", "ry", "rz", "fallback_class")
+BOUNDS = (4, 4, 20, 20)
+
+
+def read(pointer, shape, dtype=np.float32):
+    values = np.empty(shape, dtype)
+    cuda.memcpy_dtoh(values, pointer)
+    return values
+
+
+def rest(shape):
+    return np.broadcast_to(W[:, None, None], (9, *shape)).astype(np.float32).copy()
+
+
+def surface(speed):
+    return None if speed is None else dict(angle=.7, half_width=.85, normal_velocity=speed)
+
+
+def object_spec(speed):
+    return SimObject(0, CircleGeometry(12.25, 12.25, 2.15), center=(12.25, 12.25),
+                     radius=2.15, surface_actuation=surface(speed))
+
+
+def audit_compiler(original):
+    def compile_private(*args, **kwargs):
+        entry = Path(kwargs["build_dir"])/"fine_surface_audit.cu"
+        entry.write_text('#define CELERIS_REFINEMENT_AUDIT\n#include "refinement.cu"\n')
+        kwargs["source"] = entry.name
+        return original(*args, **kwargs)
+    return compile_private
+
+
+def reflection_oracle(before, cl, speed, *, verify_projection=True):
+    """FP64 BFL from frozen spatial populations, independent arc projection."""
+    flat = before.astype(float).reshape(9, -1)
+    radius = np.hypot(cl.rx.astype(float), cl.ry.astype(float))
+    delta = (np.arctan2(cl.ry.astype(float), cl.rx.astype(float))-.7+np.pi) % (2*np.pi)-np.pi
+    amplitude = 0 if speed is None else speed
+    strength = amplitude*np.maximum(0, 1-(delta/.85)**2)**2
+    velocity = strength[:, None]*np.column_stack((cl.rx, cl.ry))/radius[:, None]
+    if verify_projection and cl.surface_velocity is not None:
+        np.testing.assert_allclose(cl.surface_velocity, velocity, atol=3e-9, rtol=0)
+    incoming = []
+    for i, (k, d, q, fallback) in enumerate(zip(cl.fluid_idx, cl.dir, cl.q, cl.fallback_class)):
+        k, d, q = int(k), int(d), float(q)
+        rho = flat[:, k].sum()
+        dot = CX[d]*velocity[i, 0]+CY[d]*velocity[i, 1]
+        if fallback:
+            value = flat[d, k]-6*W[d]*rho*dot
+        elif q < .5:
+            value = 2*q*flat[d, k]+(1-2*q)*flat[d, k-CX[d]-40*CY[d]]-6*W[d]*rho*dot
+        else:
+            value = flat[d, k]/(2*q)+(1-1/(2*q))*flat[OPP[d], k]-3*W[d]*rho*dot/q
+        incoming.append(value)
+    return np.array(incoming)
+
+
+def fine_flux(before, staged, active, solid):
+    """Population ledger across the fine leaf boundary: solid versus halo.
+
+    Internal fluid-to-fluid streaming cancels pairwise; solid and halo packets
+    are counted in their actual direction, before any collision.
+    """
+    boundary, transfer = np.zeros(9), np.zeros(9)
+    magnitude = 0.0
+    for d, (cx, cy) in enumerate(zip(CX, CY)):
+        incoming = active & ~np.roll(active, (cy, cx), (0, 1))
+        outgoing = active & ~np.roll(active, (-cy, -cx), (0, 1))
+        from_solid = np.roll(solid, (cy, cx), (0, 1))
+        into_solid = np.roll(solid, (-cy, -cx), (0, 1))
+        received = np.roll(staged[d], (cy, cx), (0, 1)).astype(float)
+        sent = before[d].astype(float)
+        for vector, inc, out in ((boundary, incoming & from_solid, outgoing & into_solid),
+                                 (transfer, incoming & ~from_solid, outgoing & ~into_solid)):
+            assert np.isfinite(received[inc]).all() and np.isfinite(sent[out]).all()
+            vector[d] = received[inc].sum()-sent[out].sum()
+            magnitude += np.abs(received[inc]).sum()+np.abs(sent[out]).sum()
+    return boundary, transfer, magnitude
+
+
+def coarse_flux(before, fine, active):
+    """Derive every replacement from physical midpoints, not production tables."""
+    x0, y0, x1, y1 = BOUNDS
+    incoming = np.stack([np.roll(before[d], (CY[d], CX[d]), (0, 1)) for d in range(9)]).astype(float)
+    magnitude = 0.0
+    for y, x in np.argwhere(active):
+        for d in range(1, 9):
+            if x0 <= x+.5-CX[d]/2 <= x1 and y0 <= y+.5-CY[d]/2 <= y1:
+                a, b = 4+2*(x-x0), 4+2*(y-y0)
+                children = fine[d, b:b+2, a:a+2].astype(float)
+                assert children.shape == (2, 2) and np.isfinite(children).all()
+                incoming[d, y, x] = children.sum()/4
+                magnitude += np.abs(children).sum()/4
+    assert np.isfinite(incoming[:, active]).all()
+    # This retains the eight grazing-corner replacements of uncovered donors.
+    flux = (incoming[:, active]-before[:, active].astype(float)).sum(axis=1)
+    magnitude += np.abs(incoming[:, active]).sum()+np.abs(before[:, active]).sum(dtype=float)
+    return flux, magnitude
+
+
+def run_patch(speed, *, audit=True):
+    cfg = LBMConfig(nx=24, ny=24, viscosity=.05, velocity=0, rho=1)
+    coarse_active = np.ones((24, 24), bool)
+    coarse_active[4:20, 4:20] = False
+    source = object_spec(speed)
+    state = vars(source.state).copy()
+    with CudaContext(0) as context:
+        build = (patch.object(compiler, "compile_kernel", audit_compiler(compiler.compile_kernel))
+                 if audit else nullcontext())
+        with build:
+            backend = implementation.FixedPatchStepper(cfg, BOUNDS, context=context, fine_objects=[source])
+        with backend, context.activate():
+            c, f = backend._levels
+            cl = backend._fine_curved
+            geometry = {name: getattr(cl, name).copy() for name in GEOMETRY}
+            flags = backend.fine_boundary.flags.reshape(40, 40)
+            solid = (flags & SOLID) != 0
+            active = np.zeros((40, 40), bool)
+            active[4:-4, 4:-4] = True
+            active &= (flags & FLUID) != 0
+            active &= ~solid
+            local = backend.fine_boundary.objects[0]
+            assert local.center == (20., 20.) and local.radius == 4.3
+            assert source.center == (12.25, 12.25) and source.radius == 2.15
+            yy, xx = np.mgrid[:40, :40]
+            roi = active & ((xx-20)**2+(yy-20)**2 <= 9**2)
+            backend.initialize(rest((24, 24)), rest((40, 40)))
+            if audit:
+                for level in backend._levels:
+                    for name in ("collision_counts", "explosion_counts", "incoming_counts"):
+                        pointer, size = level.module.get_global(name)
+                        cuda.memset_d8(pointer, 0, size)
+            initial = backend.download()
+            initial_pop = initial[0][:, coarse_active].sum(axis=1, dtype=float)
+            initial_pop += .25*initial[1][:, active].sum(axis=1, dtype=float)
+            boundary, fine_transfer, coarse_transfer = np.zeros(9), np.zeros(9), np.zeros(9)
+            budget_sum, reflection_error, drive_mass = 0., 0., 0.
+            traces = []
+            original_curved, original_fine, original_coarse = backend._curved, f.kernel, c.kernel
+
+            def curved(*args, **kwargs):
+                nonlocal boundary, fine_transfer, budget_sum, reflection_error, drive_mass
+                backend._stream.synchronize()
+                before = read(args[0], f.shape)
+                expected = reflection_oracle(before, cl, speed)
+                original_curved(*args, **kwargs)
+                backend._stream.synchronize()
+                staged = read(args[0], f.shape)
+                d, k = cl.dir.astype(int), cl.fluid_idx.astype(int)
+                values = staged.reshape(9, -1)[OPP[d], k+CX[d]+40*CY[d]]
+                passive = reflection_oracle(before, cl, None, verify_projection=False)
+                drive_mass += .25*float(np.sum(values-passive))
+                error = float(np.max(np.abs(values-expected)))
+                reflection_error = max(reflection_error, error)
+                assert error <= 1e-7
+                np.testing.assert_array_equal(staged[:, active], before[:, active])
+                b, transfer, magnitude = fine_flux(before, staged, active, solid)
+                boundary += .25*b
+                fine_transfer += .25*transfer
+                budget_sum += .25*magnitude
+
+            def fine(*args, **kwargs):
+                nonlocal budget_sum
+                backend._stream.synchronize()
+                staged = read(args[0], f.shape)
+                original_fine(*args, **kwargs)
+                backend._stream.synchronize()
+                advanced = read(args[1], f.shape)
+                assert np.isfinite(advanced[:, active]).all()
+                assert np.isnan(advanced[:, solid]).all()
+                # Include actual collision operands in the FP32 rounding budget.
+                budget_sum += .25*np.abs(staged[:, active]).sum(dtype=float)
+                traces.append(advanced[:, roi].copy())
+
+            def coarse(*args, **kwargs):
+                nonlocal coarse_transfer, budget_sum
+                backend._stream.synchronize()
+                before, fine_values = read(args[0], c.shape), read(args[2], f.shape)
+                transfer, magnitude = coarse_flux(before, fine_values, coarse_active)
+                coarse_transfer += transfer
+                budget_sum += magnitude
+                return original_coarse(*args, **kwargs)
+
+            with patch.object(backend, "_curved", curved), patch.object(f, "kernel", fine), \
+                    patch.object(c, "kernel", coarse):
+                backend.step(2)
+            actual = backend.download()
+            population = actual[0][:, coarse_active].sum(axis=1, dtype=float)
+            population += .25*actual[1][:, active].sum(axis=1, dtype=float)
+            ledger = boundary+fine_transfer+coarse_transfer
+            error = MOMENTS@(population-initial_pop-ledger)
+            budget = 8*np.finfo(np.float32).eps*budget_sum
+            assert np.isfinite(budget_sum) and budget_sum > 0
+            assert np.max(np.abs(error)) <= budget
+            if speed:
+                assert speed*drive_mass > 0
+            assert len(traces) == 4 and backend.step_count == 2
+            if audit:
+                for level, mask, count in ((c, coarse_active, 2), (f, active, 4)):
+                    pointer, size = level.module.get_global("collision_counts")
+                    counts = read(pointer, mask.shape, np.uint32)
+                    assert size == counts.nbytes
+                    np.testing.assert_array_equal(counts, count*mask)
+            for name, values in geometry.items():
+                np.testing.assert_array_equal(getattr(cl, name), values)
+            assert vars(source.state) == state and source.geometry.center == source.center
+            print(f"speed={speed} audit={audit} BFL={reflection_error:.9g} ledger={error.tolist()} "
+                  f"budget={budget:.9g} boundary={list(MOMENTS@boundary)} "
+                  f"transfer={list(MOMENTS@(fine_transfer+coarse_transfer))} "
+                  f"drive_mass={drive_mass:+.9g}; counts={'PASS' if audit else 'normal build'}", flush=True)
+            return traces, roi, actual
+
+
+def uniform_reference(speed, roi):
+    # Reuse the existing explicit config helper without importing unrelated tests.
+    spec = importlib.util.spec_from_file_location("fine_surface_cases", ROOT/"tests/integration/_cases.py")
+    cases = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(cases)
+    with cases.make_sim(nx=48, ny=48, viscosity=.1, velocity=0, rho=1) as sim:
+        sim.add_body("circle", center=(24, 24), radius=4.3, surface_actuation=surface(speed))
+        sim.initialize()
+        # Uniform 48^2 has the same dx=dt=.5 representation. Its distant channel
+        # boundaries cannot influence the circle ROI within these four hops.
+        traces = []
+        for _ in range(4):
+            sim.run(1)
+            traces.append(sim.get_ddf().reshape(9, 48, 48)[:, 4:44, 4:44][:, roi].copy())
+        return traces
+
+
+@pytest.mark.parametrize("speed", [0., .002, -.002])
+def test_fine_surface_four_hops(speed):
+    assert Path(CelerisLab.__file__).resolve() == ROOT/"src/CelerisLab/__init__.py"
+    assert Path(compiler._KERNEL_DIR).resolve() == ROOT/"src/CelerisLab/lbm/kernels"
+    assert Path(implementation.__file__).resolve() == ROOT/"src/CelerisLab/lbm/refinement_stepper.py"
+    actual, roi, final = run_patch(speed)
+    reference = uniform_reference(speed, roi)
+    for got, wanted in zip(actual, reference):
+        np.testing.assert_allclose(got, wanted, atol=3e-6, rtol=0)
+        np.testing.assert_allclose(MOMENTS@got.astype(float), MOMENTS@wanted.astype(float),
+                                   atol=2e-5, rtol=0)
+    if speed == 0:
+        passive, passive_roi, passive_final = run_patch(None, audit=False)
+        np.testing.assert_array_equal(passive_roi, roi)
+        for got, wanted in zip(actual+list(final), passive+list(passive_final)):
+            np.testing.assert_array_equal(got, wanted)
+
+
+@pytest.mark.parametrize("missing", ["surface_velocity_gpu", "link_exchange_gpu"])
+def test_missing_surface_device_buffer_rejects_before_launch(missing):
+    backend = implementation.FixedPatchStepper.__new__(implementation.FixedPatchStepper)
+    backend.fine_boundary = SimpleNamespace(objects=[object_spec(.002)])
+    backend._fine_curved = SimpleNamespace(surface_velocity_gpu=object(), link_exchange_gpu=object())
+    setattr(backend._fine_curved, missing, None)
+    backend._curved = Mock()
+    with pytest.raises(RuntimeError, match="Surface boundary device buffers are missing"):
+        backend._apply_fine_boundary(object())
+    backend._curved.assert_not_called()
+
+
+def test_close_frees_fine_boundary_after_stream_failure_once():
+    backend = implementation.FixedPatchStepper.__new__(implementation.FixedPatchStepper)
+    backend.ctx = SimpleNamespace(activate=nullcontext)
+    backend._lock = RLock()
+    backend._status = "ready"
+    stream, soa, first, second = Mock(), Mock(), Mock(), Mock()
+    stream.synchronize.side_effect = RuntimeError("stream synchronization failed")
+    backend._stream = stream
+    backend._fine_curved = soa
+    backend._fine_flags = first
+    backend._curved = Mock()
+    backend._levels = [object(), object()]
+    backend._allocations = [first, second]
+    with pytest.raises(RuntimeError, match="stream synchronization failed"):
+        backend.close()
+    assert backend._status == "closed"
+    assert backend._levels == [] and backend._allocations == []
+    assert backend._fine_curved is None and backend._fine_flags is None
+    assert backend._curved is None and backend._stream is None
+    backend.close()
+    stream.synchronize.assert_called_once_with()
+    soa.free.assert_called_once_with()
+    first.free.assert_called_once_with()
+    second.free.assert_called_once_with()

research/fine_surface_20261014/manifest.json

@@ -0,0 +1,102 @@
+{
+  "head": "6e3756c587ec08ab6a55c4a1a5f4671822d3f0a0",
+  "changes": [
+    {
+      "path": "src/CelerisLab/lbm/kernels/refinement.cu",
+      "added": 10,
+      "removed": 2,
+      "sha256": "129f3d91da93b4324f88a0da73a4da1e5390f72c14cce574ee63306712da9895",
+      "characters": 4482
+    },
+    {
+      "path": "src/CelerisLab/lbm/kernels/step/aux_kernels.cu",
+      "added": 1,
+      "removed": 55,
+      "sha256": "578a5b20a157241ee678547059abb1372dd5a589ad06bb2c15b987eb01ca1013",
+      "characters": 10982
+    },
+    {
+      "path": "src/CelerisLab/lbm/kernels/step/curved_double.cu",
+      "added": 61,
+      "removed": 0,
+      "sha256": "bfa7a1df1e939020314d49755045f7a85fe4a19cc1c68dbe62653c66c5e7c2b3",
+      "characters": 2153
+    },
+    {
+      "path": "src/CelerisLab/lbm/refinement.py",
+      "added": 157,
+      "removed": 3,
+      "sha256": "8935b070ec9e7020897919c15f43f7fa6293f02e2ff64a19a3e3d99bc444dbcc",
+      "characters": 14161
+    },
+    {
+      "path": "src/CelerisLab/lbm/refinement_stepper.py",
+      "added": 66,
+      "removed": 10,
+      "sha256": "9178224089ee6584420b79f10cf1d91441645b668e8b6898641d19eac757687b",
+      "characters": 14875
+    },
+    {
+      "path": "src/CelerisLab/lbm/stepper.py",
+      "added": 5,
+      "removed": 1,
+      "sha256": "0dcb7cd7ae87e33e3dc67a38b6aa43042fbe673e37d9ad165342ee1d695933ce",
+      "characters": 7724
+    },
+    {
+      "path": "tests/unit/test_fine_surface.py",
+      "added": 215,
+      "removed": 0,
+      "sha256": "b232b55e75eef52480f06a35c401d72b6145892bb8b79d1d1b3cfed965b3506c",
+      "characters": 10596
+    },
+    {
+      "path": "tests/validation/multigrid/test_fine_surface_gpu.py",
+      "added": 330,
+      "removed": 0,
+      "sha256": "d45ca48fc4e77d021fcc5461329b094ae11b257c036bb23634d326fbbedb7700",
+      "characters": 16204
+    }
+  ],
+  "unchanged_baseline_files": 377,
+  "baseline_file_count": 382,
+  "post_status": " M pyproject.toml\n M setup.py\n M src/CelerisLab/__init__.py\n M src/CelerisLab/body/__init__.py\n M src/CelerisLab/body/ddf_patch.py\n M src/CelerisLab/body/manager.py\n M src/CelerisLab/body/objects.py\n M src/CelerisLab/body/preprocess/flag_overlay.py\n M src/CelerisLab/common/__init__.py\n M src/CelerisLab/common/checkpoint.py\n M src/CelerisLab/config.py\n M src/CelerisLab/configs/CONFIG.md\n M src/CelerisLab/cuda/__init__.py\n M src/CelerisLab/cuda/compiler_v2.py\n M src/CelerisLab/cuda/context.py\n M src/CelerisLab/lbm/__init__.py\n M src/CelerisLab/lbm/curved_links.py\n M src/CelerisLab/lbm/field.py\n M src/CelerisLab/lbm/initializers.py\n M src/CelerisLab/lbm/kernels/boundary/bounce_back.cuh\n M src/CelerisLab/lbm/kernels/boundary/curved_boundary.cuh\n M src/CelerisLab/lbm/kernels/boundary/inlet/common.cuh\n M src/CelerisLab/lbm/kernels/boundary/inlet/zou_he_local.cuh\n M src/CelerisLab/lbm/kernels/boundary/inlet_outlet.cuh\n M src/CelerisLab/lbm/kernels/config/config_grid.h\n M src/CelerisLab/lbm/kernels/config/config_method.h\n M src/CelerisLab/lbm/kernels/config/config_objects.h\n M src/CelerisLab/lbm/kernels/config/config_physics.h\n M src/CelerisLab/lbm/kernels/kernel_v2.cu\n M src/CelerisLab/lbm/kernels/operators/collision_mrt.cuh\n M src/CelerisLab/lbm/kernels/operators/collision_trt.cuh\n M src/CelerisLab/lbm/kernels/operators/forcing_guo.cuh\n M src/CelerisLab/lbm/kernels/step/aux_kernels.cu\n M src/CelerisLab/lbm/kernels/step/esopull_sync.cu\n M src/CelerisLab/lbm/kernels/step/init_flow.cu\n M src/CelerisLab/lbm/kernels/step/one_step_double.cu\n M src/CelerisLab/lbm/kernels/step/one_step_esopull.cu\n M src/CelerisLab/lbm/kernels/streaming/esopull_semantic_helpers.cuh\n M src/CelerisLab/lbm/stepper.py\n M src/CelerisLab/simulation.py\n M tests/integration/test_body_sync_e2e.py\n M tests/integration/test_ddf_patch.py\n M tests/integration/test_sync_bodies_skeleton.py\n M tests/integration/test_unified_obs.py\n M tests/postproc/experiment.ipynb\n M tests/validation/run_kan99b_rotating_cylinder.py\n M tests/validation/run_sah04_st_matrix.py\n M tests/validation/test_sensor_accuracy.py\n?? docs/design/\n?? docs/multilevel_grid_architecture_analysis.md\n?? examples/\n?? research/\n?? src/CelerisLab/lbm/kernels/boundary/planar_velocity.cuh\n?? src/CelerisLab/lbm/kernels/refinement.cu\n?? src/CelerisLab/lbm/kernels/step/curved_double.cu\n?? src/CelerisLab/lbm/refinement.py\n?? src/CelerisLab/lbm/refinement_stepper.py\n?? \"tests/audit/body\\345\\210\\240\\345\\207\\217\\345\\212\\237\\350\\203\\275.md\"\n?? tests/integration/_cases.py\n?? tests/integration/test_numerical_gpu.py\n?? tests/integration/test_runtime_contracts_gpu.py\n?? tests/integration/test_state_gpu.py\n?? tests/integration/test_surface_actuation_gpu.py\n?? tests/unit/cpp/\n?? tests/unit/test_build_contracts.py\n?? tests/unit/test_context_ownership.py\n?? tests/unit/test_fine_surface.py\n?? tests/unit/test_initializers.py\n?? tests/unit/test_numerical_operators.py\n?? tests/unit/test_planar_velocity.py\n?? tests/unit/test_refinement.py\n?? tests/unit/test_reservoir.py\n?? tests/unit/test_simulation_lifecycle.py\n?? tests/unit/test_slot_velocity.py\n?? tests/unit/test_state_regressions.py\n?? tests/unit/test_surface_actuation.py\n?? tests/validation/analyze_j3_saved_frames.py\n?? tests/validation/diagnose_j3_lags.py\n?? tests/validation/multigrid/\n?? tests/validation/run_j1.py\n?? tests/validation/run_j2_slot.py\n?? tests/validation/run_j3_coverage.py\n?? tests/validation/run_j3_reservoir.py\n?? tests/validation/run_poiseuille.py\n",
+  "patch_sha256": "9cf8b5cc4ea037c865762ba7069f0c1daabcb4383d4333167d279f8b7704e5b0",
+  "cleanup": {
+    "baseline_copy_dir": "/tmp/celeris-fine-surface-baseline-z98oi6ps",
+    "baseline_copy_bytes": 1581541,
+    "runner": "/tmp/celeris-fine-surface-gpu-run.py",
+    "baseline_copies_removed": true,
+    "runner_removed": true,
+    "gpu_scratch_removed": true
+  },
+  "shared_kernel_exact_extraction": true,
+  "diff_reverse_check": "passed",
+  "evidence_hashes": {
+    "cpu_surface_projection_command.txt": "b1783e26e92737106a5614fff01452c8ea0364372d9bdbc44c7d15c19d9b13f5",
+    "cpu_surface_projection_exit.txt": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa",
+    "report.txt": "ad8af2be7239f8fe728ac7a8db340d4458e6ec1bbb30b14e614c1072dd9804ec",
+    "cpu_existing_runs.json": "523b3179b976c2198112c7b49c6c8a75cf7d3332663a8b8a0646c94a39abd1b4",
+    "gpu_run.json": "8c4b4d7c53e17c30ce4c7d2fb92466e0704f39966e89016dbf82d36cf96e35bf",
+    "gpu_stdout.txt": "02d1f6fea194d1185a49b7bcdde58642f1d6b9634fe55e4bcda2f020414eb35d",
+    "cpu_device_guard_cmd.txt": "43a0fb0e20c4adcf1930f145796378294558060d5fd5303402e0538674b68c0a",
+    "cpu_surface_command.txt": "2b8f2a3c9ddfd1e877efa2a50a935eeb937e2b3ea92515610cd334d80703d6ce",
+    "baseline.json": "dc9dfa88e69d2b7cf93b0c572961c0bc7849ea1608a0b14b1a6dca1429abf87c",
+    "cpu_lifecycle_stdout.txt": "af52542989b4a2bf597e020c12064e7083e136f15b938ed5382b616a16f70e38",
+    "cpu_surface_projection_stdout.txt": "96ea3e4ca948962b6eb92aaf215efb6c598a3c4b296f6fd26094df353ded5722",
+    "cpu_lifecycle_run.json": "2a3b09ad2f9c86e43892d643a510c9e936d6153e2ae1f6a9eab90c3067f0473d",
+    "cpu_shared_kernel_stdout.txt": "1ab9905d8b0f34f6d791ff7da4efa2de0f7f3e282a078758cc0496cc0230c0f0",
+    "cpu_device_guard_stdout.txt": "f4c61c0ac8f55c6c9a2d6c593731bf5f8c4a6c5bebbe514284fd4f899818f9e0",
+    "gpu_test_run1.py": "3dd0658f63a4e7a1c41eecf433842c872f8fecb391ea4b44d0b48947643d5189",
+    "gpu_preparation_run1.py": "b3fe9e58118369adb1bdfc618fbfbd917d508a563beaf2555f656b59aeff4425",
+    "cpu_surface_exit.txt": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa",
+    "cpu_surface_stdout.txt": "bdb786f2d289eaeab4e53d0fdccb998525c217efaa778496cf7a97ccca9e1597",
+    "cpu_preallocation_run.json": "363106050ba00d9a1c5c948c36926e8510ed7fdd75d28cfeca59f593fd0f1c50",
+    "cpu_final_stdout.txt": "bdb786f2d289eaeab4e53d0fdccb998525c217efaa778496cf7a97ccca9e1597",
+    "cpu_maps_stdout.txt": "7886fd4e2fa8a63e9cecf02bdf650e5447ba149704ac75f51da6964d8e77ba6b",
+    "cpu_device_guard_exit.txt": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa",
+    "cpu_preallocation_stdout.txt": "59907462a8d5fd93406cdf4c7d1eb2f7b7a96664ae85c4ec202693d419cd019e",
+    "incremental.diff": "9cf8b5cc4ea037c865762ba7069f0c1daabcb4383d4333167d279f8b7704e5b0",
+    "cpu_final_run.json": "020a9ef12904c2d18185613d68a58dd7ff9b1b22197ac1f95bba61f2f593eaac"
+  }
+}

research/fine_surface_20261014/report.txt

@@ -0,0 +1,115 @@
+2026-10-14 — 固定加密区内静止圆表面吹吸：受限整合交付
+
+状态：当前代码与验证完成，停在独立审查点。A 的单层静止圆功能保持；本次只
+把完整边界 stencil 位于 fine active 的圆接入 FixedPatchStepper。未增加
+checkpoint、forcing、运动刚体、喷嘴内部、墙穿接口、blockforest 或临时 ledger。
+所有 B 反例与既有证据保留。
+
+入口与单位
+FixedPatchStepper(cfg, bounds, context=context, fine_objects=[obj])。
+obj 是现有 SimObject/CircleGeometry；中心/半径用 coarse 物理坐标，速度沿用
+coarse lattice 单位（当前 dx=dt=1）。构造独立 fine-local 副本，不修改调用方对象。
+C_local=(C_phys-origin)/dx-.5，R_local=R_phys/dx，U_local=U_phys*dt/dx。
+真实 hit 反变换为 origin+dx*(hit_local+.5)，lever arm 乘 dx，角度/q 不变。
+维持 D2Q9/SRT/FP32/unshifted/double_buffer、无 LES/forcing 的原 backend 范围。
+
+生产改动：5 个现有文件 + 1 个共享文件，+300/−71，净 +229 行。
+- refinement.py：FineBoundary2D、prepare_fine_boundary；纯 CPU 建图和拒绝检查。
+- refinement_stepper.py：固定 fine 对象、flags/SoA 管理、两个 BFL 子步、solid
+  叶掩码、初始化与释放；不接完整 Simulation/ObjectManager。
+- aux_kernels.cu → step/curved_double.cu：原 action_omega/CurvedBoundaryKernel
+  代码块逐字相同，只抽取共享位置并增加 include guard，已比对确认。
+- refinement.cu：包含共享 BFL，PatchFineStep 接 flags；solid 不 pull/collide，
+  输出 NaN；所有 Python launch 传完整参数。
+- 原 lbm/stepper.py：allocation 显式 is not None；驱动缓冲缺失报错。
+
+数据/所有权
+explosion → BFL(current) → fine pull+collision → BFL(spare) → fine pull+collision
+→ coarse pull/coalescence+collision。active fluid 每 coarse 步碰撞两次；solid
+与 ghost 不碰撞。BFL 只填当前输入的 solid source 反射槽，下一子步重新填充。
+下载仅发布流体叶节点，coarse covered、fine solid/ghost 均 NaN。
+flags/level/transfer arrays 归 stepper._allocations；SoA 的列及速度/交换缓冲只
+归 SoA，未重复登记。initialize 清空最新交换缓存。无对象不创建这些新缓冲。
+内部交换缓冲仅代表最后一个 fine 子步，未新增公共 coarse 累计诊断。
+测试账本分别读取四个 fine 子步的实际 population，按面积 1/4 求和；不是用
+latest 值冒称区间总量，也不是喷嘴总推力。
+
+有限依赖规则
+plan.transfer_reads 保存 (hop, direction, cell)，从实际 coalesce_fine 的 hop 2
+源槽反向两次 pull；遇 active collision 展开全部 9 个输入，hop 0 停止。
+transfer_fine_cells 加入全部 ghost_fine/explosion 写集；coarse 集合包含实际
+ghost_coarse donors 与 coalesce_coarse targets。ghost 可以合法参与运输；
+outer ghost 的各阶段有效性仍按原 kernel 判断。
+逐条检查 r active fluid、s=r+c active solid、反射写槽唯一、q<.5 的 r−c
+仍在 active；不可用 fallback 掩盖跨层 donor。同层真实 solid 阻挡的原 fallback
+语义不改。逆查所有 active-fluid→solid 邻接，确保与 cut links 完全一致。
+整个 solid 集合及 r/s/donor stencil 均不得碰到上述 transfer footprint。
+coarse donors/targets 必须 uncovered bulk；slot 模式另外拒绝其真实壁面
+reconstruction pull stencil。无对象旧 slot 模式保持原规则。
+
+CPU 结果（原始 command/stdout/exit 见同目录）
+- 新建图/单位/边界覆盖/拒绝检查：15 passed，最终代码复测 15 passed，exit 0。
+  同行补充的非对角圆心、origin=(2,2)、四子格平均等于 coarse I+.5 也通过。
+- 旧 maps：9 passed、23 subtests；共享 actual CUDA-header CPU 回归：1 passed。
+- 旧生命周期/边界模式：5 passed、5 subtests。
+- 新缺失驱动缓冲拒绝：2 passed，exit 0；同步失败后释放且不重复释放：通过。
+- 指定 donor 反例通过构造器检查，context.activate/mem_alloc 均未调用：1 passed。
+
+真实 GPU 结果与首次批次失败说明
+使用现有 pycuda_3_10、显式 PYTHONPATH=/home/frank14f/CelerisLab/src；stdout
+首先打印并断言实际包来源。设备 0 UUID GPU-e8853ae7-a302-6a17-bcfa-aa767e9ed20c，
+开始时占用 5 MiB、util=0、无计算进程；未用其他设备。
+运行批次真实 exit=1：5 项 GPU 检查和 1 项 CPU cleanup 检查通过，另 2 项 CPU
+缺失缓冲夹具失败，因为夹具未提供新增前置检查所需的 fluid_idx_gpu 字段。
+仅补齐夹具后，定向 CPU 重测这 2 项 exit=0；原日志/exit=1 保留，未重跑 GPU。
+
+5 项 GPU 检查：
+1–3. speed=0,+.002,−.002 的批准小案例，各 2 coarse/4 fine 步。
+  coarse24²，patch[4,20)²，fine40²，origin(2,2)，dx=dt=.5；物理圆心
+  (12.25,12.25)、R2.15 → local(20,20)、R4.3；angle.7/half_width.85；
+  nu_phys=.05，tau_c=.65/tau_f=.8，rho1/u0/G=feq。
+  三个驱动使用私有 audit build 验证 fine fluid 碰撞4次、coarse fluid2次，
+  solid/ghost0次。零驱动另与正常 production build 的 same-solid/no-actuation
+  路径逐元素相等。参考采用正常 A build 的48²、dx=dt=.5、circle local(24,24)，
+  对齐真实物理位置与时间（4 fine步=物理时间2），不是跨分辨率逐元素比较。
+4. 旧无对象 periodic 非居中矩形 normal build：1 coarse步，最大人口误差
+  1.14050047e−7，通过。
+5. 旧无对象 slot/reservoir normal build：8 coarse步，最大人口误差
+  1.78241457e−7、最大BC误差2.21654773e−7，通过。
+
+主要数值：
+  speed       max |BFL误差|   max |累计质量/动量账本残差|    预定FP32预算
+   0          7.4505806e−9          1.6049482e−5             0.00221051117
+  +.002       9.7307344e−9          1.5977304e−5             0.00221052543
+  −.002       7.4505806e−9          1.6636681e−5             0.00221049693
+BFL阈值1e−7；同细分辨率、未触接口的圆周ROI人口atol3e−6、局部矩2e−5均通过。
+账本预算为8*eps32*实际参与加权population绝对值总和，未放宽。喷吸附加质量
+分别约+0.00620033871/−0.00618575338，符号正确。该短例净transfer项为0；
+仍逐项统计真实非零出入人口，但喷吸扰动尚未触达接口。
+
+拒绝证据
+- physical C=(5.05,12.25),R=.7 → fine C=(5.6,20),R=1.4：r=(4,20),c=(1,0),
+  hit=(4.2,20),q≈.2，donor=(3,20)为ghost，构造在任何CUDA调用前拒绝。
+- physical C=(6.05,12.25),R=.7：全部直接r/s/donor都active，仍因与真实
+  两hop transfer footprint相交而拒绝。说明通过边界检查不能仅靠包围盒或边距。
+
+资源与记录
+GPU批次外部耗时25.395s；进程组RSS峰值386883584 bytes，RAM最小空闲
+63638339584 bytes，VRAM最小空闲15826 MiB，相关临时空间采样峰值3585985 bytes。
+按实际余量保护，无固定RSS/AS上限；120s与2GB本次临时量约束未触发。监测是
+采样方式，不是OS硬资源隔离。编译临时目录已清理；不会清理其他任务或旧证据。
+baseline.json保存382个src/tests/examples文件哈希；其中377个保持不变。
+manifest.json和incremental.diff只描述本轮；共享kernel抽取相等与反向patch检查通过。
+GPU执行后仅将建图时的孔口预检输入改成与实际八列完全一致的FP32 lever arm，
+避免极窄孔口在分配前后得到不同覆盖判断；最终CPU15项复测通过。GPU算子、上传
+数组生成方式、步序和测试数值部分未变。gpu_test_run1.py/gpu_preparation_run1.py
+是按GPU运行中已记录的SHA256逐项核对后的执行版快照，保留首次运行的精确来源。
+
+参考与边界
+直接复用A已接受BFL。ref/OpenLB/src/boundary/defineU2D.hh:74–79用于真实hit
+速度投影对照，offBoundaryPostProcessors2D.hh:115–127用于两分支stencil对照；
+OpenLB commit fb62326f260bf0c5ec2666fc5e055c0813ff50a9，仅算法对照、未复制代码。
+现有CPUREF-0.3与实际refinement kernel的ghost不碰撞、两hop/每层tau、incoming
+替换后coarse碰撞保持不变，未移植任何B候选。
+不声称喷流穿粗细接口精度、长时稳定性、空间收敛或性能已验证。设备free()自身
+抛错时沿用既有close限制，不保证完整释放或重试；上下文激活失败可保留资源重试。

research/fine_surface_joint_20261014/baseline_00.json

@@ -0,0 +1,182 @@
+{
+  "src/CelerisLab.egg-info/PKG-INFO": "0b9a8a4e8d60bc531473688723ddef0aab02c7ccc4997e31c9b6a6c35011ca77",
+  "src/CelerisLab.egg-info/top_level.txt": "cd51958ca03afabbaa9618c60b8280e486f8cc0b0359b839e10f886e7c3948f8",
+  "src/CelerisLab.egg-info/dependency_links.txt": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
+  "src/CelerisLab.egg-info/requires.txt": "36e1404178e5ea590b2fc04e8ba4d748ec9a82e7693136ccf0dfd204fe265c04",
+  "src/CelerisLab.egg-info/SOURCES.txt": "f36b29c1b34c4bd6b2acc3ccdd21c24ee5077df7e2a20a652d9fae77eedb8e21",
+  "src/CelerisLab/simulation.py": "c9d903f53fe356d7af281bea07943de1a62494127fb69848d7053fd46f7dec3e",
+  "src/CelerisLab/config.py": "2f1bba7515f5bc08cb3a8d140bcafe7fa0689e01b3b06494697bb2956a71530e",
+  "src/CelerisLab/__init__.py": "21cc469bd6e970a1f9ff5970c8eea4602065e41fc881854759ee565ee55c10c6",
+  "src/CelerisLab/cuda/compiler_v2.py": "c4cc3ec4445c8d75e6a253dd87963877117a722bc73b9d4811806fc6045d08c1",
+  "src/CelerisLab/cuda/obs_layout.py": "5ffb2c3aeeaaaaeb64f2cd8febfbcf4ad9919e5414020ad753cfade0683b21c2",
+  "src/CelerisLab/cuda/context.py": "013dd4ec6d01d2fbd11afdfb103eac6a273bd9f798d663d761b851eeb27885e9",
+  "src/CelerisLab/cuda/__init__.py": "0d01dff9f0399c8baba822aab5ca0122a135f011008ed8a499ebd9f7e5b06aea",
+  "src/CelerisLab/lbm/refinement_stepper.py": "9178224089ee6584420b79f10cf1d91441645b668e8b6898641d19eac757687b",
+  "src/CelerisLab/lbm/field.py": "0e727eacc3706add4d8d15c418e9b631050871f831698d3ac689dd5f2c701b9b",
+  "src/CelerisLab/lbm/equilibrium.py": "2fb2f2bb7ff326d23abce80fc2a4c0907b17740ea3e29fe6ae079c5044783826",
+  "src/CelerisLab/lbm/descriptors.py": "c9f025dfc14da43b989047b84cc22bd05d5cc92c9ec695c1da68fdfb788e3f2b",
+  "src/CelerisLab/lbm/initializers.py": "dacf9586963e862d6d0a98ef1a066036be6f91e9d423720661d8ef2c1fb2df6a",
+  "src/CelerisLab/lbm/curved_links.py": "00d9c29d660b41190f32dd737b12f60e10ce4214b6c9a6ab2a63438813faa594",
+  "src/CelerisLab/lbm/stepper.py": "0dcb7cd7ae87e33e3dc67a38b6aa43042fbe673e37d9ad165342ee1d695933ce",
+  "src/CelerisLab/lbm/__init__.py": "7f60fb3aaae81501b510d08c2fedff44fcb05657260eb10b6f5cc91e7204306b",
+  "src/CelerisLab/lbm/refinement.py": "8935b070ec9e7020897919c15f43f7fa6293f02e2ff64a19a3e3d99bc444dbcc",
+  "src/CelerisLab/lbm/kernels/kernel_v2.cu": "c7bd3fb705b77261ba2441c52a24a7e6a7865c165cba088a1b75201c4d29c408",
+  "src/CelerisLab/lbm/kernels/refinement.cu": "129f3d91da93b4324f88a0da73a4da1e5390f72c14cce574ee63306712da9895",
+  "src/CelerisLab/lbm/kernels/config.h": "7d1124125e0b354558297934460e64c760fb68cdd7bf6d01a1238bb2eaab8c37",
+  "src/CelerisLab/lbm/kernels/kernel_v2.ptx": "a599ee30ae66800f4d4220eb79dfed35ff32991661260f01ea58023ef780f0ca",
+  "src/CelerisLab/lbm/kernels/operators/turbulence_smag.cuh": "ff7f000297ee0817e255ad9fcb6a13b647e3ddd5b206518d35f38d2895a9f501",
+  "src/CelerisLab/lbm/kernels/operators/collision_mrt.cuh": "aee444eb60c47a3fd518dca975d1af05425a0818a0ec6c3fb3f6150f60c2cb44",
+  "src/CelerisLab/lbm/kernels/operators/collision_trt.cuh": "9725b9840b9ad8b4ec7be61ff5d06d3151e86d1a87585c13f2fbf934d0d2c5f6",
+  "src/CelerisLab/lbm/kernels/operators/collision_srt.cuh": "6b7ff842f392c8f853d2d1a97cc69bfe50f21283f73e659404da07cf6c95f5e1",
+  "src/CelerisLab/lbm/kernels/operators/forcing_guo.cuh": "969a430c1af03f32e3bd0df95d805e64f56334717c44dd4ba208ba503062a24b",
+  "src/CelerisLab/lbm/kernels/operators/macro.cuh": "e27c1c410dc857be98da4596568e405eeaf88701d291ac0e398aa9cd23dee740",
+  "src/CelerisLab/lbm/kernels/operators/helpers.cuh": "0b3a4d95d7d19f5fec09e5423b8f4cc99f8a226b541967425967330da5a051ec",
+  "src/CelerisLab/lbm/kernels/core/precision.cuh": "849df14b4cce50af52399e4b8f3e997196f3ae5f1163f68e28df3e6b2507a8c4",
+  "src/CelerisLab/lbm/kernels/core/descriptors.cuh": "8440bc14857da9007982650f828a23608eec9f7cc4bf772e8c8dc1239cb45356",
+  "src/CelerisLab/lbm/kernels/core/obs.cuh": "b742b77c9f61e1f020fe9922c3838ae9d855e17b381154958b58f10a22938922",
+  "src/CelerisLab/lbm/kernels/core/params.cuh": "6e18bf730d936d940e3d85452f0714a2eaae31bf41002f9fd520ec5b372878dd",
+  "src/CelerisLab/lbm/kernels/core/flags.cuh": "0025705f24710330d9d9195f713879bfb650a85a3449baef0e196b831af104ab",
+  "src/CelerisLab/lbm/kernels/core/layout.cuh": "1fbd820021c89ac3efcde24145996cb0147769e607e498e61f308ed3e0b13706",
+  "src/CelerisLab/lbm/kernels/boundary/ibm_kernels.cuh": "e6909b547dc8d64cdd8a76a90660243a8f5fee535caa161b52b4dd8b7c29934b",
+  "src/CelerisLab/lbm/kernels/boundary/planar_velocity.cuh": "0b2f9e0bd483c199637e5672dc0ffc460bc383dd1804805befbeb4c5d8c708d1",
+  "src/CelerisLab/lbm/kernels/boundary/inlet_outlet.cuh": "de8b213a6da42c2e5e9f8966199fc66ea4541b85144a90f3f5dbad3c6ab63b97",
+  "src/CelerisLab/lbm/kernels/boundary/curved_boundary.cuh": "7bccf7e7091c012d7a3d4874a881d4d46699021faedd83d125933fbdaa562711",
+  "src/CelerisLab/lbm/kernels/boundary/bounce_back.cuh": "aba3748c564ed91b161d268ef8b737b7c7be96a823063d201f3da684dd845233",
+  "src/CelerisLab/lbm/kernels/boundary/esopull_curved_helpers.cuh": "b9b474bc4edaff05681c5443235472d04072d0d775fc0eb9c5967faef52b0258",
+  "src/CelerisLab/lbm/kernels/boundary/inlet/equilibrium.cuh": "f0964c811b2c41a5aaa1c6d99c490b06e850c634eb8749f1f05ef61f93c2de1d",
+  "src/CelerisLab/lbm/kernels/boundary/inlet/channel_stabilized.cuh": "efe077afcbb6b731256a987c2fd79a1dbc470c902f87070d60421ea6cb13d4e2",
+  "src/CelerisLab/lbm/kernels/boundary/inlet/common.cuh": "f3cec54c8873c65b3dca4375605d2c89a8727765884d3954c235242fdff9c6ba",
+  "src/CelerisLab/lbm/kernels/boundary/inlet/zou_he_local.cuh": "e73e66b853b1e4e0e30d8f4185d832aa414ce670a1813ce2b5459f2887f71f89",
+  "src/CelerisLab/lbm/kernels/boundary/inlet/regularized.cuh": "943d4a571818bacb89c70bccfaac202691121e3e385803ce6309123a0a03ddaf",
+  "src/CelerisLab/lbm/kernels/boundary/outlet/pressure_neq.cuh": "c8b2adc66d12fe602076ddc9693c5c208711fcaddb58aa9a31401a269f51c4c4",
+  "src/CelerisLab/lbm/kernels/streaming/esopull_single_buffer.cuh": "77ed4ab9a0ebc5ff62a91a7c39066ef395391ae36e9040a69fb2bd8b1626dc79",
+  "src/CelerisLab/lbm/kernels/streaming/pull_double_buffer.cuh": "b65d741ed78b7b62f99531ba0c0ce1936663d8dc9640e7d7d16c707f1baf6549",
+  "src/CelerisLab/lbm/kernels/streaming/esopull_semantic_helpers.cuh": "dd5a9091628b079efd97e53fd49e52d09dcee88529235db77a5648e02937af6e",
+  "src/CelerisLab/lbm/kernels/step/curved_double.cu": "bfa7a1df1e939020314d49755045f7a85fe4a19cc1c68dbe62653c66c5e7c2b3",
+  "src/CelerisLab/lbm/kernels/step/esopull_sync.cu": "c0ff3e72900c3ab89a05dd03684e96d3b740cf1672d565727fc2af165933d087",
+  "src/CelerisLab/lbm/kernels/step/init_flow.cu": "305be3bb12fc0d039acec1701baabcf0e8a35e683c49c34f2af8ca9867d2b29c",
+  "src/CelerisLab/lbm/kernels/step/esopull_macro.cu": "c73116020ca217ede1e4de27c8269c31f9d91e33433ac8252a21e9b14187c50f",
+  "src/CelerisLab/lbm/kernels/step/aux_kernels.cu": "578a5b20a157241ee678547059abb1372dd5a589ad06bb2c15b987eb01ca1013",
+  "src/CelerisLab/lbm/kernels/step/one_step_esopull.cu": "aa223b2744ae6c9125673df311a96ce588032c1ba58bebb11fd33ecb990f8ed4",
+  "src/CelerisLab/lbm/kernels/step/one_step_double.cu": "f9f8242b38e8e0cf8425b75e2b0215bc15363c62eaa0fb43c761b8e0931bfdc9",
+  "src/CelerisLab/lbm/kernels/config/config_physics.h": "26df33c2960ba36f3283e19b55b4ea92e50e4efda705f9ebfbf3f875a4092c59",
+  "src/CelerisLab/lbm/kernels/config/config_method.h": "3db4e16ef2c6b22349d04e6aa8ab04bdfe0eb784f9f3a98277e15dbed1835d81",
+  "src/CelerisLab/lbm/kernels/config/config_grid.h": "8be3a7cf74ba30d7fd3074fed79e63dbda7311c4d03b454ea641bf298ffeaa8d",
+  "src/CelerisLab/lbm/kernels/config/config_objects.h": "dbb93c063586da278c15d95e23f84c12e728f4f5f1bbc3980fe9cedaa6fff90e",
+  "src/CelerisLab/lbm/kernels/config/config_obs.h": "c11e2249359145b5c4cbaaf0487506fa77c1f4b82c7c169ddc574aa0babcd727",
+  "src/CelerisLab/common/checkpoint.py": "b2f960aecd5ac27a3a7130b809ffad4709c44d522edef0359ab952654625410b",
+  "src/CelerisLab/common/_types.py": "aad2ff1a9033d4fd68783ad7123afb47201ddc58785cb6dc0246947037072a5f",
+  "src/CelerisLab/common/pathline.py": "a1b6efcc0a076d0f1dc8d49a595779426d7d5626b00072a59bac710ff02ad046",
+  "src/CelerisLab/common/__init__.py": "d4dbde78bc97fccc9eabac9abae8f0f15c112c10ff8e9b45bd9401d4723df1ef",
+  "src/CelerisLab/common/preprocess.py": "7fc78a08857cf8e98519500b094a1d896af189b6b15658ff9b388ed51bed4515",
+  "src/CelerisLab/common/render.py": "0e055476257eb2bcd11e733766e52195de02f8fad228f570a3511a7c831bdc29",
+  "src/CelerisLab/common/streakline/_render.py": "236cd637414ee318c4d66f9aed32110d8dc42a100d65fde06172f7cd0ba62c65",
+  "src/CelerisLab/common/streakline/_integrate.py": "3fbd4368b2c8d0e7fda40dc65aac5df02b085008b4c68acd83cb7ae45d33a13b",
+  "src/CelerisLab/common/streakline/_streakline.py": "1a3e08daa706b5f83cdeb337e9a945a36ddf7583c40af1d0bb9d825ac954df37",
+  "src/CelerisLab/common/streakline/__init__.py": "13ff1cfa416fdd721a08a659e76b5a5a99b8d3201add10a83b7b0bc654bc1eec",
+  "src/CelerisLab/common/streakline/_config.py": "a9185ef68e9c7b5d5a1dc0b04a28341e2ad91d13c145a7c106636a878cf0a605",
+  "src/CelerisLab/configs/config_lbm.json": "17e4311f1f250c6ece59177a8b6ff856b69a016c7c10267e774b030a0a390865",
+  "src/CelerisLab/configs/CONFIG.md": "41cafdbe525366c08aa9d0416ea026ccf0026ba7123b8a9b65f968a80d928e3a",
+  "src/CelerisLab/configs/config_lbm_three_cylinder_triangle.json": "eeb8e7149dbe4aa6b3a9562802735aa950750dfbe2d972a0727e788573afa817",
+  "src/CelerisLab/configs/config_lbm_flume_trt_regularized.json": "f4bba8e6a4339fc3c4eb14f6e2f57c4b22993c73703c773d853edfbe34736e56",
+  "src/CelerisLab/configs/config_body.json": "055f261f0828ca1d4f2bb694bd15b72bbcabe31d552326208f28e37f761adab1",
+  "src/CelerisLab/configs/config_lbm_flume_mrt_zouhe.json": "8f593321db05a563a42931603a228d61cbcba06dfbe113262d5cd0ad93c0fe79",
+  "src/CelerisLab/body/objects.py": "d1cf7054cc8379a83c39acc66a7c88ae62fa004f110bb0c1def2ee57137401c5",
+  "src/CelerisLab/body/action_smoother.py": "b1a23ee6bbd4850b172cb8738c5c3546ee465a54189e6af9d8044f023d4687dc",
+  "src/CelerisLab/body/registry.py": "fbb7327780adbdc6da15ebdb799980daf32df22ee974af0893d7409f177bbb68",
+  "src/CelerisLab/body/manager.py": "6a40be708c71ef6f3b5f5f0aa9c92cfafc51f2ec2a958f99656cccb850986c16",
+  "src/CelerisLab/body/ddf_patch.py": "60fcfb7441e73bf290bcff41ca3a83da3e7ddad765d7247464e8f02e3043b4e2",
+  "src/CelerisLab/body/sync_plan.py": "a73ac9ee361b2120d0b7bbebeaa2ccbf924ba27bd95d4dd4b383c10a39b2a409",
+  "src/CelerisLab/body/__init__.py": "91d1155080b3ade83d13c84c39693046df122e4bed5ef583de2df1f9453c1b76",
+  "src/CelerisLab/body/preprocess/flag_overlay.py": "831fc9e9736b758847759a085ff133eb49ec91318ace4fda76f85960138ee300",
+  "src/CelerisLab/body/preprocess/__init__.py": "dfd9d58bc07f626ab23a70053e31b88a6d9165d2e4c76a4e9f48abe674d3d2ec",
+  "src/CelerisLab/body/geometry/base.py": "cceca14361ca2f34d34a3e43730e1a79b8ca81be00f0dd62e884db32b479419f",
+  "src/CelerisLab/body/geometry/__init__.py": "ada88980ab672959aca9aa3a4c4aade3219524b2ab68110cd2a2f41e3e0ca90a",
+  "src/CelerisLab/body/geometry/circle.py": "7605ca7c21103f1d801ac73ab8dd18dffbdac425b2dee7b8858b283628a9e436",
+  "src/CelerisLab/body/coupling/soa_packer.py": "8ec26fd55ef74801bbd5ab6bd3d0a7dabc750cbd498aaac2ca4c61a0108ad3c9",
+  "src/CelerisLab/body/coupling/__init__.py": "c931f7eb318d48408c3e2febcc6917c88c8dcc1697cbf4329b1f340d94c35763",
+  "tests/conftest.py": "fa0ec26667872c9c1011d608310d2551fd24719b5d216f06d923ff4c74c73237",
+  "tests/specs/exp_ctrl_matrix.md": "5d9dd2e703582572eb68afe3a7096ea43ec82aa03418d20ed283c5365031e433",
+  "tests/specs/Sah04_validation.md": "1d122d29e281b7f50801b148f3314a0e35fdc27ee7d757c0a661243aa6185fb0",
+  "tests/specs/sah04.md": "33dbe5e0fd63738abd055c4aa403c191b6de04e6efdbc568f1942c6d23c7459f",
+  "tests/specs/Kan99b_validation.md": "0d8bf74f2361f863809af1979bf8807adaa423f98321e1104a3d86d8c7a863cf",
+  "tests/specs/kan99b.md": "b7e0669f0a6b677d902204f3427d1b3ac254bfe70c37d9cf995fb3e8f1fedfb1",
+  "tests/specs/streakline_notes.md": "cd342d214c07eb608ac2e5b8697322c44c31dbf4d27dfdb5409de46ef474df4b",
+  "tests/validation/run_perf_baseline.py": "93dde2eb1132f45ea69e1e285ff421dc97a83651a22c79571f299c1909650721",
+  "tests/validation/run_j1.py": "51b758a271ff358f931b3140a80082294a67e66c2fec0f8c19319e37f92aadc4",
+  "tests/validation/run_kan99b_rotating_cylinder.py": "323186429a100f36b41ab9b81ade2da6a47e93be3ccb7034a3a6b97f4ee8eb00",
+  "tests/validation/run_j2_slot.py": "b7d2d3aa06fcafc3ac62ed4a50892afbdb7f86e5720ce75a39ce317b6f571dad",
+  "tests/validation/run_j3_coverage.py": "329869519b7078e854d96241a7aad8ef93f35ac9be83f0be502c3a93523c3b13",
+  "tests/validation/run_sah04_st_matrix.py": "9b9c0ce063e07a316846635ee769b837ed26be6bf039f78f4219c10b516f8006",
+  "tests/validation/analyze_j3_saved_frames.py": "438f67dac682b94c4950626f8de4fdcde48c3a4e9ecf8fdf1b0ada4b6e0e781a",
+  "tests/validation/diagnose_j3_lags.py": "286fcd65b3261667a847b9b26e213d0af92cf459faa6bbd774f78c8479ce31d7",
+  "tests/validation/run_j3_reservoir.py": "47535bc3569ce68c888d38978bc4f9077fd763a17829c20c081be52bb18a2903",
+  "tests/validation/run_poiseuille.py": "e529288e2ffa8e00d281a9006723954d60a96ae4d025e8f28656c09287d4ff46",
+  "tests/validation/test_sensor_accuracy.py": "c6038a9e7a597a1738814bd15e6ecf357cfd271cdc2a132d47943c5280ac0ef9",
+  "tests/validation/multigrid/test_cpu_reference.py": "ade5d4827f971aed7174b59d83769e7aa542338e625a9fc8db1e8b1805cb74ca",
+  "tests/validation/multigrid/cpu_reference.py": "bba2a06a9f6517b32079ffff15e4060d8c3b7ed35f16ca134e1877226c9e4e1e",
+  "tests/validation/multigrid/test_fine_surface_gpu.py": "d45ca48fc4e77d021fcc5461329b094ae11b257c036bb23634d326fbbedb7700",
+  "tests/validation/multigrid/cpu_reference_v0.2.py": "b6adbad7da625ef6a6b97958ea9625030ed92676d0cada48e061c87bcf7ca8c9",
+  "tests/validation/multigrid/test_open_corner_negative_control.py": "59a6f8ca80cdd63cb7827fbebf9b4b555c3793f19dd6bca801544ec10b5cbe1b",
+  "tests/validation/multigrid/test_refinement_followup.py": "6643e26cd877bf0d0f030e974f00a1d1c0f0350cc76d1c8affed3e8ba2f4393b",
+  "tests/validation/multigrid/local_stress_observable_v1.py": "0e2777990359a7cf2bb29884173b7b01de37c49bcf49e1f29fc59fe83d62b456",
+  "tests/validation/multigrid/test_refinement_gpu.py": "0021a39b3a131347196845cff6507c90c387b46b772fe1319d634178c5e13354",
+  "tests/validation/multigrid/shear_diagnostic_v0_2.py": "a8b1cf2f7abd00efc4d068bbd27bb2317144a6ca4c545d9b2e0dcf421eadebc6",
+  "tests/validation/multigrid/test_tron_additions.py": "8e7a6a90b85e64c7326719e7b8bca2f6d34fb4c80690f0685f7e291ab93bd2a4",
+  "tests/validation/multigrid/MULTIGRID_VERIFICATION_STRATEGY.md": "d4f3473da44abee6031a0e1bd4d0ca589077a18f15d2461836e4d2ebb98e458a",
+  "tests/validation/multigrid/shear_v0_2_evidence/stdout_horsea.txt": "0577df5b3f5cb3c7b6e1ef2de71344f8fd3e6d959117487a06cbaf7f2afa3dea",
+  "tests/validation/multigrid/shear_v0_2_evidence/stdout_grok.txt": "28ddd1267ca91a772f5a6bfc65d949c9a4ea7dac5c9ba3a0bdb168492810b670",
+  "tests/validation/multigrid/shear_v0_2_evidence/run_once.py": "6698a2e040c56be949b809387d4518eb0ba82d34cc9d99640da4f8bf3c35c23f",
+  "tests/validation/multigrid/shear_v0_2_evidence/source_manifest.json": "56fbd0259ff3d4dbd14ace52f64e249a435e9df91732b0e4027def2c344c2e6a",
+  "tests/validation/multigrid/shear_v0_2_evidence/results_horsea.json": "c2d7ce8d16a0f47baff0788a153353dcf67088da974d9cd3d521b04ecd91ee05",
+  "tests/validation/multigrid/shear_v0_2_evidence/comparison.json": "41c00372099dd04b6d323785e9eaf4fec09da1753d3d150ffa230800f904142f",
+  "tests/validation/multigrid/shear_v0_2_evidence/baseline.json": "98a7853341ea732762c7506694e3a867a7259bf110e9e461ea84f741fd9ab829",
+  "tests/validation/multigrid/shear_v0_2_evidence/manifest.json": "e42aa19e91608164698bea42da88fbbfab8b0f87cc37b27c5baf165453a4fdb0",
+  "tests/validation/multigrid/shear_v0_2_evidence/README.txt": "4306a34b6896bd6e7a5c2ca71d68e18450359239d0c7ad7a67a4e83e7155959a",
+  "tests/validation/multigrid/shear_v0_2_evidence/joint_report.md": "1860b8082108c8b8a87998af90cd0b81dce1c04e9f6c67b41e0912f9fef6cc9c",
+  "tests/validation/multigrid/local_stress_v1_evidence/stdout_horsea.txt": "882f2cfb1dbdf82cce63c011397e7c2e6307bbcfec42a3510648d328cd6ddcfe",
+  "tests/validation/multigrid/local_stress_v1_evidence/run_once.py": "e629800291ef65ffea8555f66ec80bf15200552540b2a493a677bfb53d0830b3",
+  "tests/validation/multigrid/local_stress_v1_evidence/source_manifest.json": "d2cf90b73458f493c665c9a281d06aef0c190cf0d143639fb77ab838c78f020c",
+  "tests/validation/multigrid/local_stress_v1_evidence/results_horsea.json": "f17b4644d19eb75d55deb7021ab679cb9e7922a2b46f1cacf8b6da6bfb9a2690",
+  "tests/validation/multigrid/local_stress_v1_evidence/comparison.json": "be236671a501c31c06f7e266f6e0c0c2a89aede321a483452050ff37bf84c84a",
+  "tests/validation/multigrid/local_stress_v1_evidence/baseline.json": "64f6541447afbd15b1b15d802ad6f1b5042aaf84e7d4d2414e4ed4c52cf70507",
+  "tests/validation/multigrid/local_stress_v1_evidence/manifest.json": "3a9fa8c7d691c1b8c24f05940eb724d30b890dd8ed636551068d2633d7db2f70",
+  "tests/validation/multigrid/local_stress_v1_evidence/README.txt": "4f62314876047ee437bb9ecbf84798d2a9f6e85f6a3aef260277b85bcdb35fae",
+  "tests/validation/multigrid/local_stress_v1_evidence/stdout_local_stress_observable_v1.txt": "6a826e5ad729ce45af6879a07a1c659d8b4a21403fde5b9c6d9696cc6a5b09d4",
+  "tests/validation/multigrid/local_stress_v1_evidence/TABLE_local_stress_observable_v1.md": "d8ff0568d9c473a4bb09396a8948ddc8dc5af2f0f3a23ac84d238814fc779501",
+  "tests/validation/multigrid/cpuref_0_3_evidence/stdout_horsea.txt": "457f1d2173496554c87ca6e61df518c0b8f1e0a28cdfd94b94ebbb61bc459d70",
+  "tests/validation/multigrid/cpuref_0_3_evidence/stdout_grok.txt": "73e4ef01138842981daaa534390f1463839e63833c11f4e8872f94f8eaadc717",
+  "tests/validation/multigrid/cpuref_0_3_evidence/results_horsea.json": "914389afc39752bcd4132aa21fc8d5cbcf0ca75b1efd6a49becab15c2fa3361b",
+  "tests/validation/multigrid/cpuref_0_3_evidence/baseline.json": "0daaccee41cabeb17a00e2405e2c7fd0b80d36f2d01778eb39c9fd22b13d2d47",
+  "tests/validation/multigrid/cpuref_0_3_evidence/manifest.json": "2850ecaf2e19d010ba35eb54162371d82cc1a092831e08a03b6adf75a614988b",
+  "tests/validation/multigrid/cpuref_0_3_evidence/README.txt": "1947ee0232b88b3cc2c506d0b0af5ba051ecc94aa8f7f09228ef3939cc95919b",
+  "tests/validation/multigrid/cpuref_0_3_evidence/README_grok.md": "065947e15b2242bce7d3eb05a3acdbb59939c621dcd5d31540ad4a1bd4416818",
+  "tests/audit/\u5ba1\u8ba1\u62a5\u544a_kernel_layer.md": "89893c98ed7c2699157bf728ec0e79b0dd6aff4008ee5c7b77eb052de24033f1",
+  "tests/audit/body\u91cd\u6784\u7b14\u8bb0.md": "8f978d7b01c9f49dca9eeaff0d163cec6da085e2f99ee5a5e803d72306e7a72f",
+  "tests/audit/\u517c\u5bb9\u6027\u6d4b\u8bd5.md": "9c1721a33b381b9c3810545772b022913da06617711b5ba13a3c2c991b81a7f7",
+  "tests/audit/Force_region.md": "3092080afe4a30665fe1b721803621ba9d0dd5d20ad17826984d94efc160fdac",
+  "tests/audit/\u5ba1\u8ba1.md": "0f14ad073a0725134e6391f961c324fd0013c7791fd410713e94ed1ad40b7385",
+  "tests/audit/Force_region_validation.md": "279a4484d1bfca0fd67aed4de3282d547aa048f89389420d8e5f2fd86db54fc2",
+  "tests/audit/body\u5220\u51cf\u529f\u80fd.md": "e9f308a8cd0f0e7df5441c32a15f84c0bae50bc0e56b8728f6c6f2cf78596673",
+  "tests/unit/test_initializers.py": "8b4e3358d925614984265ae73c142006b48fd1c3918cf84901f18afd9fe68c3a",
+  "tests/unit/test_simulation_lifecycle.py": "77abdc33218c35e9c8b62dbd99ceddbaccd8417e7f0b539ea8859ea0175c663a",
+  "tests/unit/test_numerical_operators.py": "6d1d560ef553a2af7adac7db3e325d96d7fe39073d5fe3e0e982439537385b27",
+  "tests/unit/test_fine_surface.py": "b232b55e75eef52480f06a35c401d72b6145892bb8b79d1d1b3cfed965b3506c",
+  "tests/unit/test_sync_plan.py": "983313ef783143231fa5a392f85f3bac011184773ccaf5d946504c206cabb721",
+  "tests/unit/test_surface_actuation.py": "89be6f54c4eba6c2bdca0d287a5b9fa6db143de2bcd9a671d4fb8445921303ed",
+  "tests/unit/test_state_regressions.py": "0f69cfeb83428192f95688c76abcae7e5b9cf5f27c52bca4ac20c7f320044374",
+  "tests/unit/test_equilibrium.py": "1ecbcc4547b1c846b75320463d828d6a36b6aae73208084fae476b1001c1bb50",
+  "tests/unit/__init__.py": "17f57920d9c1ff46096ceb2af008eb38c4b98dc81ffa3c3d310e758e80ca1cd4",
+  "tests/unit/test_pending_edits.py": "905a0dff23b123e8e38aaf364984c810fe51c39acd64aa271e343a4701d3d024",
+  "tests/unit/test_planar_velocity.py": "b656da0880b4234b1db805544edbe0d2473cbcc7c2c869c71d8251337f62a982",
+  "tests/unit/test_body_flags.py": "ac6409157924e15a13a3d2cc2f1a09014b8b0198ba17c824f412ff20b19e2aac",
+  "tests/unit/test_build_contracts.py": "7bb237425e8bb481f312fa4841c484e280731e13c7cbb9a53dad3e7f98984ac3",
+  "tests/unit/test_context_ownership.py": "299fed30dd0f9bd4dadd8b27f50df2a6367bdb0ab2ca3f391f215fde7241f35a",
+  "tests/unit/test_reservoir.py": "e718c78a53c3941aba7feb8ae4e8bb0b1726c1145de84febf91220c1917991c9",
+  "tests/unit/test_refinement.py": "90751142f920f1c5e988577a45afa94871a6617009cdc78323a87fc7795f4634",
+  "tests/unit/test_slot_velocity.py": "6a9494de9a32c350389ccbed58af48951f6b25a21a258537d2e8b73eb67cb11d",
+  "tests/unit/cpp/semantic_regression.cpp": "99dba074c0c0a32ea76026e7d54fc60af8e6d3dc5315c8900c470b4518878f39",
+  "tests/unit/cpp/reservoir.cpp": "c3eacaf0271400eb45ad559b571a8f7faa2a809d5f1857ffeb5592addce2cd0c",
+  "tests/unit/cpp/collision_regression.cpp": "f17acdff74ab82a62dc5402b42e3f6a149c262e89b140494164d6ebd630f5e14",
+  "tests/unit/cpp/slot_profile.cpp": "31ac58ccab175bf79fa59fc46d4c0842df18ab0a5e5916be84760d9da2b75788"
+}

research/fine_surface_joint_20261014/baseline_01.json

@@ -0,0 +1,182 @@
+{
+  "tests/unit/cpp/planar_velocity.cpp": "8dea266984edc69d4e0e68007e038d7a587e99f84e33478d6656a66a56680933",
+  "tests/integration/test_body_sync_e2e.py": "d29f01771f3512a4b3ad06fae4ee952327d7fd9f0476942402fe92e9e327fcec",
+  "tests/integration/test_sync_bodies_skeleton.py": "65f55a0980659b49ae0027f0642a27e2ebaead226ef083f233e878150884b07c",
+  "tests/integration/test_numerical_gpu.py": "002a6745929bd5ee86a9491ea9bc3f97602fb825ea17262ea190c9311881100e",
+  "tests/integration/test_ddf_patch.py": "dda2abba32ca13e17098232f2831a0b1b66439c35f8931d9997a0257250c1281",
+  "tests/integration/_cases.py": "ab76ca1096d2d10fb05b3539aa8ed3c7e549619bae6900ac98723f6c3c908f2d",
+  "tests/integration/test_surface_actuation_gpu.py": "3c2b4dda70db1d6493ecd92bd9b0dad6d8b438cdf6dca46410018217f8beb4da",
+  "tests/integration/__init__.py": "c354e43ba09b55a8013a2df2069438740b5f48b5917d855e52e33ab5d7da5a6c",
+  "tests/integration/test_state_gpu.py": "dde0948941e8abbc5ea10a3acb3a35abbaea576f36ecee0f1120fbcf7454d60b",
+  "tests/integration/test_runtime_contracts_gpu.py": "775e578e2e8072af32fc740b2698abbb79454235a0f3ee929ac4c75d747f8db5",
+  "tests/integration/test_unified_obs.py": "4a681536099741d92bdc258525fe3374cbdbeba0d49996e53808381a1b6a13fa",
+  "tests/output/exp_ctrl_matrix_streak_ny300/summary_C4_deceit_f1p5.json": "11dab8440d8c4f385061d2536403f4313c6f026b4e0b7672681327a9f4f37ebb",
+  "tests/output/exp_ctrl_matrix_streak_ny300/summary_C6_deceit_f2.json": "e0c4e8bcc55da5dc8de1e2fe88029aa3e67453734faa44451f5a6dfa9131557f",
+  "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C6_deceit_f2.png": "e0a66708ce2a29c4c6b854d2596b3ffca181dc6e35d99cc94e08af3e2d8c024e",
+  "tests/output/exp_ctrl_matrix_streak_ny300/summary_C3_deceit_multi.json": "24c8e433aab6d207dab67546c4079868c4244c2948c32c94cd08e4f331991807",
+  "tests/output/exp_ctrl_matrix_streak_ny300/summary_C0_no_ctrl.json": "cf3af733a08f081cc5f879e8da79d7c60104099f4452af5b2a4a96c0e6bd5889",
+  "tests/output/exp_ctrl_matrix_streak_ny300/summary_C5_deceit_multi_f1p5.json": "a4cb4ff4481b39b9ee61b1d7209416237a7fe86b22c5068d713ccec9c3f7afe4",
+  "tests/output/exp_ctrl_matrix_streak_ny300/manifest.json": "d8a20dacc92321d98354684976f771a9ca8989fc63ddcd78e15c7768c6617671",
+  "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C3_deceit_multi.png": "c6fed617cc6ffe6677157a9b58811d5f4613725eb98a5aec830fd07dc1aac38e",
+  "tests/output/exp_ctrl_matrix_streak_ny300/summary_C2_deceit.json": "7526a6b20a158461b85b1a64070b46c2b21be1e01c5ee025e6746fcf47ea3397",
+  "tests/output/exp_ctrl_matrix_streak_ny300/summary_C1_stealth.json": "63d34a0ab33e9fa8fe7311363efbd1b2875691f5b4958bb645b8c7ac38f1ad6b",
+  "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C0_no_ctrl.png": "0cfd7ce8f9d743bf22a7a694b4e5a3616557cb8f1db2f4ddf49cc4bef96efef2",
+  "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C4_deceit_f1p5.png": "4dcfc186928dcb83d28e9eb4cb2ecb4b163eb6f121d57036b4c05ab162be0951",
+  "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C1_stealth.png": "5e3cbbefda06fcef243d7d06d74a473972350cfa4ae88bdfdb349dce13943151",
+  "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C2_deceit.png": "22f1db77499bdbd1b3cd35f5b58b1a884dd94a86fdcfef07abd4157e6aaf8d19",
+  "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C5_deceit_multi_f1p5.png": "823e475cc901af3d6f4d0c56eb07822b3e73a2b9d0aa23e20e3741023fe90092",
+  "tests/output/kan99b_validation_esopull/summary_runs.json": "fe3294a953580204319fb1143434e15096d8455b6073100dfe0d5491b76af394",
+  "tests/output/kan99b_validation_esopull/summary_runs.csv": "1a44bb27ee0a7fe0270905248c37364834248cdc8710bd68142a6a79bbdad82b",
+  "tests/output/kan99b_validation_esopull/force_csv/k2_k2_inlet_control_domM_re100_a1p000_zou_he_local_mrt.csv": "9fbc7d507c129ed85c68a9a313e3eb3431470d091bd7723e63f8afd8a3d2b737",
+  "tests/output/kan99b_validation_esopull/force_csv/k2_baseline_domM_re100_a1p000_regularized_mrt.csv": "8faac43f42d6e0c70085c6e616bfff4df8de897e315fc0d2b4aa8bd635c3fa05",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C4_deceit_f1p5.json": "b613ae55fcfbd45a1a922d6d529e5274ba9d2987fdf5620fe866b889b931e48c",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C6_deceit_f2.json": "dbf54f9a183072547b22fa14334f0167e6eefb21c1208c4e8584bc196545a399",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C3_deceit_multi.json": "2100c6cc5c358a249804ce8f6f98531f3bc868e27af6d21a9d441b1b6a9e479e",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C0_no_ctrl.json": "a8b4697b7c0caeb958f80e282e32d673deac8c914008d64e6b38f7883eacc57e",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/state_C6_deceit_f2.h5": "8d0c28566d2230b422691b738cc453705496bd150be038a576c0c0fba218fc1f",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/state_C5_deceit_multi_f1p5.h5": "608767ca11d104fa4506b57204a0c8dbd739688224ebd924fe517ce9e21db823",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/state_C1_stealth.h5": "a83c988cc8b1173a7b2f13b132ed7243e98304dccab2965aa16cf4d32f8df007",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C5_deceit_multi_f1p5.json": "6f6b9300782178e0ac9308a677bd9cb1565a383a78dff4cd52dea0bd464db31d",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C6_deceit_f2.png": "21bbe2dac1ab06ca1b172ec62d00daa7bcd65d99adac0ed03c5e30bed59e871a",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C5_deceit_multi_f1p5.png": "602a6586277699968b4cb167b134c8c406577038af088aa70baff682691398c4",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C1_stealth.png": "c1e1d04f266deac5fb2815a8283da80f9139ffaccbec2219d98544296bf3152c",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C4_deceit_f1p5.png": "96dee924e89b90091192a8d7b43321f109a5491511b8a83da77cfc611ae0d93b",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/state_C2_deceit.h5": "aa5800a0cd594eeb7cf5449d6469d55e0c9033ced0ee0a3b5d59152e68c7e263",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/manifest.json": "5d28f0f5428d7f0341e20d5d1f19c17bbc6f0f9b2a441d3c95f5422f3f2b4bd4",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C2_deceit.png": "1dcb6fb959f944d7ad89c4abaaef4d1fd4a77db8901804530e86fb336b883eb5",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C2_deceit.json": "b88ff5049aef59876b349d105f1c3467c17c9ba9022a48a77a6984f20da34345",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C1_stealth.json": "515689cbfaa30a9e39d9907939ee194a4836b644a5e9124586e6b7221d2b394b",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C3_deceit_multi.png": "d69694a1a1b2f2ea0adc7b74b7526504e2ad0b5d6317bac9b3159b2e7e88cf90",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/state_C0_no_ctrl.h5": "3a858d6be0a946e1d26bbfa192c2f0ca3910c0f140b42575ec9d9529dd99155a",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/state_C4_deceit_f1p5.h5": "660e4619ea530dcd18c3afb2e7fa22cafd9cdba1be7888e31ab5b76a0902d2fc",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C0_no_ctrl.png": "6d4d3934f1c8b20c2a5c742ae080a7143f0c139741966adf009a227c27e9bb1f",
+  "tests/output/exp_ctrl_matrix_vort_nx1500/state_C3_deceit_multi.h5": "1e72126f11b2995437cecb8cc0eeffb8807efbfa43d8f346f28711fea98ddc90",
+  "tests/output/kan99b_validation_ref/summary_runs.json": "449316c30585a8de9997538dead5d4e35a59bf00a2ac22d01b101ab600a4bc06",
+  "tests/output/kan99b_validation_ref/summary_runs.csv": "e8b9620f3772e5e421026103e456e6e844a91292f40affb96174c9dbde9b6e4e",
+  "tests/output/kan99b_validation_ref/force_csv/k2_k2_inlet_control_domM_re100_a1p000_zou_he_local_mrt.csv": "4391f41d17ebeea1092f13b901923ced4ee2a1c5b346b79ef791d692847286b5",
+  "tests/output/kan99b_validation_ref/force_csv/k2_baseline_domM_re100_a1p000_regularized_mrt.csv": "105c6eb21f1943d9d935246eab1602ff2016c415a139e24fee2793e88e006ead",
+  "tests/output/exp_ctrl_matrix_vort_ny300/summary_C4_deceit_f1p5.json": "0085a679a423621003eea81d4ac83bfe2edef2879eed7809d2a3675a212f791a",
+  "tests/output/exp_ctrl_matrix_vort_ny300/summary_C6_deceit_f2.json": "e820cf73f0e90bf93c34b24416e7692a6c2e51352ccf490fa6714d0812331ca2",
+  "tests/output/exp_ctrl_matrix_vort_ny300/summary_C3_deceit_multi.json": "571370c74ad9af589f3dc214669bff3d857efe6fc4fa13815b5d793d12b53770",
+  "tests/output/exp_ctrl_matrix_vort_ny300/summary_C0_no_ctrl.json": "ec5b89961033d8ebe0d66ce1ec7940dc2faf98130c38319bc9984ef654e60b50",
+  "tests/output/exp_ctrl_matrix_vort_ny300/state_C6_deceit_f2.h5": "2792be74d8564fa29fd0636fc8493630fba2779c165b44330197095b3e296b18",
+  "tests/output/exp_ctrl_matrix_vort_ny300/state_C5_deceit_multi_f1p5.h5": "2c64ee6c7a4ea2c42ed8f3d274402bec62de0e02ea0340e16022f0cdc92af724",
+  "tests/output/exp_ctrl_matrix_vort_ny300/state_C1_stealth.h5": "100727d94fe6c2e46d7807eed0442555bdd1e26ec9b04b4c457171a2bbba3255",
+  "tests/output/exp_ctrl_matrix_vort_ny300/summary_C5_deceit_multi_f1p5.json": "f86166f121b4eeb6d74d8176c9265e7a3ccfe2540d040f554b6f96e6a6222c16",
+  "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C6_deceit_f2.png": "fef4de0e3ac8203742f35c16a02445b19c3f556b11f73abd5d8e3ca05ca33d78",
+  "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C5_deceit_multi_f1p5.png": "9136448e6d7565ca5af3666f9cf6e154342d8a3475076abfdbdd1ff9faec34f3",
+  "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C1_stealth.png": "544537a9c500a05937fd3be17c25e7d887461d9b83a15564f9ab7063208f40f6",
+  "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C4_deceit_f1p5.png": "51e7056db99dd653affbe913d52fa41df6ec0db921109384e3c679bda06b5a83",
+  "tests/output/exp_ctrl_matrix_vort_ny300/state_C2_deceit.h5": "39d6c162085acae1612650da37d2314757715931e83a854e08bb01407d0f8efc",
+  "tests/output/exp_ctrl_matrix_vort_ny300/manifest.json": "05fbc2e7bbad4267a38e1094bbdd6bee6ad270412bdb5e92b0dfc9fa56969517",
+  "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C2_deceit.png": "07fc5817eba30371272b87ee2e023c0a1144077d1bef77efb2fd5dc284badcb7",
+  "tests/output/exp_ctrl_matrix_vort_ny300/summary_C2_deceit.json": "b1fcf76039c91a9080b830352dee2e95316d754b968cc27a8f68c51527661e76",
+  "tests/output/exp_ctrl_matrix_vort_ny300/summary_C1_stealth.json": "b78851637b9b7b93070524a2933cae1dab6d682f8894579b2849c64921e6c29e",
+  "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C3_deceit_multi.png": "2658f0747ed7287f7912fe15cc58a086e01ba284277cb98689bac01ecb6ec12b",
+  "tests/output/exp_ctrl_matrix_vort_ny300/state_C0_no_ctrl.h5": "57f73f5f8dc4b32b156bc82300b1efd1e4eddadd9b8dc51cb7e6b41fa5c966bd",
+  "tests/output/exp_ctrl_matrix_vort_ny300/state_C4_deceit_f1p5.h5": "2864b9dd086709ee8b8c3f262118a5130b0d40c86838f3ca0deab5bb898dafa8",
+  "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C0_no_ctrl.png": "2c7f3a8be2ee540afdfb66299e43a65583434bee84bde590124524a82868c900",
+  "tests/output/exp_ctrl_matrix_vort_ny300/state_C3_deceit_multi.h5": "39e0d9b032dfff8cf057b410a98973729285e7d03e89f9a6a002aaf7de3d7519",
+  "tests/output/stealth_sweep_fix_check/summary_stealth_s150_w0.02709.json": "8b1032e13975bb05c6a810fde175c8da51bacdb3dc745fd11c1049ca63bbf136",
+  "tests/output/stealth_sweep_fix_check/summary_stealth_s050_w0.00903.json": "fa7da24d5dab9fd3a3c2dea6b50d0224c7a99cd9141796e137304a6040b1ac8a",
+  "tests/output/stealth_sweep_fix_check/streakline_stealth_s050_w0.00903.png": "640928f7eb159e7caea32036123f86c281723d083cca46839ba86bce8361ada7",
+  "tests/output/stealth_sweep_fix_check/state_stealth_s050_w0.00903.h5": "187ac365f9f7370c888c4c65570c47e42465b2fccd432056c176528d45cf0c2f",
+  "tests/output/stealth_sweep_fix_check/manifest.json": "83a3f12a942fb644e470bd07a72f24921f2147d7df429110268c5c96a9953d1a",
+  "tests/output/stealth_sweep_fix_check/state_stealth_s150_w0.02709.h5": "e057e9db26b2546c0704e2c959cc7d2aac91e6a49b4c7ee75a409597a5db8716",
+  "tests/output/stealth_sweep_fix_check/vorticity_stealth_s150_w0.02709.png": "d2d202088624cf30868228f9c913ee30e1b386aaa2c22b0ea89be43dedc0712d",
+  "tests/output/stealth_sweep_fix_check/streakline_stealth_s150_w0.02709.png": "0edc7caa9caaffb754490bf1f6ac7ad7180e45a991439a3f4f83ed949a082a1a",
+  "tests/output/stealth_sweep_fix_check/vorticity_stealth_s050_w0.00903.png": "4088359b17c46ed4d7c8401d244808fe67723273b1d16d0671b69f9478c68c1a",
+  "tests/output/final_validation_round/validation_summary_report.md": "881cb7052e5a555afc87168a37268ee66e8e3fba172533706e858d996fabc7b9",
+  "tests/output/final_validation_round/sah04_mixed/s2_d48.json": "83c6c01201d90aae5c49e73ebeca88d1c7ded6cc83c13f4892a9188e6289483f",
+  "tests/output/final_validation_round/sah04_mixed/s4_reg_d96.json": "b32f03e6b347fc709cea2ecd488df0f85849c733bf6a4b9cf65ea69401c93a1d",
+  "tests/output/final_validation_round/sah04_mixed/s1_d48.json": "120e8e878f5712dc89b7cf78c7f8d0e3368d34ad5ef7494977e083b188a54c18",
+  "tests/output/final_validation_round/sah04_mixed/s3_stablecfg.json": "b38a3d197a188e65c163d974113af18f332b3abed083e2654e998d9980f6be9f",
+  "tests/output/final_validation_round/sah04_mixed/vorticity/s3_mrt_laststep.png": "dc96fcd05d458684cfb40d4cb741172213083e2f2665e2bae7e1f0267bb3575d",
+  "tests/output/final_validation_round/sah04_mixed/vorticity/s1_mrt_laststep.png": "73a3580ba3c7fe6ffeee4676a9a51b5bf678d6fb523456a61e185598389ea1e1",
+  "tests/output/final_validation_round/sah04_mixed/vorticity/s4_mrt_laststep.png": "57f2a82761f2de1a9fc2b78ee86159ca542c966494b9c704deb451da857da778",
+  "tests/output/final_validation_round/sah04_mixed/vorticity/s2_mrt_laststep.png": "786f492b96ed932254b5452e2d06ff088727f2d88c7e7c7b47d386eddfe07862",
+  "tests/output/final_validation_round/kan99b/full_summary_runs.json": "8c4a11cbf555e08a66698439170b850c57d537d8e75e4dd75beb767bbf7e38cf",
+  "tests/output/final_validation_round/kan99b/summary_runs.csv": "3fa92fdd3114f0472de44bc03006af1d4b694dfc69b06704c1667cd3627b6dab",
+  "tests/output/final_validation_round/kan99b/force_csv/k5_baseline_domM_re160_a2p000_regularized_mrt.csv": "de05e9699146f2adffc9d7c9991f9e48396aacd142afc3c08b2b64727c83c69a",
+  "tests/output/final_validation_round/kan99b/force_csv/k3_baseline_domM_re60_a1p600_regularized_mrt.csv": "53cd0dc47328b7b370eced1130508655e6815a29b727bf1fe4e4e125e4918905",
+  "tests/output/final_validation_round/kan99b/force_csv/k2_k2_inlet_control_domM_re100_a1p000_zou_he_local_mrt.csv": "4cac1ccfdb7451de3e26d921a6406cc55d1d4630e10ec0d7ec9350a4abd49404",
+  "tests/output/final_validation_round/kan99b/force_csv/k4_baseline_domM_re100_a2p000_regularized_mrt.csv": "392c98de52011ddb344a5761c4520e870f4e49bbba3e144e5a02818ba2f9250b",
+  "tests/output/final_validation_round/kan99b/force_csv/k1_baseline_domM_re100_a0p500_regularized_mrt.csv": "9e83c5175aec644c0b97c081e610deefa731b87aef04da6297abf662a71c0702",
+  "tests/output/final_validation_round/kan99b/force_csv/k2_baseline_domM_re100_a1p000_regularized_mrt.csv": "55b071f278e153aa353aa2bef85f0bce35b910a7b08103032023fe3a28169b89",
+  "tests/output/final_validation_round/kan99b/vorticity/k2_k2_inlet_control_domM_re100_a1p000_zou_he_local_mrt.png": "b91b332e7deb787975d3f08fa3325facd4a972b536694fcda52e6c01943c42cb",
+  "tests/output/final_validation_round/kan99b/vorticity/k1_baseline_domM_re100_a0p500_regularized_mrt.png": "6e7c3f6567c0ff0d00d75da8373031f5ba2a17a624cb8c5d5d6ae4f8749c33c0",
+  "tests/output/final_validation_round/kan99b/vorticity/k5_baseline_domM_re160_a2p000_regularized_mrt.png": "c4d232df2e6f7466acca711191d976aa9411ec0ade81572b531463f42a7d633a",
+  "tests/output/final_validation_round/kan99b/vorticity/k3_baseline_domM_re60_a1p600_regularized_mrt.png": "b2314c60491d20933422e1697998555dec2436d39545c71f990e9906884685b2",
+  "tests/output/final_validation_round/kan99b/vorticity/k2_baseline_domM_re100_a1p000_regularized_mrt.png": "2b2797b8f53170d04d1a70d1cdf898f7e41b3a76b9f3c1f276dfec952520ab04",
+  "tests/output/final_validation_round/kan99b/vorticity/k4_baseline_domM_re100_a2p000_regularized_mrt.png": "8135f470404fe11ac97968fa580ee35232e90dcace3c6ad94de17ef7aace24d6",
+  "tests/output/kan99b_validation/summary_runs.json": "d7239aac64884202558741074f2d644ade9e2365d94d0b7556fba68dac94868d",
+  "tests/output/kan99b_validation/summary_runs.csv": "c44da69563d58b917291a9fd402d1f57055861bffab6f9e32d7db91297428d45",
+  "tests/output/kan99b_validation/force_csv/k5_baseline_domM_re160_a2p000_regularized_mrt.csv": "27b64460923d235d34b760f2a2371ad01611a70e38edb03d6fd6a2fe7a7de6e0",
+  "tests/output/kan99b_validation/force_csv/k3_baseline_domM_re60_a1p600_regularized_mrt.csv": "76ff52f4494b7ef7650c05968732a8caaba94d2b151234c02cf624f5b3a712ab",
+  "tests/output/kan99b_validation/force_csv/k2_k2_inlet_control_domM_re100_a1p000_zou_he_local_mrt.csv": "28a83436ca8bdad38865ba21ce1bda679562a5ae1cfc6ee8fc6e86ff760ec66d",
+  "tests/output/kan99b_validation/force_csv/k4_baseline_domM_re100_a2p000_regularized_mrt.csv": "823ae04870fd951879024a18169ac5cba8db4b3201726f6a00f320f1958d04c6",
+  "tests/output/kan99b_validation/force_csv/k1_baseline_domM_re100_a0p500_regularized_mrt.csv": "a591daf2cdecd6ac3689fa2a2aba917b23053ad26e3ef1f635c81aecc451475f",
+  "tests/output/kan99b_validation/force_csv/k0_baseline_domM_re100_a0p000_regularized_mrt.csv": "e95c27c646c0c9baf8f455f876c115c8dbdb23cef9d9d550f455098bf0c03b55",
+  "tests/output/kan99b_validation/force_csv/k2_baseline_domM_re100_a1p000_regularized_mrt.csv": "3c2ea79a0e27f561215febee2e165d24b3617a648bf908981c068ba59d549c51",
+  "tests/output/stealth_steady_sweep_nx1500/streakline_stealth_s125_w0.02257.png": "a892f18c74fe13efd839bfd5068097ca0ae07acebf6c06eed89e1b867e41fcb2",
+  "tests/output/stealth_steady_sweep_nx1500/summary_stealth_s125_w0.02257.json": "7e542f59746429022ce1794854c6fb36e8ac658dd0aea3bc1140a45e83a3f1c9",
+  "tests/output/stealth_steady_sweep_nx1500/summary_stealth_s100_w0.01806.json": "b76216e0fbee00ef754edbafe5790a99ce7d53638af629947ddd9615598e4c08",
+  "tests/output/stealth_steady_sweep_nx1500/summary_stealth_s150_w0.02709.json": "42cb241d9cfb01308ce28e129756b6cb3fe2a8e9679518da84bcb8b607fe92ac",
+  "tests/output/stealth_steady_sweep_nx1500/state_stealth_s075_w0.01354.h5": "558be308dbf334832bc1d29419ba5be142969117a11b124864f6b221c8fee509",
+  "tests/output/stealth_steady_sweep_nx1500/summary_stealth_s050_w0.00903.json": "53b579811a0b651ba7cc466c230c115b9f88486c6675e0465d0715d3377a75cd",
+  "tests/output/stealth_steady_sweep_nx1500/streakline_stealth_s075_w0.01354.png": "9f4a7d89b2471becaf31e84c14402441c5fd96fc7190cea5e8a9fdd06ee62002",
+  "tests/output/stealth_steady_sweep_nx1500/streakline_stealth_s050_w0.00903.png": "5f18f56b0ff2af3350216b65540a2bc664c569520624cfc6cc2439a3c5369560",
+  "tests/output/stealth_steady_sweep_nx1500/state_stealth_s100_w0.01806.h5": "30776f333959e0e9eb5ca96b269e6a8052c5b94941a4e3b36d8a6af8076920ce",
+  "tests/output/stealth_steady_sweep_nx1500/vorticity_stealth_s075_w0.01354.png": "b5393474d99191e88dafea4144b6a8eccfbdf75107125ce4b05383b17007d06a",
+  "tests/output/stealth_steady_sweep_nx1500/state_stealth_s125_w0.02257.h5": "4ed9d8587f75ad4625ec5501fa99fb733cde037180ac53f92a210ffbb08375de",
+  "tests/output/stealth_steady_sweep_nx1500/summary_stealth_s075_w0.01354.json": "ff1c1cc649e589b5425787493c2b0d04b6c39b43043b1968d65509cb0a426e82",
+  "tests/output/stealth_steady_sweep_nx1500/state_stealth_s050_w0.00903.h5": "4de51584b24095f8cf4480b8941593a5f913332f9396061ed077c9d49eb2ee11",
+  "tests/output/stealth_steady_sweep_nx1500/manifest.json": "0dfbb2c1b5bf9093fef169e4dc6319edb5c87a1e967e8d558613e2c64a2ca734",
+  "tests/output/stealth_steady_sweep_nx1500/vorticity_stealth_s100_w0.01806.png": "60824cbdf21170cb4ffd8af0a49e8522c2d79cb2694690ab67995ee973265efa",
+  "tests/output/stealth_steady_sweep_nx1500/state_stealth_s150_w0.02709.h5": "b22d54a05cbd3138a1fe585a825246989fcff7c00f51aa9312a4185d963db933",
+  "tests/output/stealth_steady_sweep_nx1500/vorticity_stealth_s125_w0.02257.png": "c1e1d04f266deac5fb2815a8283da80f9139ffaccbec2219d98544296bf3152c",
+  "tests/output/stealth_steady_sweep_nx1500/vorticity_stealth_s150_w0.02709.png": "bcf098083a73798dc3906807218058cc571435a010234a5a350b585ba9915c78",
+  "tests/output/stealth_steady_sweep_nx1500/streakline_stealth_s150_w0.02709.png": "3bac21cc75a01429399cec308d6bf5fc8918917def1bf5d7fec1cb6003390a41",
+  "tests/output/stealth_steady_sweep_nx1500/vorticity_stealth_s050_w0.00903.png": "a675f41df763f0a1ac0a06386315806b24f2571f5dabc8693fcd871a13ed22ba",
+  "tests/output/stealth_steady_sweep_nx1500/streakline_stealth_s100_w0.01806.png": "92515588596596cc1d691c643fa48cf828492c2eaed96355dcec58109de4b5aa",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C4_deceit_f1p5.json": "0393661f08b748428fc366eeecec3b34b9d9a013aa6b151a15b33c7e3c0e1818",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C5_deceit_multi_f1p5_step080000.png": "bffef412087e426b614d8c05e59bd7580ee49bb77319279ddc4c1bf825678c49",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C6_deceit_f2.json": "de067f01ef5c11249d67bbe5e02db6f2b4c5590214de02609bca115edf8dee64",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C6_deceit_f2.png": "846badbae81b75f765d89e5a7c4f88aeb5d57f2387511e4f2f84c72a192ea9f2",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C3_deceit_multi.json": "eb21d1c69e51f01c1a6be1ce59fe86763089ea5aa667b8872d0186af035b24b2",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C0_no_ctrl.json": "780a0d329cb86990a17a088f49084410abb1fad24f659255918e5ddda6b3dabd",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C3_deceit_multi_step080000.png": "ff7836b8229d9a5dd3900f499fe3e7f0c73a61c7109b6e6e79b11a0fb459bb63",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C0_no_ctrl_step040000.png": "f2b56a7e30bcc363ed69fc19705403181ac5de90800eef03039a389a65869e30",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C5_deceit_multi_f1p5.json": "261b698723f19526a447679a2be8666c8d0cbf6df81b0c9de6d051960d77308b",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C0_no_ctrl_step060000.png": "0697e0ae06a01154afdcf00330ba870bd8f36d21561a33846ad7ba63fb731179",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C1_stealth_step040000.png": "1de3d7f54e91c5d5850f4358d1872e16fefb36d32a1b6293facb54524e32315c",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C0_no_ctrl_step100000.png": "91f0bf6ed3e854f7f83623a3f19bb12c83b4aac239e3eaa849fbe50e7baddff5",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C0_no_ctrl_step080000.png": "303c1d2d4c49b4a7495365c8cb2bcbfe9bdda7cbc0a7c7dd1f01e8aa62b3573b",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C5_deceit_multi_f1p5_step040000.png": "dd5945458a35d81b31a0e2f3a693a5023d6960474263e7dc86c22367a56cc13c",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/manifest.json": "0d97efed02f775c25dd8a2d7439f310b715d142ff8d603c9da6ddab197570ce8",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C3_deceit_multi.png": "69022ef9175acf910374ec73848640548b85fc7beb7e6950843f52c10ed7d61b",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C4_deceit_f1p5_step060000.png": "16ba30b8cca0d49e6b76be0bb4f0d14bbf276ca6ec47ebf56907c7534e15c4e0",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C5_deceit_multi_f1p5_step100000.png": "8548b6dff635cf9c92e2baa119866277e3994366eb31aeb30641b03b3d80ee9f",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C2_deceit_step060000.png": "56100f169c3e378b84bfc89c5477d2c142ca043d9f28eaa70bc5448c49c7f4d5",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C2_deceit.json": "587cd42d81b1325bbc766d9ca6c1fd3d076bf5a772efd45d056c2c4e3db742b6",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C1_stealth_step060000.png": "e43e95e7126de8cb857154353f161914c225f8c9f17eb44b1ff744249368a4d5",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C6_deceit_f2_step080000.png": "676d21ffc7180d34a6725a8bf49503ce59f48d65500450c3975d01e65162899e",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C1_stealth.json": "73040aeb7ef07c538d4687b101c599210e660202eb1c2c3e0894dfbde682d137",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C4_deceit_f1p5_step100000.png": "e22171ef86979c4398c45ada9cd0f5e4c4e5b034f271df5fa8ac9a762a8554cd",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C2_deceit_step100000.png": "0d73042be73b0de8d0a591e56c01e3c802483aa22a97f27e0300cba82c708066",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C4_deceit_f1p5_step040000.png": "a6e95fd5c24052db20d5ece200edcfe5e261c00950ca964c89df9f7335579634",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C0_no_ctrl.png": "d74061347ac3505fad878e330f6cb04d23bdb13082bfa1afa2fda0872f80f388",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C4_deceit_f1p5.png": "3156400eb59fae0638556c2711345f12ca49d951ff09e6464a2271249409a6a7",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C1_stealth_step100000.png": "d69e34c82da98b28eef7f1af29f5d11f400e90f628049f6f5f4a3a419a4a4340",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C6_deceit_f2_step040000.png": "ce1f372b517dd52fc3f3eb066145e04ab6841e43b67cb0f6bfbdb42a6738eca6",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C3_deceit_multi_step100000.png": "07cce6c99dfa7b56dd4d3aa452873a676a5a00e9f046555fa9dda30f16dde488",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C1_stealth.png": "a892f18c74fe13efd839bfd5068097ca0ae07acebf6c06eed89e1b867e41fcb2",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C6_deceit_f2_step060000.png": "80b63bd309ef11a3ebb2f1ef301b49cd8f09bcc25562097d382f859306c9fe6d",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C2_deceit.png": "1edb30dc35e29ad991695353f4b84e0507792935ec75ae9a7904ebdc007a471a",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C5_deceit_multi_f1p5_step060000.png": "93ab8e09e58a64c5dd2eedfdafd27cf4dcfe4e8fae1af64ac71eac509e6ffdaf",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C3_deceit_multi_step060000.png": "f773bdef1c8d718d01b6d6d7735182c04564dd8b5692b359e1dd2f721c774b1a",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C4_deceit_f1p5_step080000.png": "5570fe6a25c92e5c6aa9a5129aa1797ba8ee7418170c7a351f9e35b931a366c7",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C1_stealth_step080000.png": "32d3e700286eb4b46b3bcf757669481affd6ff6b53792d730b5a21da92cc57d6",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C6_deceit_f2_step100000.png": "5acfe36694bb4e628309ff8ae1e839ca0a1f684607165bbc2883436b85208bf4",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C2_deceit_step040000.png": "2c6f2b8d61cc2aaa63631eb6c98d3de26dcef705fa6b66c823ce7b9eef50e00c"
+}

research/fine_surface_joint_20261014/baseline_02.json

@@ -0,0 +1,182 @@
+{
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C5_deceit_multi_f1p5.png": "adbefd0021e2c981d026718de8c63594b9c8e5971901d1dc40835cb69d95b93e",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C2_deceit_step080000.png": "ce8b18e4dd976ed590fcc44075f3fb058ca7b23e15a1624726c181c4dd0c11da",
+  "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C3_deceit_multi_step040000.png": "168d21ef24ae198fbfd642f8ca315faad4c7bff2e2c09e16ff7c97e7360ea883",
+  "tests/output/screening/screening_summary.csv": "3a23c4f2bd54ed5ee9bdb5b6dcdc58eed04519fcf1b4790e0abd1e6c5288fb96",
+  "tests/output/screening/screening_summary.json": "caf64530f152b6b8ccec82a3c7ba44fa0b3aeb0e0221ef6121857bf62c031ecd",
+  "tests/output/screening/B1/force_hist.csv": "854bfebe63fb2d140823fc5dbc434a70c317c6ab0bedbd5220cec45665b524c8",
+  "tests/output/screening/B1/summary.json": "35b4d958bc0fdd6ab6c9c0d1ed50e85d89b04f7be3e34632d6c3ea95b89acb47",
+  "tests/output/screening/custom/force_hist.csv": "06da0f67b564d5c114332ef3b39167b1ba222fc50045f95303c75c14755b51d5",
+  "tests/output/screening/custom/summary.json": "1701ed75e5e9ca16127f495ccff1d87de245d81df581e94114c8fca6fbbe77fd",
+  "tests/output/screening/MR1/force_hist.csv": "f70fbfa748fd0709e225523aaaa72b761db56df4f1d48f105384b94cbc44b31f",
+  "tests/output/screening/MR1/summary.json": "3d9a0fc19710820e3634ab2143b913b282beb159336567ab9ebf3de2092947bd",
+  "tests/output/screening/MR2/force_hist.csv": "c947b3c16b8e8f8f85a203cea8cd912bdfc07f96985c1c24a470b644170195ea",
+  "tests/output/screening/MR2/summary.json": "d2344e9e2517ec76c8b56bfbe3763dd465e24721856992401c57c414763481bb",
+  "tests/output/screening/MR3/force_hist.csv": "7df1536c83ee466b7195d9c521d3d3b1309acaf142f2855bba51fb279c7612e4",
+  "tests/output/screening/MR3/summary.json": "ad188eb1b271a6cd0fb4025b456eccac5450776f60db58466f804fc5a0e0ec61",
+  "tests/postproc/run_exp_ctrl_matrix_vorticity.py": "b7e0c4113111b9b677f321750c0055656ccfa4f45c25fe7846f3ed22f30d1467",
+  "tests/postproc/vorticity_triangle_clean.png": "f831b8143b50f038d5920a0658469622655f34176d30cf7216feff108aa2ecaf",
+  "tests/postproc/run_kan99b_streakline.py": "a2bbf3fc629ea170d2d4879317dbf2b81c43378a328100ac1f2ee8d9895666cb",
+  "tests/postproc/streakline_triangle_clean.png": "aa6669de7af6f82e98af25698a15f494e9cea20cb911ad9a30fe52597d33bb79",
+  "tests/postproc/experiment.ipynb": "c6b45db1c57200f0777213ef8d44cb4996c1aa7a5fb42b968b77e56f51b4fca4",
+  "tests/postproc/run_stealth_steady_sweep.py": "3c32c4dede7da77fd6cfbd3f7b1ff43bb11390aaba621883ec96c6c7fdad5af7",
+  "tests/postproc/run_exp_ctrl_matrix_streakline.py": "529d5f31a3862080f890c65177502b589710b2d960ddf131abaf7dc2f9e2a96f",
+  "tests/screening/run_config_sweep.py": "5030c99923815ed6ad39110cb56f748c579ff4c66c7c1a368ad1a6008017e2ff",
+  "examples/fixed_periodic_patch.py": "6732e440a47c237ea341703f2d80717903d34c68fd061bdc97189e5d877be46c",
+  "examples/fixed_patch_jet.py": "9d58ac3f32478603e8e798efcdaf6ea16e9cc92346eb4780a60e438d331abced",
+  "research/j3-lag-2026-10-12/host-check.log": "b2b6d262934b3abf9e0f0bdbde14b339cb977f7bffe391c17b51b5d067862dda",
+  "research/j3-lag-2026-10-12/REVIEW.md": "f388b64b0cc0413dc9865afda90ed24de666dda0d6cdb821b4363ce1b73631b3",
+  "research/j3-lag-2026-10-12/trajectory.h5": "2b51f8ec5e0cc8ca72c73ac1b51dd611158368e6d6de791d85150fa111ea1986",
+  "research/j3-lag-2026-10-12/baseline-status.txt": "e0b69879084f54afac1a3bc3701f1de9819068190c815ae84421f02f83cad9f7",
+  "research/j3-lag-2026-10-12/baseline.json": "5e9a920813fe3d775110af85af92970d5245a7040ace804445e432353b77e489",
+  "research/j3-lag-2026-10-12/gpu-diagnostic.log": "97956b517072b7c34e2e29e2a23f87eafb19b9eda786a4b8149e4a2eaed76ee9",
+  "research/j3-lag-2026-10-12/gpu-availability.log": "b227a519b8286849cfdf842573bd451803da048c6b27af9517f6b8964cd3aa39",
+  "research/j3-lag-2026-10-12/results.json": "00435ac7e402943e55e702fac1beb5af8cafe71967999658bcde2b29077b1fa8",
+  "research/j3-lag-2026-10-12/incremental.diff": "ebdf66c72daf17b926482f79a1a30bf0eb2d27fc930a7bb62e5449ebcf72fcc7",
+  "research/j3-lag-2026-10-12/end-21280.h5": "19a94e9e8db6dd9ac981effe06032c351992250b58768d9c090409193893d588",
+  "research/j3-lag-2026-10-12/start-20760.h5": "6c4cba5928c77566c2afc32231311a3986831c18fea766faadebb101243399e2",
+  "research/fine_surface_20261014/cpu_surface_projection_command.txt": "b1783e26e92737106a5614fff01452c8ea0364372d9bdbc44c7d15c19d9b13f5",
+  "research/fine_surface_20261014/cpu_surface_projection_exit.txt": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa",
+  "research/fine_surface_20261014/report.txt": "ad8af2be7239f8fe728ac7a8db340d4458e6ec1bbb30b14e614c1072dd9804ec",
+  "research/fine_surface_20261014/cpu_existing_runs.json": "523b3179b976c2198112c7b49c6c8a75cf7d3332663a8b8a0646c94a39abd1b4",
+  "research/fine_surface_20261014/gpu_run.json": "8c4b4d7c53e17c30ce4c7d2fb92466e0704f39966e89016dbf82d36cf96e35bf",
+  "research/fine_surface_20261014/gpu_stdout.txt": "02d1f6fea194d1185a49b7bcdde58642f1d6b9634fe55e4bcda2f020414eb35d",
+  "research/fine_surface_20261014/cpu_device_guard_cmd.txt": "43a0fb0e20c4adcf1930f145796378294558060d5fd5303402e0538674b68c0a",
+  "research/fine_surface_20261014/cpu_surface_command.txt": "2b8f2a3c9ddfd1e877efa2a50a935eeb937e2b3ea92515610cd334d80703d6ce",
+  "research/fine_surface_20261014/baseline.json": "dc9dfa88e69d2b7cf93b0c572961c0bc7849ea1608a0b14b1a6dca1429abf87c",
+  "research/fine_surface_20261014/cpu_lifecycle_stdout.txt": "af52542989b4a2bf597e020c12064e7083e136f15b938ed5382b616a16f70e38",
+  "research/fine_surface_20261014/cpu_surface_projection_stdout.txt": "96ea3e4ca948962b6eb92aaf215efb6c598a3c4b296f6fd26094df353ded5722",
+  "research/fine_surface_20261014/cpu_lifecycle_run.json": "2a3b09ad2f9c86e43892d643a510c9e936d6153e2ae1f6a9eab90c3067f0473d",
+  "research/fine_surface_20261014/cpu_shared_kernel_stdout.txt": "1ab9905d8b0f34f6d791ff7da4efa2de0f7f3e282a078758cc0496cc0230c0f0",
+  "research/fine_surface_20261014/manifest.json": "19747021257f2bc5fa012763521a1733c7303a07f319f013253ca2b9ebb3ad35",
+  "research/fine_surface_20261014/cpu_device_guard_stdout.txt": "f4c61c0ac8f55c6c9a2d6c593731bf5f8c4a6c5bebbe514284fd4f899818f9e0",
+  "research/fine_surface_20261014/gpu_test_run1.py": "3dd0658f63a4e7a1c41eecf433842c872f8fecb391ea4b44d0b48947643d5189",
+  "research/fine_surface_20261014/gpu_preparation_run1.py": "b3fe9e58118369adb1bdfc618fbfbd917d508a563beaf2555f656b59aeff4425",
+  "research/fine_surface_20261014/cpu_surface_exit.txt": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa",
+  "research/fine_surface_20261014/cpu_surface_stdout.txt": "bdb786f2d289eaeab4e53d0fdccb998525c217efaa778496cf7a97ccca9e1597",
+  "research/fine_surface_20261014/cpu_preallocation_run.json": "363106050ba00d9a1c5c948c36926e8510ed7fdd75d28cfeca59f593fd0f1c50",
+  "research/fine_surface_20261014/cpu_final_stdout.txt": "bdb786f2d289eaeab4e53d0fdccb998525c217efaa778496cf7a97ccca9e1597",
+  "research/fine_surface_20261014/cpu_maps_stdout.txt": "7886fd4e2fa8a63e9cecf02bdf650e5447ba149704ac75f51da6964d8e77ba6b",
+  "research/fine_surface_20261014/cpu_device_guard_exit.txt": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa",
+  "research/fine_surface_20261014/cpu_preallocation_stdout.txt": "59907462a8d5fd93406cdf4c7d1eb2f7b7a96664ae85c4ec202693d419cd019e",
+  "research/fine_surface_20261014/incremental.diff": "9cf8b5cc4ea037c865762ba7069f0c1daabcb4383d4333167d279f8b7704e5b0",
+  "research/fine_surface_20261014/cpu_final_run.json": "020a9ef12904c2d18185613d68a58dd7ff9b1b22197ac1f95bba61f2f593eaac",
+  "research/refinement_slot_20261013/incremental.patch": "2daca4c9751190df27e18ea79e46685a8fe3cbb6d42b34135b1219b8f53ea3fc",
+  "research/refinement_slot_20261013/baseline.json": "17b1a8cb7e8232979cd1fc9976cb6b78aa58a7005449526ec15cc0bfd45f8139",
+  "research/refinement_slot_20261013/manifest.json": "9f28f275533e8a1a761ec748152170b40845612058236ce331c47ae6c5d68713",
+  "research/refinement_slot_20261013/before.json": "482b02da26207ce32deb9368b6eb63f9de7b4ab670078c02f458f512fb182b53",
+  "research/refinement_slot_20261013/notes.txt": "8c70efe2acef9f179c453d297b27047b7632a2d55e0739fff4bccf74e0867511",
+  "research/refinement_slot_20261013/stdout.txt": "1cabbc8a87a2a237ffa649feac0b1b8e0ae8d769af8c298e600e249d2a525f58",
+  "research/refinement_slot_20261013/results.json": "6245de38106d7a7b0bfea0aa5100b9c9e393ab5436fc594ce0295b4526964b8f",
+  "research/refinement_slot_20261013/cpu_results.json": "2a891c1adcb3b25390ee7967e5171396aedb9cb4da5ae85f7444450d758671d5",
+  "research/refinement_slot_followup_20261013/planar_velocity.sha256": "326639a3e66b2b8dbd21ecd76b32a331f3194a82d1b5888219eee4a1782f6366",
+  "research/refinement_slot_followup_20261013/incremental.patch": "b734b4b540ece11a037a0f119a9846c39c09c8247d3cc89877880a27c3d082c4",
+  "research/refinement_slot_followup_20261013/planar_velocity.cuh": "0b2f9e0bd483c199637e5672dc0ffc460bc383dd1804805befbeb4c5d8c708d1",
+  "research/refinement_slot_followup_20261013/baseline.json": "7ee505b7371a5258db7cb197c999be8859d14641915e3085f1969deb465880a4",
+  "research/refinement_slot_followup_20261013/manifest.json": "b11c1fb42abccc4b5638b974d1ea00b0687d8fad72b492eab3c8435bf485fd13",
+  "research/refinement_slot_followup_20261013/before.json": "809c4a6f330d4a29e92415fd0eb820f34dec38484e3560a8b9287b09553c2d87",
+  "research/refinement_slot_followup_20261013/notes.txt": "c04644a287aa936c9c6de0ca9d8bd83cee2d80aab9544ca284c9f7c029bfeff9",
+  "research/refinement_slot_followup_20261013/stdout.txt": "acb72f2b14e1abfe750330d84a38afe9bbe944bf028dde9700a291d5edff4be4",
+  "research/refinement_slot_followup_20261013/results.json": "dc38c3f5f88fac2ebf49be11df84e9f3da9d25504d400b6a506240a91735e4e1",
+  "research/refinement_prepare_20261013/incremental.patch": "df01345b8e2c33ebf6cdcbbb5104f02c4d7c239a6e6cafab1833228791bfa9a7",
+  "research/refinement_prepare_20261013/baseline.json": "5cc3c35faac9bb43a0017d83ddfca330d7da93f1e6407391da56b2e9df3b28b6",
+  "research/refinement_prepare_20261013/manifest.json": "5d479557cd01d61d8b652a3cf456fa57665bf624ce3b4a42c747523b74dec548",
+  "research/refinement_prepare_20261013/README.txt": "eee46f01add6ed7a5da76da76c98da628e13b930cfc49785399d7afbedbfd95f",
+  "research/refinement_prepare_20261013/validation.json": "945f4c3604ae0eae91c29741a39588207cfff3e05646e03a12d074a299956c2f",
+  "research/refinement_prepare_20261013/validation.txt": "5b5a8e9d455d37064c6709dcfd14e89ba66f51f09a11a9863b5cab67ac651d42",
+  "research/refinement_followup_20261013/gpu_rectangle_before.json": "aeab9314117b7eaa0950566094d20ecb5a304cc55b85887b6281694d3a6b8660",
+  "research/refinement_followup_20261013/gpu_before.json": "236cc69740cb40640cf4cd96cd94ff80644c2cf07c471b276092303edd3003e1",
+  "research/refinement_followup_20261013/gpu_rectangle_before_no_launch_1791886104981638567.json": "831b08511b78e8e631a17a638212b1c511e6f3fdb86019d7a77cc0f44d4015d2",
+  "research/refinement_followup_20261013/gpu_stdout.txt": "3147d3ab0b58ac9aa67c495491979ebb455db0fc2e89e7004facbd8c55c67b4e",
+  "research/refinement_followup_20261013/cpu_results_attempt1.json": "a91976e3ff92f7fe458a4432dae31d6b751bee92450d9a07e1dd5ee1cf5e915a",
+  "research/refinement_followup_20261013/incremental.patch": "b638544a02cbf7dd7acfcad545fcac50dc9640e193a9672f27916275c134253f",
+  "research/refinement_followup_20261013/baseline.json": "77694a29bbea2e61eb69eb5fe37eca7a8d5e82114bd59c7ff23e89d3db53a019",
+  "research/refinement_followup_20261013/gpu_seed1_before.json": "4dc6de02770a8e985f62d902ab9067cf5910084e4506ece059979640adb5575f",
+  "research/refinement_followup_20261013/gpu_seed1_stdout.txt": "8453a1b7221085691b39439428e39aaf52215abbbe9b1f84fc54c4a695260a9e",
+  "research/refinement_followup_20261013/cleanup.json": "ce1fb34fcbf2fadf7786234a8dd5dd9d0e520d9353a08b5df4c6777a35beed88",
+  "research/refinement_followup_20261013/manifest.json": "5f4c3b56a9ff8dfb422c37e0777af90536e94585ae7573caa05410e3cea294f5",
+  "research/refinement_followup_20261013/README.txt": "c553e889c6d66bb81d17d2691150cadf6fecdaa336de941281e7c85a6ff1eb12",
+  "research/refinement_followup_20261013/cpu_stdout.txt": "f9bcee3a2b43599e99c2e3b3a250aa4d4f4db1a73d1bf7cf1db0ab1fa585c54b",
+  "research/refinement_followup_20261013/gpu_before_no_launch.json": "396664d587d2e7791e972def03c7199845f7a162ab4626733fae1e54e1262da5",
+  "research/refinement_followup_20261013/gpu_rectangle_results.json": "9a06af9ec07de80d049889f321b7ea5f03036f4e461af2a43cdfb76d02ee1d6a",
+  "research/refinement_followup_20261013/gpu_rectangle_stdout.txt": "fea29f48685d84966b51d41b33e59bc01bef7d9dbc5e75b3d7c316de761f5bd5",
+  "research/refinement_followup_20261013/gpu_seed1_results.json": "ac54f5071b6e6095437078d4f8ed1cbc851a4b727ce6336281c1f27472f3dbe4",
+  "research/refinement_followup_20261013/run_gpu.py": "16b1520adbfee1651539f04dd694f5f02e9dc8ae4f4fc55d374a0ac06b50b4b8",
+  "research/refinement_followup_20261013/cpu_results.json": "a1a57b35c0839a82a7b653a062e852edf693d2c318da77dc1cb79373661bc780",
+  "research/refinement_followup_20261013/gpu_results.json": "be369bb072139b3fbfac4cbb3ab5eade7d2fb1ab67549ae2e4e0d0f48f640dfc",
+  "research/refinement_followup_20261013/cpu_stdout_attempt1.txt": "6ac5f889a9f6b6ecfa8abb74e98b07deaadc71c7f5488112eca26e4ed255e7ba",
+  "research/refinement_step_20261013/gpu_failure_validation.txt": "d6ec00e0e8c69015565135a67fac6de47701e9eebc3cbacc379abf8166ac61be",
+  "research/refinement_step_20261013/cpu_validation.json": "cf7200fc4b763f5a2133d8affeea306578a247179bb82ce2f5ae0d8e244c576b",
+  "research/refinement_step_20261013/incremental.patch": "c3d2d813b64f8a2305f54153508d71b546d86af7be1005cff96e0ef8c91297bb",
+  "research/refinement_step_20261013/baseline.json": "68bd37982acb433bea235a94f211c907be483e905742f98166235929f79ba95d",
+  "research/refinement_step_20261013/manifest.json": "a60a40ffa9073a8047f3b9f5af3c1256179603641083c3a20dda6cfa6e050146",
+  "research/refinement_step_20261013/README.txt": "922d6fc6c742203f69e174a12cac6b19e8ae15be74257134c08d72990b16d517",
+  "research/refinement_step_20261013/gpu_validation.json": "2f0218854a2a307dd15a891a781fa3c2b7e865c201630a36ca180134b1ee6436",
+  "research/refinement_step_20261013/gpu_validation.txt": "1714ee85e6235528bf29dac85bca1298a673bdb9bf0c9c364961bf364a83f0d2",
+  "research/refinement_step_20261013/gpu_failure_validation.json": "5e7d58863659af3c29f10aac11ff43516fedd39a30a40e5ead62732ba80fcbd3",
+  "research/repair-2026-10-10/simplification-checks.log": "c9f15e870d02003480adf1a7f2fe4a9aca66c1934c4477619f05c8a4798ba85b",
+  "research/repair-2026-10-10/repair-state.md": "4d4aa1ec0c11a87d2c8380912e7ed74cf5c910ae42e5cc529effde36c9020969",
+  "research/repair-2026-10-10/TRON_HANDOFF.md": "f8aaa3d99cd133c2055d4adf396a0a57d14f6006aea19e87611bd1c2c1b53a88",
+  "research/repair-2026-10-10/final-gpu.log": "988bb97256d17b88c14f3793b15880d727ecb285abe62e7d2ae27a16729651c3",
+  "research/repair-2026-10-10/baseline-status.txt": "074088d793014e3b8154c58718058c7d300fb45595f5129fa957ef1e4cec38e2",
+  "research/repair-2026-10-10/repair-architecture.md": "49be42ff5c994017f3175e17efda14d84f0b68f8ecd239f66ccee38415b60c5a",
+  "research/repair-2026-10-10/classic-results.json": "a5d15305f516fd378b54cf9029102be58a83a55a7bad4b8e058fcfe0cc9898f4",
+  "research/repair-2026-10-10/checkpoint-domain-2026-10-12.diff": "292b4bafe7a62d4fbbf7c165eb99929336edfcaa16b15f34f72ab71fcd928391",
+  "research/repair-2026-10-10/repair-numerical.md": "0272ebfa8c519aad161c520542cf53156574661609b91fd5ccad7955fdf2bd7b",
+  "research/repair-2026-10-10/provenance.json": "a81b7e32ecf7182c9617df1b39bbb063a05ef89290ad501bac4573cd5e8a6832",
+  "research/repair-2026-10-10/classic-signals.npz": "820c9a0b0713d7455f0a5839ac2cd5ee706086d1a26461225dcdb095673421e2",
+  "research/repair-2026-10-10/baseline-hashes.json": "d6a7d5f9ec5bceb0e7927d55603d9c5e70105982cd945723454659b19ab476e6",
+  "research/repair-2026-10-10/final-unit.log": "a892a39ecf88125558538cadce2cb5dc46d106b993b164e03da4ebb0eee68cef",
+  "research/repair-2026-10-10/original-user-files/tests/postproc/experiment.ipynb": "c6b45db1c57200f0777213ef8d44cb4996c1aa7a5fb42b968b77e56f51b4fca4",
+  "research/repair-2026-10-10/original-user-files/src/CelerisLab/lbm/kernels/config/config_physics.h": "26df33c2960ba36f3283e19b55b4ea92e50e4efda705f9ebfbf3f875a4092c59",
+  "research/repair-2026-10-10/original-user-files/src/CelerisLab/lbm/kernels/config/config_method.h": "3db4e16ef2c6b22349d04e6aa8ab04bdfe0eb784f9f3a98277e15dbed1835d81",
+  "research/repair-2026-10-10/original-user-files/src/CelerisLab/lbm/kernels/config/config_grid.h": "8be3a7cf74ba30d7fd3074fed79e63dbda7311c4d03b454ea641bf298ffeaa8d",
+  "research/repair-2026-10-10/original-user-files/src/CelerisLab/lbm/kernels/config/config_objects.h": "dbb93c063586da278c15d95e23f84c12e728f4f5f1bbc3980fe9cedaa6fff90e",
+  "research/surface_actuation_20261014/report.txt": "128dd731124542be4ba50fe18d24ceb0a5b37f0329bcf32cdda4de3f1514b0c7",
+  "research/surface_actuation_20261014/gpu_run.json": "e06268a9acdb3c6ced30e58d684c427aeaaa427b7098da55e60f9a4854a8aa58",
+  "research/surface_actuation_20261014/gpu_stdout.txt": "bc882fe06353f12ab2b85bc5c9b7e6a23adf705d9e2ab6a529ca8afa49a5166a",
+  "research/surface_actuation_20261014/cpu_surface_command.txt": "7204f2326b37ce0b4bf05e806935974fb91246922f7e3760dbab0627d94f07ef",
+  "research/surface_actuation_20261014/baseline.json": "4456d6718db2ad3335c372368e3e1a0a384d78319855a0a9d4cdfca02f28a4c7",
+  "research/surface_actuation_20261014/cpu_initial.txt": "2c19cce736bac1da5ccacf06b0c71b0e1affcd385e1346d2ab9a0cab5567842a",
+  "research/surface_actuation_20261014/manifest.json": "9a4e768bd10e8609cd722af8f3904aed27df7debaf2389aa20692c67fe05050f",
+  "research/surface_actuation_20261014/cpu_surface_exit.txt": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa",
+  "research/surface_actuation_20261014/cpu_surface_stdout.txt": "8e47fbdb3f81736adfbb0df2621df4953cf20f2e49cf63a9518b32e6a524fc20",
+  "research/surface_actuation_20261014/incremental.diff": "9511a0f105edd655f08fbbb22b0330729ee6b610b15febfa38403c4ec506c88b",
+  "research/surface_actuation_20261014/cpu_checkpoint_stdout.txt": "d740f1038fb46c8c49a0677d9b0d3677ef461bc14cf58f92eb8bd9ad3b1c97f9",
+  "research/surface_actuation_20261014/cpu_checkpoint_run.json": "8970cd51e65172d47ed3dd16fd118923708dbb2309b213fb819a4c9e3f2e67d0",
+  "research/j1-2026-10-12/REVIEW.md": "13004a4f140acdcf59acb57e9e2dda1bb95763d30060f822a7c206c94b813a9f",
+  "research/j1-2026-10-12/gpu.log": "8659a78ea52bbf8eb923d46ea71636ce63cd322352d5c98a74f631e666dd8cfb",
+  "research/j1-2026-10-12/baseline-status.txt": "ac398360e05b746b89ae0c3acfe202b5122e650a3bb1ff234ab26f874a303e64",
+  "research/j1-2026-10-12/baseline.json": "ad7afdf7b3913d11c07343e971fe2f43c2d1a2b99e3d5904a6ba89e3bb0b24fb",
+  "research/j1-2026-10-12/checkpoint-gpu.log": "adfe3d77d2e6c6f6184dccc0267b4404b20a7709505d5ff5affed0ed4a618083",
+  "research/j1-2026-10-12/cpu.log": "60cac097f7c4f11401df2aacb43a248640555e7628d2829c4680c71db34e9640",
+  "research/j1-2026-10-12/gpu-validation.log": "d1e9f2aea17a85eddcd94b81c700738ce073214857b55c28abd1219ff1edbed7",
+  "research/j1-2026-10-12/results.json": "449f8a17dacac0fc6d2489c4b10bac330dbbbdb38fad3ce54f739ac8c6d48e85",
+  "research/j1-2026-10-12/incremental.diff": "a454c23da7b0011645949c0fbf64d0c41ecfdab5642b1b7c5119868005d3c721",
+  "research/j3-coverage-2026-10-12/restart-21280.h5": "3e89c12c16f91f76ca9acd909e0fa7d42df6fbb5e870b299aa08ca42bc3e3dc9",
+  "research/j3-coverage-2026-10-12/REVIEW.md": "7293f3f3442855c8521698605aab504e026915a7bf1e77f5a24710d89a812443",
+  "research/j3-coverage-2026-10-12/restart-reference-21296.h5": "7192f510dd7820675aa1de130f55514136fba782cf77f92545189918a7e0c328",
+  "research/j3-coverage-2026-10-12/negative-end-20760.h5": "bd0bd063579d625e358762b1fdde5ac11bfcf739646a847fb77a4a2031011b9b",
+  "research/j3-coverage-2026-10-12/baseline-status.txt": "31c949b11b20d7cd4202dba16882b5712aa1653da0cb2da2f0ebd69bf488040e",
+  "research/j3-coverage-2026-10-12/baseline.json": "d8844104f2665a25bfc417ee29becf89ab3955fac9105b5ddb12cfb1fe2a55b0",
+  "research/j3-coverage-2026-10-12/verification.json": "205986efd2b41635721b7fd20288be982348c765180102c7102750ba088f3a28",
+  "research/j3-coverage-2026-10-12/negative-budget-20744.h5": "c09d75fc4a2cff68039a0956bd9d32b79b9cd3a6b386c72b4db54c214b110cd8",
+  "research/j3-coverage-2026-10-12/gpu-validation.log": "505cd5a5db46d7984aefb2a614151c25c4ace0e7d2a52e02c3e4f9792fd8eb95",
+  "research/j3-coverage-2026-10-12/results.json": "02460981ad49c9cc13b4246abad1d8afd2599c61bfb545a6e32da9bbcd5c0db1",
+  "research/j3-coverage-2026-10-12/incremental.diff": "98aa7855d5d6b91b4509a924c8a5aabab4339ba29c7e7dc2d91262c48e3848ca",
+  "research/fixed_patch_jet_20261013/incremental.patch": "dd95a98f03b7ce06d024a1d1d1f454dd206ad10a573a8060f728bad71941d6e8",
+  "research/fixed_patch_jet_20261013/baseline.json": "d2a83d490ca545589a7a7fc0e3fd187f4801e22e5c8d2d18ddb519097d3281b9",
+  "research/fixed_patch_jet_20261013/manifest.json": "3efaf5af8d6a4f6c3460d8023466af611ff90bc9fc79c3e7db6f591d172d1182",
+  "research/fixed_patch_jet_20261013/before.json": "dd47f1e25a807a3eafef7d12429f034117f945a4ebfeb98eb1688d1752c3d30d",
+  "research/fixed_patch_jet_20261013/notes.txt": "155be36e201c9c8a043a87fc7a7d0064b703990b2aad86853767603fe38a256d",
+  "research/fixed_patch_jet_20261013/stdout.txt": "925abb3038095560d71a4e7733b38d93672397640cc88197c733a8a39e2f9f51",
+  "research/fixed_patch_jet_20261013/results.json": "fcd944b8dec61b399874b5386d6e00880f0dbc34d248ad371a6af8781fddaa93",
+  "research/fixed_patch_jet_20261013/fixed_patch_jet.py": "f27cd067fd7b9a7c6d7fab19fa471fe0617ee67889ae3931048557cc5659181b",
+  "research/fixed_patch_jet_20261013/output/summary.json": "a9a4ab5975684a386f05746f570ec4d7b1c5ee3be413400445122448f534eca3",
+  "research/fixed_patch_jet_20261013/output/velocity.png": "0f8ffc3a7b36ffefa5c0cd8550309fe89d9de72cd5476f354a27fac89cb39b0a",
+  "research/fixed_patch_jet_20261013/output/layout.png": "cfc354c0192a5a9727a8056ff6c5bc4571f916143853e4da2dc16da965e10173",
+  "research/audit-2026-10-09/numerical_semantics_results.json": "b95b065b594aa2911740dab216f87936c9bf7f7fa25acfda93b5738443564035",
+  "research/audit-2026-10-09/REVIEW.zh-CN.md": "2841fd3aa7a6baedbe1079d90915c8b05212b133824ed6abccaa1f09656eaefe",
+  "research/audit-2026-10-09/root-initializers-report.md": "ca448457c444949d5d0e1e10fa7121064510b77fc4c3512580900f0299219867",
+  "research/audit-2026-10-09/numerical-report.md": "970330b3a593f79f09866ce6ae82bc0ddd81226230d0a6ff06ae8ae756ee80da"
+}

research/fine_surface_joint_20261014/baseline_03.json

@@ -0,0 +1,72 @@
+{
+  "research/audit-2026-10-09/numerical_collision_results.json": "51e5c263bb8cde82cedef2ccfdbf5ef657742a80218d7896b1ff877516e59693",
+  "research/audit-2026-10-09/architecture-cpu-results.json": "e1b809210005c8765b13fddbb5ed710d15f6fcbb4c5788a4064f3e88808433ef",
+  "research/audit-2026-10-09/numerical_compile_results.json": "c3b0ae02072a2ec408ada7513b542ec255f6855cb743a3ed7f91bd8f31504f44",
+  "research/audit-2026-10-09/state_results.json": "da9170df3e11231c73f20e5e79ed68e08966673d1dd52004ea6b6a279afc0dcd",
+  "research/audit-2026-10-09/architecture-report.md": "861079dc3f4ced9fdc41bfb22002d32e190c0d630d3ba2f138f9dc7a949b8371",
+  "research/audit-2026-10-09/state-report.md": "f8708807efc2e109810c5955f7c1884a932668c0b3cb2963c2df3b09f2a3d5c4",
+  "research/fixed_patch_jet_closure_20261013/incremental.patch": "18b30ecc0703bcb4cb6577255d12a5b0d95dfea99d02d761bbc1b5b231bba1d3",
+  "research/fixed_patch_jet_closure_20261013/baseline.json": "ccf88409836657aebbf091f06c41141c81d20169c2cac0fd8e2a16b40df36882",
+  "research/fixed_patch_jet_closure_20261013/manifest.json": "7a2a079be7b6146b3bc2f5494f98ca2f935805ca4c6aa1eb1b9067fdeb3ae3c5",
+  "research/fixed_patch_jet_closure_20261013/notes.txt": "bc3c939659ef0cbda506024d79b896707f4dc4af94bb088924e139f81a9e885f",
+  "research/fixed_patch_jet_closure_20261013/cpu_stdout.txt": "4e1f371a568eb1c2a7912cb5ea564c8c23f0106dbc41a68f179bbcafdff2cdff",
+  "research/fixed_patch_jet_closure_20261013/layout_uncropped.png": "0ef6709c02ed5beba5707e033d9f6f9795a9bbfe3d7fc23341fa7dab6e85288c",
+  "research/fixed_patch_jet_closure_20261013/cpu_results.json": "6bae91721db9051f18bbf89dacca40b80410f84f037e7732cb1af4eadc24aaf8",
+  "research/j3-offline-2026-10-12/REVIEW.md": "d9902c58498e73c29e054b23adb968f7e1e14421cba5c58d03bbc5a50159ae79",
+  "research/j3-offline-2026-10-12/lags.csv": "fbd9addd413f24c47f4411317e872265bb774e8e1724fe169412befa860ae94d",
+  "research/j3-offline-2026-10-12/localization.png": "a72907638e32b0ecfc2205bea438e7b408f40aad86217ce6ad9b4877840c9cfc",
+  "research/j3-offline-2026-10-12/results.json": "cdb857bea6f4e06ed15acf773505ce6d5147f8cb8ce0a53cc368ee267cde6361",
+  "research/j3-offline-2026-10-12/cpu-analysis.log": "bc02a9b197fc15ae1b503ca54655a7622d4361f9b45b7848ff9c387ea3665f11",
+  "research/j3-offline-2026-10-12/regions.csv": "3a8fc640b61d70e3b7f73d2bf8ac2bd3f720adf39a90dfda6180430e0489efae",
+  "research/fixed_patch_jet_records_20261013/incremental.patch": "63485fb4eee8e2e89b683961aee32a6ca00ef5e607a362efb3290f3a08809222",
+  "research/fixed_patch_jet_records_20261013/baseline.json": "d73ddb2a6629f03655aa05fae08bb4bbc9474c686af56dbe29c99d6491b7508e",
+  "research/fixed_patch_jet_records_20261013/manifest.json": "97a2fbf139985a19cb6c0e0818646571fa1bcfb23e36424998a64777db641592",
+  "research/fixed_patch_jet_records_20261013/before.json": "68ec7ef820d5f826b6e24c6afdef71c76bd22400393815321ac3a1905c437796",
+  "research/fixed_patch_jet_records_20261013/notes.txt": "6d55a6395833fa02883357752ab3d8ea43df516fbcb40e4006fb1756757b1e99",
+  "research/fixed_patch_jet_records_20261013/stdout.txt": "6e579eff0c1762ba31d8b1cee709e0cdba2e3f408432b71fe374b2d9f450665c",
+  "research/fixed_patch_jet_records_20261013/results.json": "7997ee1626ad0640a9d362499c8e0eeefe9d71913fef5f2280112d5bdc9b50d4",
+  "research/fixed_patch_jet_records_20261013/fixed_patch_jet.py": "7d6370fe6d8b723b1b3e1492e89fcc72562383c0dc030c25a254ac3fc899845a",
+  "research/fixed_patch_jet_records_20261013/output/summary.json": "a448c2e66a56ee48071315d6f73d0ec1afccc29d680ab3a40d51d1df62dd973a",
+  "research/fixed_patch_jet_records_20261013/output/velocity.png": "7c67c5f64a4bec94547c0ac7833e6d47eeaae9696904c1465a9d5d969008b79d",
+  "research/fixed_patch_jet_records_20261013/output/layout.png": "678ba19a51c112960ace2a4b8d9d94e43287d97c3a6ef892684630ab37b70255",
+  "research/j2-slot-2026-10-12/REVIEW.md": "10c4a94ffc32e0a2c4e0f6593b7cfc28479b5869f279f0b9d0b708fa3a47d1e6",
+  "research/j2-slot-2026-10-12/gpu-serialization-failure.log": "df804e53b35e7ddaad79a17842b4b5fd9d834e29ca2d56edb00e835848d09200",
+  "research/j2-slot-2026-10-12/baseline-status.txt": "812616e2d941efcf854e1b37d6e662dda1aaf2b69074fcc04017133e13b72166",
+  "research/j2-slot-2026-10-12/baseline.json": "e82a1844145fd0cbc585c581b29f80b56193f122cfe1dfa7578f26904a720285",
+  "research/j2-slot-2026-10-12/cli.log": "9482ad7101d501f27f92e204b2f3ae5c6d91bd887b525aa31cb4a2a188f3cb92",
+  "research/j2-slot-2026-10-12/cpu.log": "91aba5961006909fbbb860429a9d3cfc930112a0d74c7788bc51c0a5897b47e5",
+  "research/j2-slot-2026-10-12/gpu-validation.log": "223351b52c70fa4523289f3a1b3db435a11286379253280470900ffe397580a6",
+  "research/j2-slot-2026-10-12/results.json": "7d35ca7989aed5380e0a45de7f583972566fc516a051da63c53b35514e267494",
+  "research/j2-slot-2026-10-12/incremental.diff": "c9e391bc91438cd912c1ed5a419705d4388522f672c67a066cfc055e814e699f",
+  "research/design-2026-10-09/math-and-history.md": "64f8c82e4949d6f58b46faa09800958714859c36cad20bbeeae8b449ae7a6099",
+  "research/design-2026-10-09/math-checks.json": "94750381954317cde8d649db26beaed8ea945666572a05030ca2b4d97d384011",
+  "research/design-2026-10-09/Contracts.lean": "2442d9a778ef20e8af3fecf23be6fea6d73c6299ff744c9664b652bc5ee3f034",
+  "research/design-2026-10-09/jet-study.md": "a362142ef04a5ad5dbb4c9db9d221b1199dccec53780c8f2da49a15201cfe529",
+  "research/design-2026-10-09/PLAN.zh-CN.md": "0341dd7ee306a040340c8e5dedb07a109e931c27dbf3c994d072aa78e3b6bc67",
+  "research/design-2026-10-09/jet_closure_results.json": "12cf7d400a206f9f9ec9ea6ad251fe6bb0232e27bcbed22fbc1ead2c0fc7d249",
+  "research/design-2026-10-09/grid-study.md": "4435dc1275ec5e15b118becc6ac391f306195d1e5beaa58037b1aff3bb2465c7",
+  "research/design-2026-10-09/jet_closure_check.py": "fde45d0f8518740ef5c0bf0fe7635d6adaf9a2e789927dd4e68e991c138ddc30",
+  "research/design-2026-10-09/api-architecture-study.md": "d6fb45ec784f0e1db55fb9f34e137b9f551db0b9b39fd4f0ef247a78fc34eedf",
+  "research/design-2026-10-09/math_checks.py": "4254983a783fe4bad8888b3d7c243c87d991c7bbf242edb0f56f25cbaefee890",
+  "research/wall_seam_pulse_20261014/analyze.py": "2b174826ffaee96c147bd247ef5e322cb51d55ce506f330bac021afd012560f7",
+  "research/wall_seam_pulse_20261014/stdout.txt": "4a555ab2412d6b6974ba42f213fa394c6b438a3762981a135cbddfeff5598ae2",
+  "research/wall_seam_pulse_20261014/run.json": "4466aafbea16f9af46d70a5da4c8ce69ea7d5fcd256181f083cc728d1c35bfe9",
+  "research/wall_seam_pulse_20261014/interpretation.txt": "9785c6814a25cddbf5e74b4cb1ba421287c920d97a502425d6739667185a24c6",
+  "research/wall_seam_pulse_20261014/results.json": "29b7588e4cc86750d63567315fd430c9de20be5419bb45f8bca4a5259f6473aa",
+  "research/wall_seam_pulse_20261014/sources.csv": "765f6e8b7545304675688295153ee6c94deacfbfb52571c831021ca03f4bb98d",
+  "research/refinement_example_20261013/incremental.patch": "6acd05df6669ccdcf234ac1680c6e76c75a2587974adb6728f7edda6fd625b69",
+  "research/refinement_example_20261013/baseline.json": "ae0af15ddb40709d1e348655a665264984a240ded1e28af816a8000d08e784be",
+  "research/refinement_example_20261013/manifest.json": "6da85ac513065dcf49200bc0872bec38b6c7ba61f7d82036c2189cabe5ac29ce",
+  "research/refinement_example_20261013/before.json": "d95cd518f080eab92af5e53e1e9b6b6fad626eae51990e510d2d2f2ae9d0ec7b",
+  "research/refinement_example_20261013/notes.txt": "f111f8cba94b43d1127945fa41615037e1740efcfc529e802338dd8c4ff02795",
+  "research/refinement_example_20261013/stdout.txt": "9c59fb315a5552cce4ceab171003e425bf64d747137c89bd86d8779a34adcbd1",
+  "research/refinement_example_20261013/results.json": "8ab13bbc022f2a66898aa07ed94f43cb6716570e7a360a809b7fcd097316db7e",
+  "research/j3-reservoir-2026-10-12/gpu-availability-sandbox.log": "1d58470512e583a0acfabf6896ee5f31e5b493b8231aed54b864f64eb275b02c",
+  "research/j3-reservoir-2026-10-12/REVIEW.md": "1ea5f860728584ea6cbe40ba3994e40471102d8e2cf6d93e28fe47222cba0cab",
+  "research/j3-reservoir-2026-10-12/baseline-status.txt": "0ef1a8c9878c4053ebc1a7d4bace6d4ec38bf27ace167b4239ddbb1c6c897e20",
+  "research/j3-reservoir-2026-10-12/baseline.json": "847fefd1eae971985d34d04d89ee6d6f1c91f6940c54fe351d112faba7bc6838",
+  "research/j3-reservoir-2026-10-12/cpu.log": "b33f6c1a1b0ee67968c4cff85d491e46e30e0d6c796b552629714ab8b5dcead0",
+  "research/j3-reservoir-2026-10-12/gpu-validation.log": "ff04024db197e332f37c912a96413e3251fd0186947348ffbc33af6f4a899f2c",
+  "research/j3-reservoir-2026-10-12/results.json": "49685de7679a14860258abf1753aaa6d116ad709b868d907ddb40e74c9b845ea",
+  "research/j3-reservoir-2026-10-12/incremental.diff": "fae312831d71e46dd477a640b06ed927853a9e735d26bf9f5868927fa31cfa56"
+}

research/fine_surface_joint_20261014/blow_boundary.csv

@@ -0,0 +1,49 @@
+step,substep,time,bfl_error,drive_mass,latest_body_impulse_x,latest_body_impulse_y,latest_body_angular_impulse,boundary_m,boundary_px,boundary_py,fine_transfer_m,fine_transfer_px,fine_transfer_py
+1,1,0.5,3.7331066016221826e-09,0.0015482567250728607,-0.0010669911280274391,-0.0009111231192946434,-1.3296011179275702e-05,0.0015482567250728607,0.0010669846087694168,0.0009111212566494942,0.0,0.0,0.0
+1,2,1.0,7.450580596923828e-09,0.00155003224242226,-0.0005924226716160774,-0.0005089053884148598,-6.828160713734377e-06,0.0018995041027665138,0.0005924198776483536,0.0005089100450277328,-3.557652235031128e-07,0.0,0.0
+2,1,1.5,9.730734440438482e-09,0.0015509553987416245,-0.0007510213181376457,-0.0006337100639939308,-6.453869729639017e-06,0.0018004681915044785,0.0007510194554924965,0.0006337091326713562,-8.530914783477783e-07,-7.450580596923828e-09,-1.6763806343078613e-07
+2,2,2.0,7.450580596923828e-09,0.0015510943465718227,-0.0007005799561738968,-0.0005853474140167236,9.16537625561542e-06,0.0019320533610880375,0.0007005711086094379,0.0005853441543877125,-1.3401731848716736e-06,2.7939677238464355e-09,-9.313225746154785e-10
+3,1,2.5,8.252825436927402e-09,0.0015511169589478664,-0.0007204441353678703,-0.0006065750494599342,-1.9204094044988906e-06,0.0019155647605657578,0.0007204404100775719,0.0006065657362341881,-1.6577541828155518e-06,1.5832483768463135e-07,1.5832483768463135e-07
+3,2,3.0,9.915552157124807e-09,0.0015509250112041078,-0.0006797974929213524,-0.0005730642005801201,2.2820092603348385e-06,0.0019676131196320057,0.0006797960959374905,0.0005730544216930866,-1.982320100069046e-06,3.1152740120887756e-07,3.096647560596466e-07
+4,1,3.5,9.13659503609665e-09,0.0015507420136590903,-0.0006570117548108101,-0.0005553392693400383,-3.1137037854733762e-06,0.00195569870993495,0.0006570047698915005,0.0005553369410336018,-3.2121315598487854e-06,3.5297125577926636e-07,3.762543201446533e-07
+4,2,4.0,7.450580596923828e-09,0.0015504969629409936,-0.0006134528666734695,-0.0005185604095458984,-2.5563305094955524e-07,0.001978149637579918,0.0006134519353508949,0.0005185585469007492,-3.698747605085373e-06,-3.585591912269592e-08,1.909211277961731e-08
+5,1,4.5,7.450580596923828e-09,0.0015502991826538432,-0.0005827639251947403,-0.0004925131797790527,-2.496779667127136e-06,0.001968016382306814,0.0005827643908560276,0.0004925071261823177,-3.6563724279403687e-06,5.550682544708252e-07,2.4121254682540894e-07
+5,2,5.0,7.450580596923828e-09,0.0015500768212474217,-0.0005441568791866302,-0.00045982934534549713,-6.621178455512577e-07,0.0019786693155765533,0.0005441587418317795,0.00045982934534549713,-3.6312267184257507e-06,5.122274160385132e-07,2.2258609533309937e-07
+6,1,5.5,7.450580596923828e-09,0.001549918623869907,-0.0005141962319612503,-0.00043411366641521454,-1.9021591811663185e-06,0.0019702534191310406,0.000514195766299963,0.00043410947546362877,-2.8940849006175995e-06,5.164183676242828e-07,3.213062882423401e-08
+6,2,6.0,7.450580596923828e-09,0.0015497499199425297,-0.0004802681505680084,-0.0004054997116327286,-7.309877421146638e-07,0.0019760499708354473,0.0004802667535841465,0.00040551135316491127,-3.33273783326149e-06,-3.0687078833580017e-07,-2.1746382117271423e-07
+7,1,6.5,6.764444948625936e-09,0.0015496176481223653,-0.0004520462825894356,-0.0003813067451119423,-1.5892076227208562e-06,0.001969610806554556,0.00045204488560557365,0.00038131000474095345,-7.304362952709198e-06,-2.8349459171295166e-06,-1.5050172805786133e-06
+7,2,7.0,8.109305865700023e-09,0.0015494958415757888,-0.00042206887155771255,-0.0003560921177268028,-7.75549964804334e-07,0.0019731801003217697,0.0004220716655254364,0.00035608746111392975,-1.9578728824853897e-05,-1.0931398719549179e-05,-6.151851266622543e-06
+8,1,7.5,7.94549828708746e-09,0.0015493981799709084,-0.00039640720933675766,-0.000333922915160656,-1.3677983846660524e-06,0.001968265976756811,0.00039641233161091805,0.0003339252434670925,-5.536805838346481e-05,-2.580694854259491e-05,-1.5653669834136963e-05
+8,2,8.0,8.57936799381065e-09,0.0015493020071895578,-0.00037000514566898346,-0.00031171925365924835,-8.318499384873945e-07,0.0019705859012901783,0.00037001678720116615,0.0003117159940302372,-0.00011411821469664574,-6.15590251982212e-05,-3.886828199028969e-05
+9,1,8.5,8.998468456478115e-09,0.0015492362139466068,-0.0003468478098511696,-0.0002919333055615425,-1.3410125925261696e-06,0.0019667870365083218,0.0003468613140285015,0.0002919272519648075,-0.00023686187341809273,-9.644916281104088e-05,-6.473483517765999e-05
+9,2,9.0,1.0769307515201554e-08,0.0015491672233875443,-0.0003237603232264519,-0.00027247238904237747,-8.826204219714029e-07,0.0019684722647070885,0.0003237677738070488,0.0002724668011069298,-0.0003811251372098923,-0.00018009915947914124,-0.00012547895312309265
+10,1,9.5,6.5991891951000525e-09,0.001549105281009374,-0.00030333735048770905,-0.00025494955480098724,-1.3582019926516864e-06,0.0019654426723718643,0.0003033336251974106,0.000254947692155838,-0.0006271977908909321,-0.00022491207346320152,-0.00016344105824828148
+10,2,10.0,6.118484829897852e-09,0.001549051989981235,-0.0002833334729075432,-0.00023819785565137863,-9.026330124450865e-07,0.001966737676411867,0.0002833292819559574,0.0002382085658609867,-0.0008610719814896584,-0.0003546644002199173,-0.00026744231581687927
+11,1,10.5,6.552038911422642e-09,0.00154901751549866,-0.0002655861899256706,-0.0002231122925877571,-1.2630542108871268e-06,0.001964384224265814,0.00026558665558695793,0.00022311368957161903,-0.0011930274777114391,-0.00039019854739308357,-0.0003034067340195179
+11,2,11.0,9.802380018797408e-09,0.0015489874147144294,-0.00024848151952028275,-0.00020880158990621567,-9.786817930512726e-07,0.0019654412753880024,0.00024848291650414467,0.00020880764350295067,-0.001470054965466261,-0.0005364310927689075,-0.0004325839690864086
+12,1,11.5,1.0565094576975298e-08,0.0015489509835935602,-0.00023323949426412582,-0.0001959698274731636,-1.174757736199794e-06,0.0019635832868516445,0.00023323623463511467,0.000195962842553854,-0.0017936332151293755,-0.0005537522956728935,-0.0004546362906694412
+12,2,12.0,1.0153207108398732e-08,0.0015489143609847475,-0.00021865405142307281,-0.00018392689526081085,-9.567065110127615e-07,0.001964456867426634,0.00021865731105208397,0.0001839236356317997,-0.00204546470195055,-0.0006773108616471291,-0.0005757706239819527
+13,1,12.5,6.847925559938517e-09,0.0015489000506591615,-0.00020564347505569458,-0.00017303228378295898,-1.229019973680856e-06,0.0019629797898232937,0.0002056504599750042,0.00017301971092820168,-0.002280890941619873,-0.00067916139960289,-0.000582011416554451
+13,2,13.0,1.1770799335231175e-08,0.0015488750333560626,-0.0001933462917804718,-0.00016286037862300873,-9.379367493789204e-07,0.0019637630321085453,0.00019335513934493065,0.00016285711899399757,-0.002459546085447073,-0.0007534711621701717,-0.0006643435917794704
+14,1,13.5,8.936060558184522e-09,0.0015488612668431816,-0.00018239393830299377,-0.00015359185636043549,-1.2376870923702654e-06,0.001962530892342329,0.000182389747351408,0.00015358394011855125,-0.002583651803433895,-0.0007450981065630913,-0.0006575053557753563
+14,2,14.0,1.2725840020655355e-08,0.0015488343418273527,-0.0001720944419503212,-0.00014511216431856155,-8.9041709272486e-07,0.001963145099580288,0.00017209816724061966,0.00014511402696371078,-0.002680632285773754,-0.0007635904476046562,-0.0006860606372356415
+15,1,14.5,9.446215296082805e-09,0.0015488229734234565,-0.0001630391925573349,-0.00013743527233600616,-1.146773010329838e-06,0.001962078735232353,0.00016304105520248413,0.00013743527233600616,-0.0027179024182260036,-0.0007485975511372089,-0.000670840498059988
+15,2,15.0,9.313422921763959e-09,0.001548801691143042,-0.00015463586896657944,-0.00013038236647844315,-9.957984490327476e-07,0.0019625588320195675,0.0001546279527246952,0.0001303856261074543,-0.002754406537860632,-0.0007191230542957783,-0.000647230539470911
+16,1,15.5,7.756034481332108e-09,0.001548795055197433,-0.00014728587120771408,-0.00012414250522851944,-1.19767199602272e-06,0.001961618661880493,0.0001472746953368187,0.00012414157390594482,-0.0027457624673843384,-0.000701194629073143,-0.0006282757967710495
+16,2,16.0,4.9820187697502405e-09,0.0015487817877766277,-0.0001406259834766388,-0.00011855922639369965,-1.0063548837591085e-06,0.001962041947990656,0.0001406143419444561,0.00011856527999043465,-0.00275089917704463,-0.0006374767981469631,-0.0005653253756463528
+17,1,16.5,7.659630707479437e-09,0.0015487774975968425,-0.0001347297802567482,-0.00011365208774805069,-1.1021201878902431e-06,0.0019611907191574574,0.00013471907004714012,0.00011365814134478569,-0.0027269930578768253,-0.0006199139170348644,-0.0005475492216646671
+17,2,17.0,8.840773640939048e-09,0.001548763244042896,-0.00012935884296894073,-0.00010930560529232025,-1.016784981322516e-06,0.0019615269266068935,0.0001293686218559742,0.00010931165888905525,-0.002721673808991909,-0.0005361568182706833,-0.00046241283416748047
+18,1,17.5,1.2304882210378842e-08,0.0015487567261606326,-0.00012471340596675873,-0.000105343759059906,-1.0469923481526422e-06,0.001960811670869589,0.0001247120089828968,0.00010533956810832024,-0.0026941243559122086,-0.0005193613469600677,-0.00044766347855329514
+18,2,18.0,7.418095471223296e-09,0.0015487429170055658,-0.00012026354670524597,-0.00010176189243793488,-9.512738775585561e-07,0.001961167436093092,0.00012026121839880943,0.00010176049545407295,-0.0026859669014811516,-0.0004291580989956856,-0.00035731401294469833
+19,1,18.5,7.707569693593541e-09,0.0015487447557849957,-0.0001163184642791748,-9.842775762081146e-05,-1.1155910571991612e-06,0.001960610970854759,0.00011632218956947327,9.842775762081146e-05,-0.0026490092277526855,-0.00040957890450954437,-0.00034233927726745605
+19,2,19.0,9.897528907565345e-09,0.001548736220618044,-0.00011231936514377594,-9.525753557682037e-05,-8.746676823934152e-07,0.0019609862938523293,0.00011232960969209671,9.52649861574173e-05,-0.0026348931714892387,-0.0003248099237680435,-0.00026043038815259933
+20,1,19.5,7.458307527130614e-09,0.0015487257938516241,-0.00010872259736061096,-9.228847920894623e-05,-1.117876357703551e-06,0.001960530411452055,0.00010872026905417442,9.2280562967062e-05,-0.0025746123865246773,-0.000293082557618618,-0.0002375887706875801
+20,2,20.0,7.1616321761780455e-09,0.0015487109979796746,-0.00010512489825487137,-8.937250822782516e-05,-9.404776560861805e-07,0.0019608777947723866,0.00010512815788388252,8.937017992138863e-05,-0.002546322997659445,-0.00022387364879250526,-0.00017382996156811714
+21,1,20.5,1.2005225979994094e-08,0.0015487181439359362,-0.00010188575834035873,-8.659716695547104e-05,-1.0574914846017691e-06,0.0019605131819844246,0.00010188296437263489,8.659809827804565e-05,-0.002445746213197708,-0.00016940850764513016,-0.00013363640755414963
+21,2,21.0,7.5469843707765e-09,0.001548692199227755,-9.881984442472458e-05,-8.39056447148323e-05,-9.763081801894558e-07,0.0019607869908213615,9.881611913442612e-05,8.391123265028e-05,-0.0023945574648678303,-0.0001229965128004551,-9.305356070399284e-05
+22,1,21.5,6.037053218443944e-09,0.0015486938404374378,-9.613670408725739e-05,-8.161552250385284e-05,-1.0525385535364862e-06,0.00196036696434021,9.6137635409832e-05,8.160900324583054e-05,-0.002243565861135721,-3.6747660487890244e-05,-2.6164110749959946e-05
+22,2,22.0,9.586391680471706e-09,0.001548693360520578,-9.382795542478561e-05,-7.957685738801956e-05,-9.683724135900462e-07,0.001960549969226122,9.383400902152061e-05,7.956428453326225e-05,-0.0021634772419929504,-1.710653305053711e-05,-1.1105090379714966e-05
+23,1,22.5,9.489836569342991e-09,0.0015486823349255578,-9.185541421175003e-05,-7.787439972162247e-05,-1.0168454692704998e-06,0.0019601034000515938,9.18535515666008e-05,7.786881178617477e-05,-0.0019649858586490154,0.00010295165702700615,8.555082604289055e-05
+23,2,23.0,6.585969006267511e-09,0.0015486694330888832,-9.038113057613373e-05,-7.635168731212616e-05,-9.023735720870008e-07,0.0019602179527282715,9.038485586643219e-05,7.635634392499924e-05,-0.001856005284935236,9.549083188176155e-05,7.625715807080269e-05
+24,1,23.5,6.188236104098799e-09,0.0015486604639943502,-8.921325206756592e-05,-7.526762783527374e-05,-1.0200224049849993e-06,0.001959813293069601,8.920999243855476e-05,7.527368143200874e-05,-0.0016284165903925896,0.0002412758767604828,0.00019868742674589157
+24,2,24.0,9.620717680847157e-09,0.0015486650695279314,-8.823629468679428e-05,-7.427390664815903e-05,-9.335468453830487e-07,0.0019598701037466526,8.823955431580544e-05,7.426505908370018e-05,-0.0014977920800447464,0.0002111736685037613,0.00016872771084308624

research/fine_surface_joint_20261014/blow_collisions.csv

@@ -0,0 +1,73 @@
+step,level,substep,max_error,max_ratio,regime,drift_m,drift_px,drift_py,ideal_defect_m,ideal_defect_px,ideal_defect_py,measured_rounding_m,measured_rounding_px,measured_rounding_py
+1,fine,1,6.200234548003891e-08,0.28965071213188953,True,1.6061589121818542e-05,1.7695128917694092e-08,6.51925802230835e-09,-3.41740524767431e-16,1.214306433183765e-17,-8.673617379884035e-18,1.6061589122160283e-05,1.7695128905551027e-08,6.519258030981967e-09
+1,fine,2,9.592780092493314e-08,0.3574847775115332,True,-3.2549723982810974e-07,-1.3969838619232178e-09,-1.4435499906539917e-08,-5.4539706084710815e-15,1.3877787807814457e-17,3.469446951953614e-17,-3.2549723437413913e-07,-1.3969838758010056e-09,-1.4435499941234387e-08
+1,coarse,1,1.1080350609260492e-08,0.10456730670501622,True,-1.5292316675186157e-06,-1.30385160446167e-08,-1.5832483768463135e-07,-4.288236432614667e-15,-5.551115123125783e-17,1.3877787807814457e-17,-1.5292316632303793e-06,-1.3038515989105548e-08,-1.5832483769850914e-07
+2,fine,1,7.754918973645886e-08,0.34580397879479957,True,8.987262845039368e-07,-2.3283064365386963e-08,-1.9744038581848145e-07,-5.167741234934908e-15,-1.5612511283791264e-17,2.931682674400804e-16,8.98726289671678e-07,-2.328306434977445e-08,-1.974403861116497e-07
+2,fine,2,1.155261522001183e-07,0.321440603069343,True,2.284534275531769e-06,-2.8870999813079834e-08,8.66129994392395e-08,-1.1794384913166311e-14,-7.112366251504909e-17,2.203098814490545e-16,2.2845342873261537e-06,-2.887099974195617e-08,8.661299921892962e-08
+2,coarse,1,1.6365805183271576e-08,0.1544470929589978,True,-1.426786184310913e-06,-3.0919909477233887e-07,-3.0919909477233887e-07,-6.286637876939949e-15,-8.326672684688674e-17,-8.326672684688674e-17,-1.4267861780242752e-06,-3.0919909468907214e-07,-3.0919909468907214e-07
+3,fine,1,9.149310453704373e-08,0.3150717610922152,True,4.654750227928162e-06,1.0896474123001099e-07,6.146728992462158e-08,-1.1813466871402056e-14,1.1449174941446927e-16,2.1163626406917047e-16,4.6547502397416285e-06,1.0896474111551924e-07,6.146728971298532e-08
+3,fine,2,1.0172501863081607e-07,0.3828123813437159,True,7.561873644590378e-06,1.257285475730896e-08,5.168840289115906e-08,-1.7838161503469507e-14,8.673617379884035e-18,3.2786273695961654e-16,7.561873662428539e-06,1.2572854748635343e-08,5.168840256329632e-08
+3,coarse,1,1.0010523732173482e-07,0.2854567053212911,True,9.115785360336304e-06,3.3155083656311035e-07,3.203749656677246e-07,-3.837208328860697e-15,1.5334955527634975e-15,1.2420620087993939e-15,9.115785364173512e-06,3.315508350296148e-07,3.203749644256626e-07
+4,fine,1,1.1511500297434196e-07,0.3632811360585352,True,1.1234544217586517e-05,3.3155083656311035e-07,2.3469328880310059e-07,-2.0365653607967715e-14,2.5673907444456745e-16,2.393918396847994e-16,1.1234544237952171e-05,3.315508363063713e-07,2.3469328856370875e-07
+4,fine,2,1.323716875001324e-07,0.420721981505359,True,1.0875053703784943e-05,7.171183824539185e-08,5.4016709327697754e-08,-1.6948248360293405e-14,-6.83481049534862e-16,-4.0939474033052647e-16,1.0875053720733191e-05,7.17118389288729e-08,5.4016709737092494e-08
+4,coarse,1,1.2150177930436712e-07,0.37139422446265463,True,1.3064593076705933e-05,5.997717380523682e-07,5.62518835067749e-07,-1.2559397966072083e-14,-5.967448757360216e-16,-2.498001805406602e-16,1.306459308926533e-05,5.99771738649113e-07,5.625188353175492e-07
+5,fine,1,1.2583242237074188e-07,0.3554646638422362,True,9.815674275159836e-06,-2.789311110973358e-07,-3.608874976634979e-07,-1.565240992373873e-14,-1.9949319973733282e-16,-3.642919299551295e-17,9.815674290812246e-06,-2.789311108978426e-07,-3.6088749762706873e-07
+5,fine,2,1.2541811456046048e-07,0.3685724336736591,True,9.207520633935928e-06,-2.5192275643348694e-07,-4.0512531995773315e-08,-1.5307199952019346e-14,3.469446951953614e-17,4.3021142204224816e-16,9.207520649243128e-06,-2.519227564681814e-07,-4.051253242598474e-08
+5,coarse,1,1.2532259030528792e-07,0.38942307019337585,True,1.49458646774292e-05,9.723007678985596e-07,1.2628734111785889e-06,-1.6535384173010925e-14,1.5959455978986625e-16,6.175615574477433e-16,1.4945864693964583e-05,9.72300767738965e-07,1.2628734105610273e-06
+6,fine,1,1.0399005534456052e-07,0.4260869217553865,True,5.527399480342865e-06,-8.754432201385498e-08,-1.555308699607849e-07,-1.4764231504038605e-14,4.336808689942018e-17,3.86843335142828e-16,5.5273994951070965e-06,-8.754432205722307e-08,-1.5553087034762825e-07
+6,fine,2,1.295425238190262e-07,0.36331211716460343,True,5.567912012338638e-06,-2.6542693376541138e-08,-2.0908191800117493e-07,-1.4812803761365956e-14,-5.186823193170653e-16,1.734723475976807e-18,5.567912027151442e-06,-2.654269285785882e-08,-2.0908191800290965e-07
+6,coarse,1,1.0239773140519048e-07,0.43028837580529966,True,1.3461336493492126e-05,5.308538675308228e-07,4.2654573917388916e-07,-2.033095913844818e-14,2.0816681711721685e-16,1.2212453270876722e-15,1.3461336513823086e-05,5.308538673226559e-07,4.2654573795264383e-07
+7,fine,1,1.1958961998459472e-07,0.4029625240438387,True,5.150679498910904e-06,-5.3551048040390015e-08,-7.497146725654602e-08,-1.5931700403370996e-14,-5.204170427930421e-17,-1.700029006457271e-16,5.150679514842604e-06,-5.355104798834831e-08,-7.497146708654312e-08
+7,fine,2,1.265965450247819e-07,0.3851888208747954,True,3.789551556110382e-06,0.0,3.725290298461914e-09,-1.5173626244369132e-14,7.806255641895632e-17,3.903127820947816e-16,3.7895515712840083e-06,-7.806255641895632e-17,3.725289908149132e-09
+7,coarse,1,1.0902046165828239e-07,0.38161058826685446,True,1.2835487723350525e-05,8.326023817062378e-07,-2.6635825634002686e-07,-2.4501234374696423e-14,-5.48172618408671e-16,-2.5673907444456745e-16,1.283548774785176e-05,8.326023822544104e-07,-2.663582560832878e-07
+8,fine,1,1.2448945463372496e-07,0.3720247984466396,True,2.2617168724536896e-06,7.869675755500793e-08,3.259629011154175e-09,-1.5289852717259578e-14,7.28583859910259e-17,-2.636779683484747e-16,2.2617168877435423e-06,7.869675748214955e-08,3.259629274832143e-09
+8,fine,2,1.3473279458775522e-07,0.39946262369614577,True,2.4368055164813995e-06,7.031485438346863e-08,-1.5366822481155396e-08,-1.6287318715946242e-14,4.683753385137379e-17,-1.196959198423997e-16,2.4368055327687183e-06,7.03148543366311e-08,-1.5366822361459476e-08
+8,coarse,1,1.265961931951054e-07,0.38341345468786764,True,8.130446076393127e-06,7.506459951400757e-07,-5.830079317092896e-07,-2.2391810627908626e-14,-1.6861512186494565e-15,1.0408340855860843e-16,8.130446098784938e-06,7.506459968262269e-07,-5.83007931813373e-07
+9,fine,1,1.3222774730703435e-07,0.3900959817916434,True,2.078711986541748e-06,8.568167686462402e-08,6.239861249923706e-08,-1.5612511283791264e-14,-2.5326962749261384e-16,2.42861286636753e-16,2.0787120021542593e-06,8.568167711789365e-08,6.239861225637577e-08
+9,fine,2,1.2824470274619415e-07,0.4272642246416919,True,8.78702849149704e-07,9.266659617424011e-08,-1.3830140233039856e-07,-1.4988010832439613e-14,-1.6653345369377348e-16,-1.2836953722228372e-16,8.787028641377148e-07,9.266659634077357e-08,-1.3830140220202902e-07
+9,coarse,1,1.1335454486172125e-07,0.3876201969620664,True,5.185604095458984e-06,-2.384185791015625e-07,-6.07222318649292e-07,-2.583350200424661e-14,3.122502256758253e-16,7.632783294297951e-17,5.185604121292486e-06,-2.384185794138127e-07,-6.072223187256198e-07
+10,fine,1,1.2645846059200494e-07,0.3781818251482199,True,2.073124051094055e-06,6.426125764846802e-08,1.0151416063308716e-07,-1.6764367671839864e-14,2.949029909160572e-16,-2.1163626406917047e-16,2.073124067858423e-06,6.426125735356503e-08,1.0151416084472342e-07
+10,fine,2,1.3663077158554415e-07,0.43888780198316496,True,1.5008263289928436e-06,7.031485438346863e-08,1.9883736968040466e-07,-1.6273440928138427e-14,-1.4051260155412137e-16,6.071532165918825e-17,1.5008263452662846e-06,7.031485452398123e-08,1.9883736961968934e-07
+10,coarse,1,1.5257769281351585e-07,0.4176679708473079,True,4.520639777183533e-06,-5.904585123062134e-07,-3.166496753692627e-08,-2.443184543565735e-14,-4.649058915617843e-16,1.0408340855860843e-16,4.520639801615378e-06,-5.904585118413075e-07,-3.166496764100968e-08
+11,fine,1,1.4342478449336227e-07,0.40055388671598813,True,9.159557521343231e-07,1.4388933777809143e-07,1.103617250919342e-07,-1.6368850719317152e-14,-7.979727989493313e-17,-1.3877787807814457e-17,9.159557685031738e-07,1.438893378578887e-07,1.1036172510581199e-07
+11,fine,2,1.229973988214894e-07,0.44018383771634995,True,1.3504177331924438e-06,-2.7939677238464355e-08,-3.725290298461914e-09,-1.6167622796103842e-14,-1.942890293094024e-16,1.457167719820518e-16,1.3504177493600666e-06,-2.7939677044175326e-08,-3.725290444178686e-09
+11,coarse,1,1.0126133054289e-07,0.37920635013850246,True,2.175569534301758e-06,-1.341104507446289e-07,1.2665987014770508e-07,-2.38073449843057e-14,9.020562075079397e-17,5.759281940243e-16,2.175569558109103e-06,-1.3411045083483453e-07,1.2665986957177688e-07
+12,fine,1,1.2071681543268653e-07,0.4311470967916149,True,1.3746321201324463e-06,-2.1420419216156006e-08,1.4528632164001465e-07,-1.6273440928138427e-14,-2.237793284010081e-16,-4.0072112295064244e-16,1.3746321364058872e-06,-2.1420418992376677e-08,1.4528632204073577e-07
+12,fine,2,1.371591822341145e-07,0.44227593234711177,True,1.982320100069046e-06,9.73232090473175e-08,1.448206603527069e-07,-1.6818144099595145e-14,-2.96637714392034e-16,1.214306433183765e-17,1.98232011688719e-06,9.732320934395522e-08,1.4482066034056384e-07
+12,coarse,1,1.2813768046626706e-07,0.42388935775355246,True,3.3173710107803345e-06,-4.898756742477417e-07,-1.8067657947540283e-07,-2.7193525209412428e-14,-1.1171619185290638e-15,-4.649058915617843e-16,3.3173710379738597e-06,-4.898756731305798e-07,-1.8067657901049694e-07
+13,fine,1,1.3950153099351326e-07,0.4396993900025004,True,1.2670643627643585e-06,2.3050233721733093e-07,1.2153759598731995e-07,-1.662038562333379e-14,3.903127820947816e-16,9.194034422677078e-17,1.2670643793847441e-06,2.3050233682701815e-07,1.215375958953796e-07
+13,fine,2,1.2581214114959494e-07,0.4721292711508529,True,1.1995434761047363e-06,3.7159770727157593e-07,1.0710209608078003e-07,-1.5909148998183298e-14,-8.153200337090993e-17,9.540979117872439e-17,1.1995434920138853e-06,3.7159770735310793e-07,1.0710209598537024e-07
+13,coarse,1,1.2660152992616247e-07,0.45318197065007865,True,7.878988981246948e-07,-1.210719347000122e-07,3.334134817123413e-07,-2.346040028911034e-14,-4.2327252813834093e-16,2.706168622523819e-16,7.878989215850951e-07,-1.2107193427673968e-07,3.3341348144172445e-07
+14,fine,1,1.5054562552130335e-07,0.5104225030616341,True,6.658956408500671e-07,1.778826117515564e-07,-2.60770320892334e-08,-1.6335890973273592e-14,2.96637714392034e-16,3.86843335142828e-16,6.658956571859581e-07,1.7788261145491868e-07,-2.6077032476076734e-08
+14,fine,2,1.3530934717120857e-07,0.4009751179733903,True,1.2051314115524292e-06,-1.955777406692505e-08,1.6205012798309326e-07,-1.6099968580540747e-14,-1.5785983631388945e-16,8.500145032286355e-17,1.2051314276523978e-06,-1.9557773909065213e-08,1.620501278980918e-07
+14,coarse,1,1.3409460186686317e-07,0.39963893479139145,True,3.9692968130111694e-06,8.754432201385498e-08,2.9616057872772217e-07,-2.5528190672474693e-14,-6.245004513516506e-17,-6.314393452555578e-16,3.96929683853936e-06,8.754432207630503e-08,2.961605793591615e-07
+15,fine,1,1.2702620799665e-07,0.37981873927853255,True,1.000240445137024e-06,-3.166496753692627e-08,7.729977369308472e-08,-1.607568245187707e-14,-2.1337098754514727e-16,1.4051260155412137e-16,1.0002404612127064e-06,-3.166496732355528e-08,7.729977355257212e-08
+15,fine,2,1.1264902777252672e-07,0.42131603992753336,True,8.651986718177795e-07,-4.377216100692749e-08,-1.0151416063308716e-07,-1.5992415725030185e-14,4.336808689942018e-17,3.2959746043559335e-17,8.651986878101953e-07,-4.377216105029558e-08,-1.015141606660469e-07
+15,coarse,1,1.305862756817433e-07,0.5086178241462508,True,1.6335397958755493e-06,-6.146728992462158e-08,2.2165477275848389e-07,-2.533390164316529e-14,-4.85722573273506e-17,2.706168622523819e-16,1.633539821209451e-06,-6.146728987604932e-08,2.2165477248786702e-07
+16,fine,1,1.3092614292720128e-07,0.40502514569399495,True,9.629875421524048e-07,-9.685754776000977e-08,8.66129994392395e-08,-1.6838960781306866e-14,-9.194034422677078e-17,8.500145032286355e-17,9.629875589913656e-07,-9.685754766806942e-08,8.661299935423805e-08
+16,fine,2,1.3893401662468108e-07,0.39764517507033376,True,1.5990808606147766e-06,-8.009374141693115e-08,-5.3085386753082275e-08,-1.6518036938251157e-14,3.0531133177191805e-16,3.5735303605122226e-16,1.5990808771328135e-06,-8.009374172224248e-08,-5.308538711043531e-08
+16,coarse,1,1.2888908407227007e-07,0.4083972967001409,True,5.159527063369751e-06,-4.3213367462158203e-07,1.4901161193847656e-07,-2.6131874442114622e-14,7.216449660063518e-16,-3.885780586188048e-16,5.159527089501625e-06,-4.32133675343227e-07,1.4901161232705462e-07
+17,fine,1,1.249536419889452e-07,0.39288318869275274,True,1.12876296043396e-06,-1.7601996660232544e-07,-2.3283064365386963e-07,-1.7957857423311907e-14,-5.551115123125783e-16,1.3530843112619095e-16,1.1287629783918174e-06,-1.7601996604721393e-07,-2.3283064378917806e-07
+17,fine,2,1.3328934989065289e-07,0.46401164838116316,True,7.129274308681488e-07,-2.1373853087425232e-07,-2.6496127247810364e-07,-1.634803403760543e-14,-2.914335439641036e-16,9.71445146547012e-17,7.129274472161828e-07,-2.1373853058281878e-07,-2.6496127257524815e-07
+17,coarse,1,1.246264329513025e-07,0.4613853551985751,True,5.302950739860535e-06,-2.0675361156463623e-07,1.1362135410308838e-07,-2.8373137173076657e-14,7.7021722333370235e-16,-6.869504964868156e-16,5.302950768233672e-06,-2.0675361233485345e-07,1.1362135479003888e-07
+18,fine,1,1.5840482392448507e-07,0.48249679461224454,True,8.10716301202774e-07,-1.4016404747962952e-07,-2.6402994990348816e-07,-1.6878859421254333e-14,7.632783294297951e-17,2.0816681711721685e-17,8.107163180816335e-07,-1.4016404755595735e-07,-2.6402994992430484e-07
+18,fine,2,1.217794476371381e-07,0.4447119430321027,True,1.4016404747962952e-07,-2.8545036911964417e-07,-8.847564458847046e-09,-1.709223040879948e-14,-1.1275702593849246e-16,1.8214596497756474e-16,1.4016406457185993e-07,-2.8545036900688714e-07,-8.847564640993011e-09
+18,coarse,1,1.3857981828735433e-07,0.4519491616828685,True,5.850568413734436e-06,-1.2479722499847412e-07,-1.471489667892456e-07,-2.688821387764051e-14,-8.534839501805891e-16,9.08995101411847e-16,5.85056844062265e-06,-1.2479722414499017e-07,-1.471489676982407e-07
+19,fine,1,1.4433919059975153e-07,0.3821888438774327,True,1.9441358745098114e-06,-1.3969838619232178e-09,-2.7474015951156616e-08,-1.628905343942222e-14,-3.920475055707584e-16,2.42861286636753e-17,1.944135890798865e-06,-1.3969834698757122e-09,-2.7474015975442745e-08
+19,fine,2,1.4349667698532187e-07,0.4183999473130793,True,2.1490268409252167e-06,1.7834827303886414e-07,-7.869675755500793e-08,-1.678344963007561e-14,-5.204170427930421e-18,2.949029909160572e-17,2.1490268577086663e-06,1.783482730440683e-07,-7.869675758449823e-08
+19,coarse,1,1.264100825126846e-07,0.5347769553832019,True,5.165114998817444e-06,3.91155481338501e-08,1.1734664440155029e-07,-2.6804947150793623e-14,-4.2327252813834093e-16,-3.8163916471489756e-16,5.165115025622391e-06,3.9115548557122626e-08,1.1734664478318946e-07
+20,fine,1,1.1464598925758906e-07,0.39800949885565845,True,1.8593855202198029e-06,7.031485438346863e-08,-2.2817403078079224e-08,-1.695171780724536e-14,1.457167719820518e-16,-7.632783294297951e-17,1.8593855371715207e-06,7.031485423775186e-08,-2.281740300175139e-08
+20,fine,2,1.3166252321727967e-07,0.41581763506478076,True,2.2118911147117615e-06,9.313225746154785e-10,9.033828973770142e-08,-1.7095699855751434e-14,-3.7643499428696714e-16,2.0990154059319366e-16,2.2118911318074613e-06,9.313229510504728e-10,9.033828952779988e-08
+20,coarse,1,1.3024161815700097e-07,0.47356066681074566,True,4.023313522338867e-06,5.997717380523682e-07,-8.568167686462402e-08,-2.7228219678931964e-14,3.0531133177191805e-16,3.7470027081099033e-16,4.023313549567087e-06,5.997717377470568e-07,-8.56816772393243e-08
+21,fine,1,1.361732063775989e-07,0.4205892378883329,True,2.439599484205246e-06,1.4854595065116882e-07,-1.327134668827057e-07,-1.6781714906599632e-14,3.885780586188048e-16,8.673617379884035e-17,2.439599500986961e-06,1.4854595026259076e-07,-1.3271346696944186e-07
+21,fine,2,1.2473161092874108e-07,0.45376916235253945,True,2.2514723241329193e-06,3.5902485251426697e-07,1.9976869225502014e-07,-1.692396223162973e-14,6.938893903907228e-17,-1.457167719820518e-16,2.2514723410568815e-06,3.5902485244487803e-07,1.9976869240073691e-07
+21,coarse,1,1.5484813187249813e-07,0.561763881940829,True,3.507360816001892e-06,7.431954145431519e-07,6.202608346939087e-07,-2.6131874442114622e-14,-4.579669976578771e-16,1.5265566588595902e-16,3.5073608421337665e-06,7.431954150011189e-07,6.20260834541253e-07
+22,fine,1,1.1594882032284204e-07,0.46103443091228286,True,1.2228265404701233e-06,2.300366759300232e-07,1.9185245037078857e-07,-1.5529244556944377e-14,-3.469446951953614e-18,7.28583859910259e-17,1.2228265559993678e-06,2.3003667593349264e-07,1.918524502979302e-07
+22,fine,2,1.4032262196650436e-07,0.41123793671363457,True,2.0829029381275177e-06,1.317821443080902e-07,1.1594966053962708e-07,-1.6656814816329302e-14,-2.42861286636753e-17,2.7755575615628914e-17,2.0829029547843325e-06,1.3178214433237634e-07,1.159496605118715e-07
+22,coarse,1,1.4061314457247676e-07,0.5696050037738337,True,5.517154932022095e-06,1.6167759895324707e-06,1.0058283805847168e-06,-2.643718577388654e-14,-4.996003610813204e-16,-4.579669976578771e-16,5.5171549584592805e-06,1.616775990032071e-06,1.0058283810426838e-06
+23,fine,1,1.172129048265802e-07,0.43537551205849856,True,1.8416903913021088e-06,2.230517566204071e-07,2.1746382117271423e-07,-1.620752143605131e-14,-4.735795089416683e-16,1.9081958235744878e-17,1.8416904075096302e-06,2.2305175709398661e-07,2.1746382115363228e-07
+23,fine,2,1.2559042006365928e-07,0.4297035689234779,True,1.998152583837509e-06,7.031485438346863e-08,4.98257577419281e-08,-1.62231339473351e-14,3.0184188481996443e-16,-3.7816971776294395e-16,1.998152600060643e-06,7.031485408162674e-08,4.982575812009782e-08
+23,coarse,1,1.5135824793510722e-07,0.4407189177218073,True,1.2038275599479675e-05,1.3243407011032104e-06,7.692724466323853e-07,-2.7304547511874944e-14,1.4502288259166107e-15,-4.371503159461554e-16,1.2038275626784223e-05,1.3243406996529816e-06,7.692724470695356e-07
+24,fine,1,1.1879041472706575e-07,0.3912946498849803,True,1.0398216545581818e-06,1.62515789270401e-07,1.3737007975578308e-07,-1.705927066275592e-14,1.6306400674181987e-16,-9.020562075079397e-17,1.0398216716174524e-06,1.62515789107337e-07,1.373700798459887e-07
+24,fine,2,1.4235627243674998e-07,0.4195513876580241,True,1.6004778444766998e-06,1.3830140233039856e-07,1.7927959561347961e-07,-1.668977456237286e-14,-1.9949319973733282e-16,1.2663481374630692e-16,1.6004778611664744e-06,1.3830140252989176e-07,1.792795954868448e-07
+24,coarse,1,1.5865499780609582e-07,0.5231448442629695,True,9.544193744659424e-06,4.5821070671081543e-07,2.942979335784912e-07,-2.545880173343562e-14,3.8163916471489756e-16,-1.457167719820518e-16,9.544193770118226e-06,4.5821070632917626e-07,2.94297933724208e-07

research/fine_surface_joint_20261014/blow_ledger.csv

@@ -0,0 +1,25 @@
+step,time,average_bound_ratio,leaf_m,leaf_px,leaf_py,delta_m,delta_px,delta_py,boundary_m,boundary_px,boundary_py,fine_transfer_m,fine_transfer_px,fine_transfer_py,coarse_transfer_m,coarse_transfer_px,coarse_transfer_py,raw_m,raw_px,raw_py,collision_drift_m,collision_drift_px,collision_drift_py,average_rounding_m,average_rounding_px,average_rounding_py,closure_m,closure_px,closure_py,cumulative_raw_m,cumulative_raw_px,cumulative_raw_py,cumulative_closure_m,cumulative_closure_px,cumulative_closure_py
+1,1,0.28124994289828603,560.7534663206898,0.0016594058834016323,0.0014196881093084812,0.003462142776697874,0.0016594058834016323,0.0014196881093084812,0.0034477608278393745,0.0016594044864177704,0.001420031301677227,-3.557652235031128e-07,0.0,0.0,5.308538675308228e-07,-1.862645149230957e-09,-1.7695128917694092e-07,1.4206860214471817e-05,3.259629011154175e-09,-1.6624107956886292e-07,1.4206860214471817e-05,3.259629011154175e-09,-1.6624107956886292e-07,1.7508864402770996e-07,-1.862645149230957e-09,-1.7695128917694092e-07,0.0,0.0,0.0,1.4206860214471817e-05,3.259629011154175e-09,-1.6624107956886292e-07,0.0,0.0,0.0
+2,2,0.37499987985940486,560.7572004375979,0.003110479563474655,0.002638322301208973,0.0037341169081628323,0.0014510736800730228,0.0012186341919004917,0.003732521552592516,0.0014515905641019344,0.0012190532870590687,-2.193264663219452e-06,-4.6566128730773926e-09,-1.685693860054016e-07,2.032145857810974e-06,-1.5087425708770752e-07,1.695007085800171e-07,1.7564743757247925e-06,-3.6135315895080566e-07,-4.200264811515808e-07,1.7564743757247925e-06,-3.6135315895080566e-07,-4.200264811515808e-07,-1.6111880540847778e-07,-1.555308699607849e-07,9.313225746154785e-10,0.0,0.0,0.0,1.596333459019661e-05,-3.580935299396515e-07,-5.862675607204437e-07,0.0,0.0,0.0
+3,3,0.2812499146093721,560.7611049492843,0.004511175211519003,0.0038183839060366154,0.00390451168641448,0.0014006956480443478,0.0011800616048276424,0.0038831778801977634,0.0014002365060150623,0.0011796201579272747,-3.6400742828845978e-06,4.698522388935089e-07,4.6798959374427795e-07,3.641471266746521e-06,-4.637986421585083e-07,-4.600733518600464e-07,2.1332409232854843e-05,4.530884325504303e-07,4.3353065848350525e-07,2.1332409232854843e-05,4.530884325504303e-07,4.3353065848350525e-07,1.3969838619232178e-09,6.05359673500061e-09,7.916241884231567e-09,0.0,0.0,0.0,3.729574382305145e-05,9.499490261077881e-08,-1.5273690223693848e-07,0.0,0.0,0.0
+4,4,0.37499987985940486,560.7650738614611,0.005782689433544874,0.004893188830465078,0.003968912176787853,0.0012715142220258713,0.001074804924428463,0.003933848347514868,0.0012704567052423954,0.001073895487934351,-6.910879164934158e-06,3.1711533665657043e-07,3.9534643292427063e-07,6.800517439842224e-06,-2.6263296604156494e-07,-3.371387720108032e-07,3.517419099807739e-05,1.0030344128608704e-06,8.512288331985474e-07,3.517419099807739e-05,1.0030344128608704e-06,8.512288331985474e-07,-1.103617250919342e-07,5.448237061500549e-08,5.820766091346741e-08,0.0,0.0,0.0,7.246993482112885e-05,1.0980293154716492e-06,6.984919309616089e-07,0.0,0.0,0.0
+5,5,0.3749998295680158,560.7690546456724,0.006910111755132675,0.005846448242664337,0.003980784211307764,0.001127422321587801,0.0009532594121992588,0.0039466856978833675,0.001126923132687807,0.0009523364715278149,-7.287599146366119e-06,1.0672956705093384e-06,4.637986421585083e-07,7.417052984237671e-06,-1.0095536708831787e-06,-4.023313522338867e-07,3.396905958652496e-05,4.414469003677368e-07,8.614733815193176e-07,3.396905958652496e-05,4.414469003677368e-07,8.614733815193176e-07,1.2945383787155151e-07,5.774199962615967e-08,6.146728992462158e-08,0.0,0.0,0.0,0.00010643899440765381,1.539476215839386e-06,1.5599653124809265e-06,0.0,0.0,0.0
+6,6,0.46874973195382685,560.7730254461057,0.007904952857643366,0.006686040665954351,0.003970800433307886,0.0009948411025106907,0.0008395924232900143,0.003946303389966488,0.0009944625198841095,0.00083962082862854,-6.226822733879089e-06,2.0954757928848267e-07,-1.8533319234848022e-07,6.167218089103699e-06,-2.477318048477173e-07,9.499490261077881e-08,2.455664798617363e-05,4.1676685214042664e-07,6.193295121192932e-08,2.455664798617363e-05,4.1676685214042664e-07,6.193295121192932e-08,-5.960464477539063e-08,-3.818422555923462e-08,-9.033828973770142e-08,0.0,0.0,0.0,0.00013099564239382744,1.9562430679798126e-06,1.6218982636928558e-06,0.0,0.0,0.0
+7,7,0.4687496533735736,560.7769900038838,0.008779809810221195,0.007423080503940582,0.003964557778090239,0.0008748569525778294,0.0007370398379862309,0.003942790906876326,0.0008741165511310101,0.0007373974658548832,-2.6883091777563095e-05,-1.3766344636678696e-05,-7.656868547201157e-06,2.6874244213104248e-05,1.3727694749832153e-05,7.636845111846924e-06,2.177571877837181e-05,7.790513336658478e-07,-3.3760443329811096e-07,2.177571877837181e-05,7.790513336658478e-07,-3.3760443329811096e-07,-8.847564458847046e-09,-3.864988684654236e-08,-2.0023435354232788e-08,0.0,0.0,0.0,0.00015277136117219925,2.7352944016456604e-06,1.2842938303947449e-06,0.0,0.0,0.0
+8,8,0.4687496533735736,560.7809417177923,0.009547093417495489,0.00806809077039361,0.0039517139084637165,0.0007672836072742939,0.0006450102664530277,0.0039388518780469894,0.0007664291188120842,0.0006456412374973297,-0.00016948627308011055,-8.736597374081612e-05,-5.452195182442665e-05,0.0001695193350315094,8.732080459594727e-05,5.4486095905303955e-05,1.2828968465328217e-05,8.996576070785522e-07,-5.951151251792908e-07,1.2828968465328217e-05,8.996576070785522e-07,-5.951151251792908e-07,3.306195139884949e-08,-4.516914486885071e-08,-3.585591912269592e-08,0.0,0.0,0.0,0.00016560032963752747,3.6349520087242126e-06,6.891787052154541e-07,0.0,0.0,0.0
+9,9,0.4686406250816172,560.7848850805312,0.010217653587460518,0.008631827309727669,0.0039433627389371395,0.0006705601699650288,0.0005637365393340588,0.00393525930121541,0.0006706290878355503,0.0005643940530717373,-0.000617987010627985,-0.0002765483222901821,-0.00019021378830075264,0.0006179474294185638,0.00027653947472572327,0.00019023939967155457,8.143018931150436e-06,-6.007030606269836e-08,-6.831251084804535e-07,8.143018931150436e-06,-6.007030606269836e-08,-6.831251084804535e-07,-3.958120942115784e-08,-8.847564458847046e-09,2.561137080192566e-08,0.0,0.0,0.0,0.0001737433485686779,3.5748817026615143e-06,6.05359673500061e-09,0.0,0.0,0.0
+10,10,0.4685945715880829,560.7888254267164,0.010803885292261839,0.00912527134642005,0.00394034618511796,0.000586231704801321,0.0004934440366923809,0.0039321803487837315,0.000586662907153368,0.0004931562580168247,-0.0014882697723805904,-0.0005795764736831188,-0.00043088337406516075,0.0014883410185575485,0.0005796011537313461,0.00043090246617794037,8.094590157270432e-06,-4.5588240027427673e-07,2.6868656277656555e-07,8.094590157270432e-06,-4.5588240027427673e-07,2.6868656277656555e-07,7.12461769580841e-08,2.468004822731018e-08,1.909211277961731e-08,0.0,0.0,0.0,0.00018183793872594833,3.1189993023872375e-06,2.7474015951156616e-07,0.0,0.0,0.0
+11,11,0.37499977927664024,560.7927596913651,0.011317913420498371,0.009557455778121948,0.003934264648705721,0.0005140281282365322,0.0004321844317018986,0.003929825499653816,0.0005140695720911026,0.0004319213330745697,-0.0026630824431777,-0.0009266296401619911,-0.0007359907031059265,0.002663079649209976,0.0009266063570976257,0.0007360205054283142,4.441943019628525e-06,-1.816079020500183e-08,2.3329630494117737e-07,4.441943019628525e-06,-1.816079020500183e-08,2.3329630494117737e-07,-2.7939677238464355e-09,-2.3283064365386963e-08,2.9802322387695312e-08,0.0,0.0,0.0,0.00018627988174557686,3.1008385121822357e-06,5.080364644527435e-07,0.0,0.0,0.0
+12,12,0.46874663591177923,560.7966943499632,0.011769441422075033,0.009937478695064783,0.003934658598154783,0.00045152800157666206,0.00038002291694283485,0.003928040154278278,0.00045189354568719864,0.0003798864781856537,-0.0038390979170799255,-0.0012310631573200226,-0.0010304069146513939,0.0038390420377254486,0.0012311115860939026,0.0010304339230060577,6.674323230981827e-06,-4.139728844165802e-07,1.0943040251731873e-07,6.674323230981827e-06,-4.139728844165802e-07,1.0943040251731873e-07,-5.587935447692871e-08,4.842877388000488e-08,2.7008354663848877e-08,0.0,0.0,0.0,0.00019295420497655869,2.6868656277656555e-06,6.174668669700623e-07,0.0,0.0,0.0
+13,13,0.37499972898527817,560.8006243831478,0.01216893782839179,0.010273906867951155,0.0039300331845879555,0.0003994964063167572,0.0003364281728863716,0.003926742821931839,0.00039900559931993484,0.00033587682992219925,-0.004740437027066946,-0.0014326325617730618,-0.0012463550083339214,0.004740472882986069,0.0014326423406600952,0.0012463442981243134,3.2545067369937897e-06,4.810281097888947e-07,5.620531737804413e-07,3.2545067369937897e-06,4.810281097888947e-07,5.620531737804413e-07,3.585591912269592e-08,9.778887033462524e-09,-1.0710209608078003e-08,0.0,0.0,0.0,0.00019620871171355247,3.16789373755455e-06,1.1795200407505035e-06,0.0,0.0,0.0
+14,14,0.4687474688530803,560.8045558938757,0.012523647397756577,0.010573056526482105,0.003931510727852583,0.00035470956936478615,0.00029914965853095055,0.003925675991922617,0.00035448791459202766,0.00029869796708226204,-0.005264284089207649,-0.0015086885541677475,-0.0013435659930109978,0.0052642785012722015,0.0015086643397808075,0.0013435855507850647,5.840323865413666e-06,2.4586915969848633e-07,4.3213367462158203e-07,5.840323865413666e-06,2.4586915969848633e-07,4.3213367462158203e-07,-5.587935447692871e-09,-2.421438694000244e-08,1.955777406692505e-08,0.0,0.0,0.0,0.00020204903557896614,3.4137628972530365e-06,1.6116537153720856e-06,0.0,0.0,0.0
+15,15,0.4682317851482336,560.8084840090014,0.012841148767620325,0.010841074865311384,0.003928115125745535,0.00031750136986374855,0.00026801833882927895,0.003924637567251921,0.00031766900792717934,0.00026782089844346046,-0.005472308956086636,-0.0014677206054329872,-0.001318071037530899,0.005472287535667419,0.001467689871788025,0.001318071037530899,3.4989789128303528e-06,-1.3690441846847534e-07,1.9744038581848145e-07,3.4989789128303528e-06,-1.3690441846847534e-07,1.9744038581848145e-07,-2.1420419216156006e-08,-3.073364496231079e-08,0.0,0.0,0.0,0.0,0.0002055480144917965,3.276858478784561e-06,1.809094101190567e-06,0.0,0.0,0.0
+16,16,0.4687439328019107,560.8124153451063,0.013128423597663641,0.011083992663770914,0.0039313361048698425,0.0002872748300433159,0.00024291779845952988,0.003923660609871149,0.0002878890372812748,0.00024270685389637947,-0.005496661644428968,-0.0013386714272201061,-0.0011936011724174023,0.005496615543961525,0.0013386663049459457,0.001193629577755928,7.721595466136932e-06,-6.09084963798523e-07,1.825392246246338e-07,7.721595466136932e-06,-6.09084963798523e-07,1.825392246246338e-07,-4.6100467443466187e-08,-5.122274160385132e-09,2.8405338525772095e-08,0.0,0.0,0.0,0.00021326960995793343,2.667773514986038e-06,1.991633325815201e-06,0.0,0.0,0.0
+17,17,0.46873638940438433,560.8163452413864,0.013391933869570494,0.011306562926620245,0.003929896280169487,0.0002635102719068527,0.0002225702628493309,0.003922717645764351,0.0002640876919031143,0.00022296980023384094,-0.005448666866868734,-0.0011560707353055477,-0.0010099620558321476,0.005448700860142708,0.0011560898274183273,0.0010099466890096664,7.1446411311626434e-06,-5.96512109041214e-07,-3.841705620288849e-07,7.1446411311626434e-06,-5.96512109041214e-07,-3.841705620288849e-07,3.3993273973464966e-08,1.909211277961731e-08,-1.5366822481155396e-08,0.0,0.0,0.0,0.00022041425108909607,2.0712614059448242e-06,1.607462763786316e-06,0.0,0.0,0.0
+18,18,0.4687180348178792,560.8202739986591,0.013636329676955938,0.011513229925185442,0.003928757272660732,0.00024439580738544464,0.000206666998565197,0.003921979106962681,0.00024497322738170624,0.0002071000635623932,-0.00538009125739336,-0.0009485194459557533,-0.0008049774914979935,0.005380067974328995,0.0009484924376010895,0.0008049644529819489,6.80144876241684e-06,-5.504116415977478e-07,-4.200264811515808e-07,6.80144876241684e-06,-5.504116415977478e-07,-4.200264811515808e-07,-2.3283064365386963e-08,-2.7008354663848877e-08,-1.30385160446167e-08,0.0,0.0,0.0,0.0002272156998515129,1.5208497643470764e-06,1.1874362826347351e-06,0.0,0.0,0.0
+19,19,0.4687494647810733,560.8242048402317,0.013865197543054819,0.011706916149705648,0.003930841572582722,0.00022886786609888077,0.00019368622452020645,0.0039215972647070885,0.00022865179926156998,0.00019369274377822876,-0.005283902399241924,-0.0007343888282775879,-0.0006027696654200554,0.005283888429403305,0.0007343888282775879,0.0006027519702911377,9.258277714252472e-06,2.1606683731079102e-07,1.1175870895385742e-08,9.258277714252472e-06,2.1606683731079102e-07,1.1175870895385742e-08,-1.3969838619232178e-08,0.0,-1.7695128917694092e-08,0.0,0.0,0.0,0.00023647397756576538,1.7369166016578674e-06,1.1986121535301208e-06,0.0,0.0,0.0
+20,20,0.468749291904748,560.8281343518756,0.01407972676679492,0.011888547334820032,0.003929511643946171,0.00021452922374010086,0.0001816311851143837,0.0039214082062244415,0.00021384842693805695,0.00018165074288845062,-0.005120935384184122,-0.0005169562064111233,-0.00041141873225569725,0.005120944231748581,0.0005169659852981567,0.00041141733527183533,8.094590157270432e-06,6.710179150104523e-07,-1.816079020500183e-08,8.094590157270432e-06,6.710179150104523e-07,-1.816079020500183e-08,8.847564458847046e-09,9.778887033462524e-09,-1.3969838619232178e-09,0.0,0.0,0.0,0.0002445685677230358,2.4079345166683197e-06,1.180451363325119e-06,0.0,0.0,0.0
+21,21,0.4686316241476506,560.8320638332516,0.014281701296567917,0.012059765867888927,0.003929481375962496,0.0002019745297729969,0.00017121853306889534,0.003921300172805786,0.000200699083507061,0.00017050933092832565,-0.004840303678065538,-0.00029240502044558525,-0.00022668996825814247,0.004840286448597908,0.00029242970049381256,0.00022671185433864594,8.198432624340057e-06,1.2507662177085876e-06,6.873160600662231e-07,8.198432624340057e-06,1.2507662177085876e-06,6.873160600662231e-07,-1.7229467630386353e-08,2.468004822731018e-08,2.1886080503463745e-08,0.0,0.0,0.0,0.00025276700034737587,3.6587007343769073e-06,1.8677674233913422e-06,0.0,0.0,0.0
+22,22,0.46868277541627273,560.835993598681,0.014473678078502417,0.012222256977111101,0.0039297654293477535,0.00019197678193449974,0.0001624911092221737,0.003920916933566332,0.00018997164443135262,0.0001611732877790928,-0.004407043103128672,-5.385419353842735e-05,-3.726920112967491e-05,0.004407068714499474,5.3880736231803894e-05,3.727339208126068e-05,8.822884410619736e-06,1.978594809770584e-06,1.3136304914951324e-06,8.822884410619736e-06,1.978594809770584e-06,1.3136304914951324e-06,2.561137080192566e-08,2.6542693376541138e-08,4.190951585769653e-09,0.0,0.0,0.0,0.0002615898847579956,5.6372955441474915e-06,3.1813979148864746e-06,0.0,0.0,0.0
+23,23,0.4687343150126283,560.8399298018776,0.014657547231763601,0.01237749820575118,0.003936203196644783,0.0001838691532611847,0.0001552412286400795,0.003920321352779865,0.000182238407433033,0.000154225155711174,-0.0038209911435842514,0.0001984424889087677,0.00016180798411369324,0.00382099486887455,-0.00019842945039272308,-0.00016182847321033478,1.5878118574619293e-05,1.6177073121070862e-06,1.0365620255470276e-06,1.5878118574619293e-05,1.6177073121070862e-06,1.0365620255470276e-06,3.725290298461914e-09,1.30385160446167e-08,-2.0489096641540527e-08,0.0,0.0,0.0,0.0002774680033326149,7.255002856254578e-06,4.217959940433502e-06,0.0,0.0,0.0
+24,24,0.46876041911371336,560.8438616539352,0.014835720416158438,0.012527641374617815,0.0039318520575761795,0.00017817318439483643,0.00015014316886663437,0.003919683396816254,0.0001774495467543602,0.00014953874051570892,-0.003126208670437336,0.0004524495452642441,0.0003674151375889778,0.0031261928379535675,-0.00045248493552207947,-0.0003674216568470001,1.2184493243694305e-05,7.59027898311615e-07,6.109476089477539e-07,1.2184493243694305e-05,7.59027898311615e-07,6.109476089477539e-07,-1.5832483768463135e-08,-3.5390257835388184e-08,-6.51925802230835e-09,0.0,0.0,0.0,0.0002896524965763092,8.014030754566193e-06,4.828907549381256e-06,0.0,0.0,0.0

research/fine_surface_joint_20261014/blow_propagation.csv

@@ -0,0 +1,97 @@
+metric,time,signal,baseline,absolute,any_crossed,peak_crossed,x,y,q
+coarse_interface_u,1,0.0,0.0,0.0,False,False,3.5,3.5,
+coarse_interface_u,2,0.0,2.63417801721126e-09,2.63417801721126e-09,False,False,3.5,3.5,
+coarse_interface_u,3,0.0,2.63417801721126e-09,2.63417801721126e-09,False,False,3.5,3.5,
+coarse_interface_u,4,0.0,6.585443742795605e-08,6.585443742795605e-08,False,False,3.5,3.5,
+coarse_interface_u,5,0.0,1.2644051067663912e-07,1.2644051067663912e-07,False,False,3.5,3.5,
+coarse_interface_u,6,2.123413592043705e-07,1.4528626697542904e-07,3.5762762617979955e-07,False,False,20.5,12.5,
+coarse_interface_u,7,4.0664670353703905e-06,2.0116559817931723e-07,4.267265792606936e-06,True,True,20.5,13.5,
+coarse_interface_u,8,2.316397368189694e-05,1.5646213891164667e-07,2.3320343327342335e-05,True,True,20.5,13.5,
+coarse_interface_u,9,6.795742008554701e-05,1.5646213891164667e-07,6.81138583592495e-05,True,True,20.5,13.5,
+coarse_interface_u,10,0.00013453387391202865,9.750014426779573e-08,0.00013463070833560589,True,True,20.5,13.5,
+coarse_interface_u,11,0.00020315493961354394,1.1795114315203827e-07,0.00020326776624343072,True,True,20.5,13.5,
+coarse_interface_u,12,0.0002578325145358002,7.455233297611785e-08,0.00025790659921174714,True,True,20.5,14.5,
+coarse_interface_u,13,0.0002848355625376438,3.83541997932092e-08,0.0002848672209318115,True,True,20.5,14.5,
+coarse_interface_u,14,0.00028850325159438407,3.003423681142711e-08,0.00028847339892346693,True,True,20.5,15.5,
+coarse_interface_u,15,0.0002790426599299092,6.516592454722021e-08,0.00027900289954439403,True,True,20.5,16.5,
+coarse_interface_u,16,0.0002656231695763881,1.006517304071618e-07,0.0002656687325338991,True,True,20.5,17.5,
+coarse_interface_u,17,0.00025167224259872663,9.86322156278415e-08,0.00025171418857411254,True,True,20.5,18.5,
+coarse_interface_u,18,0.00023917435962541014,1.0286787296380317e-07,0.00023916330914968713,True,True,20.5,19.5,
+coarse_interface_u,19,0.0002264648202014007,7.783088195871973e-08,0.00022649832134267317,True,True,20.5,20.5,
+coarse_interface_u,20,0.00021450009842274482,8.503127640307697e-08,0.0002145262119900782,True,True,20.5,20.5,
+coarse_interface_u,21,0.00019565444290966713,7.893743237430962e-08,0.00019572665753668725,True,True,20.5,20.5,
+coarse_interface_u,22,0.00017530342242023255,5.2749351285234925e-08,0.0001753561669734725,True,True,20.5,20.5,
+coarse_interface_u,23,0.00016284198169591366,8.178685339035058e-08,0.00016288798599953632,True,True,20.5,14.5,
+coarse_interface_u,24,0.00016001299284349154,6.715860617082587e-08,0.00016005458983486885,True,True,20.5,14.5,
+coarse_bulk_u,1,0.0,0.0,0.0,False,False,0.5,0.5,
+coarse_bulk_u,2,0.0,0.0,0.0,False,False,0.5,0.5,
+coarse_bulk_u,3,0.0,0.0,0.0,False,False,0.5,0.5,
+coarse_bulk_u,4,0.0,0.0,0.0,False,False,0.5,0.5,
+coarse_bulk_u,5,0.0,0.0,0.0,False,False,0.5,0.5,
+coarse_bulk_u,6,0.0,0.0,0.0,False,False,0.5,0.5,
+coarse_bulk_u,7,9.685747920378016e-08,2.12341462371735e-07,3.0919894157551517e-07,False,False,21.5,12.5,
+coarse_bulk_u,8,1.885523449607647e-06,2.458690369633922e-07,2.131116250194691e-06,True,False,21.5,13.5,
+coarse_bulk_u,9,1.1801222962468464e-05,1.564621179284487e-07,1.1957591962850096e-05,True,True,21.5,13.5,
+coarse_bulk_u,10,3.7763148161723895e-05,1.0327184058071679e-07,3.786536052602384e-05,True,True,21.5,13.5,
+coarse_bulk_u,11,8.290997527773004e-05,4.214683516511236e-08,8.293984645156337e-05,True,True,21.5,13.5,
+coarse_bulk_u,12,0.00013975592467875463,5.890198697622995e-09,0.00013975397806857782,True,True,21.5,13.5,
+coarse_bulk_u,13,0.00019498935130707817,4.806920811870088e-08,0.00019495727755690072,True,True,21.5,14.5,
+coarse_bulk_u,14,0.00023699059195898703,3.215422633434082e-08,0.00023698211801486242,True,True,21.5,14.5,
+coarse_bulk_u,15,0.000255587117158192,3.434546877545681e-08,0.0002555629409290573,True,True,21.5,14.5,
+coarse_bulk_u,16,0.00025699080829703886,0.0,0.00025699080829703886,True,True,21.5,15.5,
+coarse_bulk_u,17,0.00024815159847585574,6.606481633104396e-08,0.0002482080995082901,True,True,21.5,16.5,
+coarse_bulk_u,18,0.00023639704637690832,6.929437569595666e-08,0.00023645799303108044,True,True,21.5,17.5,
+coarse_bulk_u,19,0.00022522644482484474,1.0390817551817351e-07,0.00022530812767909556,True,True,21.5,19.5,
+coarse_bulk_u,20,0.0002151574621150763,1.042082306083734e-07,0.00021524519922552202,True,True,22.5,18.5,
+coarse_bulk_u,21,0.00020618043430475382,9.442706670805767e-08,0.00020625960942046836,True,True,21.5,20.5,
+coarse_bulk_u,22,0.0001977039381507293,5.556802130737047e-08,0.00019775833634301496,True,True,22.5,20.5,
+coarse_bulk_u,23,0.00018973381549205,4.4703464263670685e-08,0.00018970107840731907,True,True,22.5,21.5,
+coarse_bulk_u,24,0.00018031585591623997,9.995996742145265e-08,0.0001802207328329628,True,True,22.5,22.5,
+fine_band_neq,1,0.0,3.000928300994632e-09,3.000928300994632e-09,False,False,4.25,4.25,
+fine_band_neq,2,0.0,4.501393077727123e-09,4.501393077727123e-09,False,False,4.25,4.25,
+fine_band_neq,3,0.0,2.069606169774474e-08,2.069606169774474e-08,False,False,4.25,4.25,
+fine_band_neq,4,0.0,4.1392115429639276e-09,4.1392115429639276e-09,False,False,4.25,4.25,
+fine_band_neq,5,0.0,4.1392115429639276e-09,4.1392115429639276e-09,False,False,4.25,4.25,
+fine_band_neq,6,3.8661114470928126e-07,9.934099098884985e-09,3.766770456103963e-07,True,True,19.75,13.25,
+fine_band_neq,7,2.0898831959437203e-06,9.934099098884985e-09,2.0799490968448353e-06,True,True,19.75,13.25,
+fine_band_neq,8,5.086951299526632e-06,9.934099098884985e-09,5.077017200427747e-06,True,True,19.75,13.75,
+fine_band_neq,9,7.3187303596400355e-06,1.1589783133203468e-08,7.307140576506832e-06,True,True,19.75,14.25,
+fine_band_neq,10,7.498180437826019e-06,9.106256526614231e-09,7.489074181299404e-06,True,True,19.75,15.25,
+fine_band_neq,11,6.85740365241605e-06,5.794905943989903e-09,6.86319855836004e-06,True,True,19.75,17.25,
+fine_band_neq,12,6.20376639004494e-06,6.622735776451449e-09,6.200455026694751e-06,True,True,19.75,18.25,
+fine_band_neq,13,5.366229072267803e-06,4.139212333997833e-09,5.369540443278531e-06,True,True,19.75,19.25,
+fine_band_neq,14,5.300103189165295e-06,4.967056432825245e-09,5.30507024559812e-06,True,True,19.75,19.75,
+fine_band_neq,15,4.0156351262532475e-06,4.553132745832578e-09,4.018946498263176e-06,True,True,19.75,19.75,
+fine_band_neq,16,3.7773208383384826e-06,6.622738135675377e-09,3.783943576474158e-06,True,True,19.75,16.75,
+fine_band_neq,17,3.59763095919563e-06,6.622736969941201e-09,3.598458797438031e-06,True,True,19.75,17.75,
+fine_band_neq,18,3.1864885083332517e-06,1.7384672978959514e-08,3.2038731813122112e-06,True,True,19.75,18.75,
+fine_band_neq,19,3.2079558324737967e-06,9.934106745546067e-09,3.2054722903795962e-06,True,True,19.75,19.75,
+fine_band_neq,20,3.2478981990546885e-06,8.278412177986638e-09,3.256176611232675e-06,True,True,19.75,19.75,
+fine_band_neq,21,2.8408409309954585e-06,1.1589792486832451e-08,2.83256250521724e-06,True,True,19.75,19.75,
+fine_band_neq,22,2.2599308021065134e-06,1.241763983306221e-09,2.2599308009962904e-06,True,True,19.75,19.75,
+fine_band_neq,23,1.7067130013148635e-06,2.0696062086322797e-09,1.7075408424993554e-06,True,True,19.75,19.75,
+fine_band_neq,24,1.7691307190870198e-06,7.864502313270627e-09,1.768302879068262e-06,True,True,4.25,8.25,
+transfer_neq,1,0.0,1.5004641487625925e-09,1.5004641487625925e-09,False,False,3.5,3.5,6
+transfer_neq,2,0.0,3.000928290586291e-09,3.000928290586291e-09,False,False,3.5,3.5,6
+transfer_neq,3,0.0,3.000928290586291e-09,3.000928290586291e-09,False,False,3.5,3.5,6
+transfer_neq,4,0.0,6.881438113781613e-09,6.881438113781613e-09,False,False,3.5,3.5,6
+transfer_neq,5,0.0,6.467520081987477e-09,6.467520081987477e-09,False,False,3.5,3.5,6
+transfer_neq,6,4.801482146599145e-08,1.7384695072397705e-08,3.063012639359375e-08,False,False,20.5,12.5,1
+transfer_neq,7,9.917490157301811e-07,1.4901174696935193e-08,9.76847841033246e-07,True,True,20.5,13.5,1
+transfer_neq,8,5.3319513640959215e-06,7.450589978308386e-09,5.324500774117613e-06,True,True,20.5,13.5,1
+transfer_neq,9,1.3926900000016396e-05,4.967061900673642e-09,1.3921932938115722e-05,True,True,20.5,13.5,1
+transfer_neq,10,2.2683459353481372e-05,7.0366557441969846e-09,2.269049600922557e-05,True,True,20.5,13.5,1
+transfer_neq,11,2.6366830318105827e-05,8.692339972804497e-09,2.6375522658078632e-05,True,True,20.5,14.5,1
+transfer_neq,12,2.307753771932375e-05,1.0761948318616099e-08,2.3088299667642365e-05,True,True,20.5,14.5,1
+transfer_neq,13,1.804053278801898e-05,6.6227364148296886e-09,1.804715552443381e-05,True,True,16.5,20.5,3
+transfer_neq,14,1.3273871487681776e-05,3.725288785783043e-09,1.327759677646756e-05,True,True,17.5,20.5,3
+transfer_neq,15,1.109810416584367e-05,1.7074248230553035e-09,1.1096396741020614e-05,True,True,20.5,20.5,5
+transfer_neq,16,1.0547037354428218e-05,3.777030622292843e-09,1.0550814385050511e-05,True,True,20.5,20.5,5
+transfer_neq,17,7.76073680465103e-06,1.5522043823879006e-09,7.762289009033418e-06,True,True,20.5,20.5,5
+transfer_neq,18,6.477044739522375e-06,2.4835230261199825e-09,6.479528262548495e-06,True,True,16.5,3.5,4
+transfer_neq,19,6.888961226400592e-06,4.553130164564045e-09,6.893514356565156e-06,True,True,16.5,3.5,4
+transfer_neq,20,8.081834403372845e-06,1.6556842147297246e-09,8.080178719158115e-06,True,True,3.5,15.5,2
+transfer_neq,21,9.19306995308955e-06,4.553133203799575e-09,9.19762308629335e-06,True,True,3.5,15.5,2
+transfer_neq,22,9.90222802181584e-06,1.241762831449833e-09,9.90346978464729e-06,True,True,3.5,15.5,2
+transfer_neq,23,9.820215213826589e-06,3.725291089495819e-09,9.823940504916084e-06,True,True,3.5,16.5,2
+transfer_neq,24,9.034586770997888e-06,6.208816516473092e-09,9.028377954481415e-06,True,True,3.5,17.5,2

research/fine_surface_joint_20261014/blow_summary.json

@@ -0,0 +1,170 @@
+{
+  "speed": 0.002,
+  "initial_leaf": [
+    560.7500041779131,
+    0.0,
+    0.0
+  ],
+  "final_leaf": [
+    560.8438616539352,
+    0.014835720416158438,
+    0.012527641374617815
+  ],
+  "raw_residual": [
+    0.0002896524965763092,
+    8.014030754566193e-06,
+    4.828907549381256e-06
+  ],
+  "exact_average_residual": [
+    0.00028958916664123535,
+    7.874332368373871e-06,
+    4.7245994210243225e-06
+  ],
+  "cumulative": {
+    "boundary": [
+      0.09356788685545325,
+      0.014827846083790064,
+      0.01252291677519679
+    ],
+    "fine_transfer": [
+      -0.0672332551330328,
+      -0.01191190630197525,
+      -0.010114157572388649
+    ],
+    "coarse_transfer": [
+      0.06723319180309772,
+      0.011911766603589058,
+      0.010114053264260292
+    ],
+    "rounding": [
+      0.0002896524965763092,
+      8.014030754566193e-06,
+      4.828907549381256e-06
+    ],
+    "average": [
+      -6.332993507385254e-08,
+      -1.3969838619232178e-07,
+      -1.043081283569336e-07
+    ]
+  },
+  "checks": {
+    "validity": true,
+    "geometry_unchanged": true,
+    "boundary_count": 48,
+    "collision_count": 72,
+    "local_collision": true,
+    "local_regime": true,
+    "bfl": true,
+    "transfer_rounding": true,
+    "interval_closure": true,
+    "cumulative_closure": true,
+    "propagation": true,
+    "drive_sign": true
+  },
+  "max_collision_ratio": 0.5696050037738337,
+  "max_collision_error": 1.5865499780609582e-07,
+  "max_bfl_error": 1.2725840020655355e-08,
+  "max_interval_closure": 0.0,
+  "drive_mass": 0.07436401406617413,
+  "propagation": {
+    "coarse_interface_u": {
+      "threshold": 1e-06,
+      "baseline_factor": 10,
+      "first_arrival": {
+        "time": 7,
+        "signal": 4.0664670353703905e-06,
+        "baseline": 2.0116559817931723e-07,
+        "absolute": 4.267265792606936e-06,
+        "x": 20.5,
+        "y": 13.5
+      },
+      "peak": {
+        "metric": "coarse_interface_u",
+        "time": 14,
+        "signal": 0.00028850325159438407,
+        "baseline": 3.003423681142711e-08,
+        "absolute": 0.00028847339892346693,
+        "any_crossed": true,
+        "peak_crossed": true,
+        "x": 20.5,
+        "y": 15.5
+      }
+    },
+    "coarse_bulk_u": {
+      "threshold": 1e-06,
+      "baseline_factor": 10,
+      "first_arrival": {
+        "time": 8,
+        "signal": 1.1069172403255332e-06,
+        "baseline": 1.005827957173589e-07,
+        "absolute": 1.2074577299858699e-06,
+        "x": 13.5,
+        "y": 21.5
+      },
+      "peak": {
+        "metric": "coarse_bulk_u",
+        "time": 16,
+        "signal": 0.00025699080829703886,
+        "baseline": 0.0,
+        "absolute": 0.00025699080829703886,
+        "any_crossed": true,
+        "peak_crossed": true,
+        "x": 21.5,
+        "y": 15.5
+      }
+    },
+    "fine_band_neq": {
+      "threshold": 1e-07,
+      "baseline_factor": 10,
+      "first_arrival": {
+        "time": 6,
+        "signal": 3.8661114470928126e-07,
+        "baseline": 9.934099098884985e-09,
+        "absolute": 3.766770456103963e-07,
+        "x": 19.75,
+        "y": 13.25
+      },
+      "peak": {
+        "metric": "fine_band_neq",
+        "time": 10,
+        "signal": 7.498180437826019e-06,
+        "baseline": 9.106256526614231e-09,
+        "absolute": 7.489074181299404e-06,
+        "any_crossed": true,
+        "peak_crossed": true,
+        "x": 19.75,
+        "y": 15.25
+      }
+    },
+    "transfer_neq": {
+      "threshold": 1e-07,
+      "baseline_factor": 10,
+      "first_arrival": {
+        "time": 7,
+        "signal": 9.917490157301811e-07,
+        "baseline": 1.4901174696935193e-08,
+        "absolute": 9.76847841033246e-07,
+        "q": 1,
+        "x": 20.5,
+        "y": 13.5
+      },
+      "peak": {
+        "metric": "transfer_neq",
+        "time": 11,
+        "signal": 2.6366830318105827e-05,
+        "baseline": 8.692339972804497e-09,
+        "absolute": 2.6375522658078632e-05,
+        "any_crossed": true,
+        "peak_crossed": true,
+        "q": 1,
+        "x": 20.5,
+        "y": 14.5
+      }
+    }
+  },
+  "raw_minus_zero": [
+    6.053410470485687e-05,
+    2.1085143089294434e-06,
+    9.126961231231689e-07
+  ]
+}

research/fine_surface_joint_20261014/command.txt

@@ -0,0 +1,2 @@
+/home/frank14f/anaconda3/envs/pycuda_3_10/bin/python /home/frank14f/CelerisLab/research/fine_surface_joint_20261014/runner.py
+Child command, explicit environment, fresh resource preflight and actual exit are stored in gpu_run.json.

research/fine_surface_joint_20261014/criteria.txt

@@ -0,0 +1,110 @@
+FROZEN BEFORE GPU — bounded fine-surface/interface validation, 2026-10-14
+
+Scope: exactly three independent trajectories speed=0,+.002,-.002, each24
+coarse/48fine steps, same physical time[0,24]. No other GPU tests, extensions,
+parameter sweeps or time extensions. Read-only hook instrumentation of normal
+production build, no audit macro and no stepping/formula changes.
+
+Geometry: periodic24x24 coarse domain; patch edge bounds[4,20)x[4,20);
+fine40x40 including4halo; origin edge(2,2); fine dx=dt=.5; coarse dx=dt=1.
+Circle physical center(12.25,12.25),radius2.15 => fine integer center(20,20),R4.3.
+Stationary solid; surface angle.7rad,half_width.85rad,C1 amplitude0,+/-.002.
+nu_coarse=.05,tau_coarse=.65,tau_fine=.8; unforcedD2Q9SRT,FP32,unshiftedDB.
+Initial rho1,u0,Q-major postcollision equilibrium, same FP32 initial populations.
+All initial sources and device omega are checked. Actual package path must be
+/home/frank14f/CelerisLab/src. The preserved old tests are not changed or run.
+
+Validity at every fine/coarse hop and publication:
+All valid fluid leaves finite, density(.9,1.1) and |u|<.05 in local collision
+oracle validity regime. Fine solids and outermost2halo after each fine hopNaN;
+inner ghost exactly stream-only including legitimate directionalNaNs.
+Published fine ghost/solid and coarse coveredNaN. Geometry and flags unchanged.
+
+Propagation definitions (strict >; horizons and masks never adjusted):
+- Fine band: fine active fluid nodes with any D2Q9 nonrest neighbor outside
+  geometric active patch, excluding solid boundaries.
+- Coarse interface: uncovered receiver cells of actual coalescence map.
+- Coarse bulk: ALL uncovered coarse fluid except that interface receiver set.
+- Transfer neq: actual replaced q component of the full reconstructed coarse
+  incoming vector minus FP64feq(rho,u) of that same incoming vector, BEFORE
+  coarse collision. Do not form full macros from partly valid ghost children.
+- Fine band neq: postcollision g minus FP64 equilibrium from its own macros.
+- Velocities: FP64 moments of published postcollision g / rho.
+- Physical coordinate coarse(I+.5,J+.5);fine(2+.5*(i+.5),2+.5*(j+.5)).
+  Interface transfer and publication sampled at integer physical t=1..24.
+  Boundary substeps at t=n-.5,n; no claim of sub-integer arrival resolution.
+- At each same point/q,time,phase compare driven and ZERO trajectory:
+  velocity norm difference>1e-6 AND >10*zero velocity norm;
+  neq absolute difference>1e-7 AND >10*abs(zero neq).
+  Fine-band criterion uses maxq at each node for BOTH signal/baseline; this
+  conservatively requires excess over the largest zero neq at that node.
+- For BOTH signs, all4 metrics (fine-band neq, actual-transfer neq,
+  coarse-interface velocity, coarse-bulk velocity) must cross by24 or FAIL.
+  Record each first qualified sample and global peak's time,physicallocation,
+  baseline,absolutevalue,signal; per-step maxima and qualifying flag retained.
+  These are aligned signal witnesses, not necessarily the same node/direction.
+  This tests startup distribution/macroscopic propagation, possibly acoustic;
+  not established jet advection, physical accuracy or shear-only transmission.
+
+Ledger (M maps9populations to mass,px,py; area weights coarse1,fine1/4):
+L_n=M(sum coarse leaves+1/4 sum fine fluid leaves), FP64 accumulation.
+Each of48fine hops individually captures pre-BFL and staged BFL populations.
+B_h=1/4 M(actual solid-to-fluid arrivals minus fluid-to-solid departures).
+F_h=1/4 M(actual ghost-to-fluid arrivals minus fluid-to-ghost departures).
+B_n=B_h1+B_h2; F_n=F_h1+F_h2. No using latest buffer as two-hop sum.
+C_n=M(actual reconstructed coarse incoming minus previous coarse leaves),
+including periodic native streaming, all replacement links and8grazingcorners.
+Coarse incoming constructed from independent physical midpoint map; compare
+all target/source slots to actual tables. avg32=.25*((a+b)+c+d) inFP32.
+RAW_n=L_n-L_(n-1)-B_n-F_n-C_n; cumulative raw uses same initial/final leaves.
+Report RAW and driven-minus-zero RAW FIRST, never call them corrected to zero.
+
+Source-based rounding decomposition and separate fixed checks:
+1. Each fine/coarse collision: reconstruct actual FP32 input using pure pull
+   and avg32 where applicable. Independently evaluate FP64 SRT at the actual
+   device FP32omega, verifying omega against tau and force=0.
+   Every q,node must obey |GPUout-SRT64(input)| <= 8*eps32*|input_q|.
+   This fixed local, near-rest acceptance bound reflects short FP32 rho/macro/
+   feq/FMA path and fast-math compilation; it is not a general roundoff theorem.
+   Report max absolute error and max normalized ratio, and fail if ratio>1.
+   Cround = weighted sum M(GPUout-input) measured LOCALLY, independently of L
+   or RAW. Record FP64 ideal moment defect and measured GPUout-ideal separately.
+   Arbitrary collision error cannot be excused solely by global closure.
+2. Transfer Tround=M(avg32-avg64exact), computed independently from actual4
+   children. Require each slot <=gamma3*sum|children|/4, u=eps32/2,
+   gamma3=3u/(1-3u); exact power-of-two scaling in this normal positive regime.
+   avg32 already in C_n, so DO NOT subtract Tround a second time.
+   Also report RAW_exact_average=RAW+Tround to expose this source explicitly.
+3. BFL local oracle abs error<=1e-7, actual active cells unchanged.
+4. |RAW_n-Cround_n|<=1e-10 componentwise per interval;
+   |sum RAW-sum Cround|<=1e-9 cumulative. These are FP64 bookkeeping bounds,
+   NOT a physical-conservation/accuracy test. No broad eps*whole-domain
+   accumulated budget used to label raw conservation as passing.
+5. Both driven cases' cumulative actual-minus-passive-oracle boundary mass
+   has same sign as specified normal speed. BFL passive evaluated on same
+   actual populations; not another trajectory and not a conservation fix.
+
+Saved data: pertrajectory24ledger rows,72local collision rows,48fine boundary
+rows; small compressed diagnostic signals for reproducible zero comparisons;
+no full-field populations. Per-step link_exchange_GPU also saved separately:
+latest fine Fx,Fy scaled1/4; torque scaled1/8 for physical lever length. These
+body momentum diagnostics differ from fluid mass exchange and are NOT thrust
+or exchange rate. A fine-hop fluid exchange rate is B_h/.5; the coarse interval
+rate is (B_h1+B_h2)/1, numerically equal to interval sum only because dt_c=1.
+Do not equate B_h2/latest with two-hop interval sum.
+
+No post-result tolerance/formula/window changes, retries or added steps to
+chase PASS. Preserve errors with real stdout/exit. Report precise unmet checks.
+Resource guards: fresh physicalGPU0UUID/apps/VRAM/RAM, onlyGPU0ifidle; no
+other task interference; 180secondwalltimeout; current available RAM reserve
+max(4GiB,10%),VRAM reserve max(512MiB,10%), own temporary+evidence<=2GB.
+Sample own process group RSS, no fixed address-space/RSS cap; remove only owned
+scratch. Every text artifact<=40000characters. Hash criteria/script/source at
+freeze then verify before launch; preserve all previous dirty/evidence.
+
+Reference trace: accepted local tests/test_fine_surface_gpu.py BFL/flux hooks;
+refinement.cu actual two fine hops and coalesce order; macro.cuh and
+collision_srt.cuh actual FP32 collision path; compiler_v2.py --use_fast_math.
+Previously accepted OpenLB defineU2D.hh74-79/offBoundaryPostProcessors2D.hh115-127
+remain BFL hit/stencil reference; no new CFD formula or borrowed code.
+Production change limited to one coordinate-frame documentation sentence.

research/fine_surface_joint_20261014/frozen.json

@@ -0,0 +1,105 @@
+{
+  "frozen_utc": "2026-10-14T05:55:03.221284+00:00",
+  "hashes": {
+    "src/CelerisLab.egg-info/PKG-INFO": "0b9a8a4e8d60bc531473688723ddef0aab02c7ccc4997e31c9b6a6c35011ca77",
+    "src/CelerisLab.egg-info/top_level.txt": "cd51958ca03afabbaa9618c60b8280e486f8cc0b0359b839e10f886e7c3948f8",
+    "src/CelerisLab.egg-info/dependency_links.txt": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
+    "src/CelerisLab.egg-info/requires.txt": "36e1404178e5ea590b2fc04e8ba4d748ec9a82e7693136ccf0dfd204fe265c04",
+    "src/CelerisLab.egg-info/SOURCES.txt": "f36b29c1b34c4bd6b2acc3ccdd21c24ee5077df7e2a20a652d9fae77eedb8e21",
+    "src/CelerisLab/simulation.py": "c9d903f53fe356d7af281bea07943de1a62494127fb69848d7053fd46f7dec3e",
+    "src/CelerisLab/config.py": "2f1bba7515f5bc08cb3a8d140bcafe7fa0689e01b3b06494697bb2956a71530e",
+    "src/CelerisLab/__init__.py": "21cc469bd6e970a1f9ff5970c8eea4602065e41fc881854759ee565ee55c10c6",
+    "src/CelerisLab/cuda/compiler_v2.py": "c4cc3ec4445c8d75e6a253dd87963877117a722bc73b9d4811806fc6045d08c1",
+    "src/CelerisLab/cuda/obs_layout.py": "5ffb2c3aeeaaaaeb64f2cd8febfbcf4ad9919e5414020ad753cfade0683b21c2",
+    "src/CelerisLab/cuda/context.py": "013dd4ec6d01d2fbd11afdfb103eac6a273bd9f798d663d761b851eeb27885e9",
+    "src/CelerisLab/cuda/__init__.py": "0d01dff9f0399c8baba822aab5ca0122a135f011008ed8a499ebd9f7e5b06aea",
+    "src/CelerisLab/lbm/refinement_stepper.py": "6aad7f66e4288e293b30b2f9712202447686f263fab41150f5d919cc64328d06",
+    "src/CelerisLab/lbm/field.py": "0e727eacc3706add4d8d15c418e9b631050871f831698d3ac689dd5f2c701b9b",
+    "src/CelerisLab/lbm/equilibrium.py": "2fb2f2bb7ff326d23abce80fc2a4c0907b17740ea3e29fe6ae079c5044783826",
+    "src/CelerisLab/lbm/descriptors.py": "c9f025dfc14da43b989047b84cc22bd05d5cc92c9ec695c1da68fdfb788e3f2b",
+    "src/CelerisLab/lbm/initializers.py": "dacf9586963e862d6d0a98ef1a066036be6f91e9d423720661d8ef2c1fb2df6a",
+    "src/CelerisLab/lbm/curved_links.py": "00d9c29d660b41190f32dd737b12f60e10ce4214b6c9a6ab2a63438813faa594",
+    "src/CelerisLab/lbm/stepper.py": "0dcb7cd7ae87e33e3dc67a38b6aa43042fbe673e37d9ad165342ee1d695933ce",
+    "src/CelerisLab/lbm/__init__.py": "7f60fb3aaae81501b510d08c2fedff44fcb05657260eb10b6f5cc91e7204306b",
+    "src/CelerisLab/lbm/refinement.py": "8935b070ec9e7020897919c15f43f7fa6293f02e2ff64a19a3e3d99bc444dbcc",
+    "src/CelerisLab/lbm/kernels/kernel_v2.cu": "c7bd3fb705b77261ba2441c52a24a7e6a7865c165cba088a1b75201c4d29c408",
+    "src/CelerisLab/lbm/kernels/refinement.cu": "129f3d91da93b4324f88a0da73a4da1e5390f72c14cce574ee63306712da9895",
+    "src/CelerisLab/lbm/kernels/config.h": "7d1124125e0b354558297934460e64c760fb68cdd7bf6d01a1238bb2eaab8c37",
+    "src/CelerisLab/lbm/kernels/kernel_v2.ptx": "a599ee30ae66800f4d4220eb79dfed35ff32991661260f01ea58023ef780f0ca",
+    "src/CelerisLab/lbm/kernels/operators/turbulence_smag.cuh": "ff7f000297ee0817e255ad9fcb6a13b647e3ddd5b206518d35f38d2895a9f501",
+    "src/CelerisLab/lbm/kernels/operators/collision_mrt.cuh": "aee444eb60c47a3fd518dca975d1af05425a0818a0ec6c3fb3f6150f60c2cb44",
+    "src/CelerisLab/lbm/kernels/operators/collision_trt.cuh": "9725b9840b9ad8b4ec7be61ff5d06d3151e86d1a87585c13f2fbf934d0d2c5f6",
+    "src/CelerisLab/lbm/kernels/operators/collision_srt.cuh": "6b7ff842f392c8f853d2d1a97cc69bfe50f21283f73e659404da07cf6c95f5e1",
+    "src/CelerisLab/lbm/kernels/operators/forcing_guo.cuh": "969a430c1af03f32e3bd0df95d805e64f56334717c44dd4ba208ba503062a24b",
+    "src/CelerisLab/lbm/kernels/operators/macro.cuh": "e27c1c410dc857be98da4596568e405eeaf88701d291ac0e398aa9cd23dee740",
+    "src/CelerisLab/lbm/kernels/operators/helpers.cuh": "0b3a4d95d7d19f5fec09e5423b8f4cc99f8a226b541967425967330da5a051ec",
+    "src/CelerisLab/lbm/kernels/core/precision.cuh": "849df14b4cce50af52399e4b8f3e997196f3ae5f1163f68e28df3e6b2507a8c4",
+    "src/CelerisLab/lbm/kernels/core/descriptors.cuh": "8440bc14857da9007982650f828a23608eec9f7cc4bf772e8c8dc1239cb45356",
+    "src/CelerisLab/lbm/kernels/core/obs.cuh": "b742b77c9f61e1f020fe9922c3838ae9d855e17b381154958b58f10a22938922",
+    "src/CelerisLab/lbm/kernels/core/params.cuh": "6e18bf730d936d940e3d85452f0714a2eaae31bf41002f9fd520ec5b372878dd",
+    "src/CelerisLab/lbm/kernels/core/flags.cuh": "0025705f24710330d9d9195f713879bfb650a85a3449baef0e196b831af104ab",
+    "src/CelerisLab/lbm/kernels/core/layout.cuh": "1fbd820021c89ac3efcde24145996cb0147769e607e498e61f308ed3e0b13706",
+    "src/CelerisLab/lbm/kernels/boundary/ibm_kernels.cuh": "e6909b547dc8d64cdd8a76a90660243a8f5fee535caa161b52b4dd8b7c29934b",
+    "src/CelerisLab/lbm/kernels/boundary/planar_velocity.cuh": "0b2f9e0bd483c199637e5672dc0ffc460bc383dd1804805befbeb4c5d8c708d1",
+    "src/CelerisLab/lbm/kernels/boundary/inlet_outlet.cuh": "de8b213a6da42c2e5e9f8966199fc66ea4541b85144a90f3f5dbad3c6ab63b97",
+    "src/CelerisLab/lbm/kernels/boundary/curved_boundary.cuh": "7bccf7e7091c012d7a3d4874a881d4d46699021faedd83d125933fbdaa562711",
+    "src/CelerisLab/lbm/kernels/boundary/bounce_back.cuh": "aba3748c564ed91b161d268ef8b737b7c7be96a823063d201f3da684dd845233",
+    "src/CelerisLab/lbm/kernels/boundary/esopull_curved_helpers.cuh": "b9b474bc4edaff05681c5443235472d04072d0d775fc0eb9c5967faef52b0258",
+    "src/CelerisLab/lbm/kernels/boundary/inlet/equilibrium.cuh": "f0964c811b2c41a5aaa1c6d99c490b06e850c634eb8749f1f05ef61f93c2de1d",
+    "src/CelerisLab/lbm/kernels/boundary/inlet/channel_stabilized.cuh": "efe077afcbb6b731256a987c2fd79a1dbc470c902f87070d60421ea6cb13d4e2",
+    "src/CelerisLab/lbm/kernels/boundary/inlet/common.cuh": "f3cec54c8873c65b3dca4375605d2c89a8727765884d3954c235242fdff9c6ba",
+    "src/CelerisLab/lbm/kernels/boundary/inlet/zou_he_local.cuh": "e73e66b853b1e4e0e30d8f4185d832aa414ce670a1813ce2b5459f2887f71f89",
+    "src/CelerisLab/lbm/kernels/boundary/inlet/regularized.cuh": "943d4a571818bacb89c70bccfaac202691121e3e385803ce6309123a0a03ddaf",
+    "src/CelerisLab/lbm/kernels/boundary/outlet/pressure_neq.cuh": "c8b2adc66d12fe602076ddc9693c5c208711fcaddb58aa9a31401a269f51c4c4",
+    "src/CelerisLab/lbm/kernels/streaming/esopull_single_buffer.cuh": "77ed4ab9a0ebc5ff62a91a7c39066ef395391ae36e9040a69fb2bd8b1626dc79",
+    "src/CelerisLab/lbm/kernels/streaming/pull_double_buffer.cuh": "b65d741ed78b7b62f99531ba0c0ce1936663d8dc9640e7d7d16c707f1baf6549",
+    "src/CelerisLab/lbm/kernels/streaming/esopull_semantic_helpers.cuh": "dd5a9091628b079efd97e53fd49e52d09dcee88529235db77a5648e02937af6e",
+    "src/CelerisLab/lbm/kernels/step/curved_double.cu": "bfa7a1df1e939020314d49755045f7a85fe4a19cc1c68dbe62653c66c5e7c2b3",
+    "src/CelerisLab/lbm/kernels/step/esopull_sync.cu": "c0ff3e72900c3ab89a05dd03684e96d3b740cf1672d565727fc2af165933d087",
+    "src/CelerisLab/lbm/kernels/step/init_flow.cu": "305be3bb12fc0d039acec1701baabcf0e8a35e683c49c34f2af8ca9867d2b29c",
+    "src/CelerisLab/lbm/kernels/step/esopull_macro.cu": "c73116020ca217ede1e4de27c8269c31f9d91e33433ac8252a21e9b14187c50f",
+    "src/CelerisLab/lbm/kernels/step/aux_kernels.cu": "578a5b20a157241ee678547059abb1372dd5a589ad06bb2c15b987eb01ca1013",
+    "src/CelerisLab/lbm/kernels/step/one_step_esopull.cu": "aa223b2744ae6c9125673df311a96ce588032c1ba58bebb11fd33ecb990f8ed4",
+    "src/CelerisLab/lbm/kernels/step/one_step_double.cu": "f9f8242b38e8e0cf8425b75e2b0215bc15363c62eaa0fb43c761b8e0931bfdc9",
+    "src/CelerisLab/lbm/kernels/config/config_physics.h": "26df33c2960ba36f3283e19b55b4ea92e50e4efda705f9ebfbf3f875a4092c59",
+    "src/CelerisLab/lbm/kernels/config/config_method.h": "3db4e16ef2c6b22349d04e6aa8ab04bdfe0eb784f9f3a98277e15dbed1835d81",
+    "src/CelerisLab/lbm/kernels/config/config_grid.h": "8be3a7cf74ba30d7fd3074fed79e63dbda7311c4d03b454ea641bf298ffeaa8d",
+    "src/CelerisLab/lbm/kernels/config/config_objects.h": "dbb93c063586da278c15d95e23f84c12e728f4f5f1bbc3980fe9cedaa6fff90e",
+    "src/CelerisLab/lbm/kernels/config/config_obs.h": "c11e2249359145b5c4cbaaf0487506fa77c1f4b82c7c169ddc574aa0babcd727",
+    "src/CelerisLab/common/checkpoint.py": "b2f960aecd5ac27a3a7130b809ffad4709c44d522edef0359ab952654625410b",
+    "src/CelerisLab/common/_types.py": "aad2ff1a9033d4fd68783ad7123afb47201ddc58785cb6dc0246947037072a5f",
+    "src/CelerisLab/common/pathline.py": "a1b6efcc0a076d0f1dc8d49a595779426d7d5626b00072a59bac710ff02ad046",
+    "src/CelerisLab/common/__init__.py": "d4dbde78bc97fccc9eabac9abae8f0f15c112c10ff8e9b45bd9401d4723df1ef",
+    "src/CelerisLab/common/preprocess.py": "7fc78a08857cf8e98519500b094a1d896af189b6b15658ff9b388ed51bed4515",
+    "src/CelerisLab/common/render.py": "0e055476257eb2bcd11e733766e52195de02f8fad228f570a3511a7c831bdc29",
+    "src/CelerisLab/common/streakline/_render.py": "236cd637414ee318c4d66f9aed32110d8dc42a100d65fde06172f7cd0ba62c65",
+    "src/CelerisLab/common/streakline/_integrate.py": "3fbd4368b2c8d0e7fda40dc65aac5df02b085008b4c68acd83cb7ae45d33a13b",
+    "src/CelerisLab/common/streakline/_streakline.py": "1a3e08daa706b5f83cdeb337e9a945a36ddf7583c40af1d0bb9d825ac954df37",
+    "src/CelerisLab/common/streakline/__init__.py": "13ff1cfa416fdd721a08a659e76b5a5a99b8d3201add10a83b7b0bc654bc1eec",
+    "src/CelerisLab/common/streakline/_config.py": "a9185ef68e9c7b5d5a1dc0b04a28341e2ad91d13c145a7c106636a878cf0a605",
+    "src/CelerisLab/configs/config_lbm.json": "17e4311f1f250c6ece59177a8b6ff856b69a016c7c10267e774b030a0a390865",
+    "src/CelerisLab/configs/CONFIG.md": "41cafdbe525366c08aa9d0416ea026ccf0026ba7123b8a9b65f968a80d928e3a",
+    "src/CelerisLab/configs/config_lbm_three_cylinder_triangle.json": "eeb8e7149dbe4aa6b3a9562802735aa950750dfbe2d972a0727e788573afa817",
+    "src/CelerisLab/configs/config_lbm_flume_trt_regularized.json": "f4bba8e6a4339fc3c4eb14f6e2f57c4b22993c73703c773d853edfbe34736e56",
+    "src/CelerisLab/configs/config_body.json": "055f261f0828ca1d4f2bb694bd15b72bbcabe31d552326208f28e37f761adab1",
+    "src/CelerisLab/configs/config_lbm_flume_mrt_zouhe.json": "8f593321db05a563a42931603a228d61cbcba06dfbe113262d5cd0ad93c0fe79",
+    "src/CelerisLab/body/objects.py": "d1cf7054cc8379a83c39acc66a7c88ae62fa004f110bb0c1def2ee57137401c5",
+    "src/CelerisLab/body/action_smoother.py": "b1a23ee6bbd4850b172cb8738c5c3546ee465a54189e6af9d8044f023d4687dc",
+    "src/CelerisLab/body/registry.py": "fbb7327780adbdc6da15ebdb799980daf32df22ee974af0893d7409f177bbb68",
+    "src/CelerisLab/body/manager.py": "6a40be708c71ef6f3b5f5f0aa9c92cfafc51f2ec2a958f99656cccb850986c16",
+    "src/CelerisLab/body/ddf_patch.py": "60fcfb7441e73bf290bcff41ca3a83da3e7ddad765d7247464e8f02e3043b4e2",
+    "src/CelerisLab/body/sync_plan.py": "a73ac9ee361b2120d0b7bbebeaa2ccbf924ba27bd95d4dd4b383c10a39b2a409",
+    "src/CelerisLab/body/__init__.py": "91d1155080b3ade83d13c84c39693046df122e4bed5ef583de2df1f9453c1b76",
+    "src/CelerisLab/body/preprocess/flag_overlay.py": "831fc9e9736b758847759a085ff133eb49ec91318ace4fda76f85960138ee300",
+    "src/CelerisLab/body/preprocess/__init__.py": "dfd9d58bc07f626ab23a70053e31b88a6d9165d2e4c76a4e9f48abe674d3d2ec",
+    "src/CelerisLab/body/geometry/base.py": "cceca14361ca2f34d34a3e43730e1a79b8ca81be00f0dd62e884db32b479419f",
+    "src/CelerisLab/body/geometry/__init__.py": "ada88980ab672959aca9aa3a4c4aade3219524b2ab68110cd2a2f41e3e0ca90a",
+    "src/CelerisLab/body/geometry/circle.py": "7605ca7c21103f1d801ac73ab8dd18dffbdac425b2dee7b8858b283628a9e436",
+    "src/CelerisLab/body/coupling/soa_packer.py": "8ec26fd55ef74801bbd5ab6bd3d0a7dabc750cbd498aaac2ca4c61a0108ad3c9",
+    "src/CelerisLab/body/coupling/__init__.py": "c931f7eb318d48408c3e2febcc6917c88c8dcc1697cbf4329b1f340d94c35763",
+    "tests/validation/multigrid/test_fine_surface_gpu.py": "d45ca48fc4e77d021fcc5461329b094ae11b257c036bb23634d326fbbedb7700",
+    "research/fine_surface_joint_20261014/validate.py": "346f1223daa7ce1fb376be5e921fec5ad77c3a10992806d54ececdf199e7c3ea",
+    "research/fine_surface_joint_20261014/runner.py": "2e52a6fd8306c07415c82d9275e17d58e0597ebd9f1f45b3be81dcdb005d4737",
+    "research/fine_surface_joint_20261014/criteria.txt": "d80d6f1218b3db449ea9115fa701b9173bc866929e634e2a3b17278b65f0c256"
+  }
+}

research/fine_surface_joint_20261014/gpu_run.json

@@ -0,0 +1,39 @@
+{
+  "start_utc": "2026-10-14T05:55:16.773509+00:00",
+  "command": [
+    "/home/frank14f/anaconda3/envs/pycuda_3_10/bin/python",
+    "/home/frank14f/CelerisLab/research/fine_surface_joint_20261014/validate.py"
+  ],
+  "cwd": "/home/frank14f/CelerisLab",
+  "physical_gpu_uuid": "GPU-e8853ae7-a302-6a17-bcfa-aa767e9ed20c",
+  "note": "Sampled guards, not an OS hard isolation; no fixed RSS/AS cap.",
+  "preflight_gpu": "0, GPU-e8853ae7-a302-6a17-bcfa-aa767e9ed20c, Tesla V100-SXM2-16GB, 5, 16140, 0\n1, GPU-f1c9fd5a-e917-56e0-21fb-24035ba44a36, Tesla V100-SXM2-16GB, 5, 16140, 0\n2, GPU-b8c11c01-c91f-aa0b-abf6-dad35085cc76, Tesla V100-SXM2-16GB, 5, 16140, 0\n3, GPU-8b71b032-1b75-2891-935c-ce106a53034a, Tesla V100-SXM2-16GB, 5, 16140, 0\n",
+  "preflight_apps": "",
+  "preflight_ram_bytes": 64120958976,
+  "limits": {
+    "wall_seconds": 180,
+    "temp_bytes": 2000000000,
+    "ram_reserve_bytes": 6412095897,
+    "vram_reserve_MiB": 1614
+  },
+  "env": {
+    "PYTHONPATH": "/home/frank14f/CelerisLab/src",
+    "PYTHONNOUSERSITE": "1",
+    "PYTHONDONTWRITEBYTECODE": "1",
+    "OPENBLAS_NUM_THREADS": "1",
+    "CUDA_VISIBLE_DEVICES": "GPU-e8853ae7-a302-6a17-bcfa-aa767e9ed20c",
+    "CUDA_CACHE_DISABLE": "1",
+    "TMPDIR": "/tmp/celeris-joint24-5efo3_mj"
+  },
+  "frozen_sha256": "68fdac18ac1b4371c2a7856456c7cc5b6f360c5dde52d282c44a68237d74028d",
+  "peak_group_rss_bytes": 297836544,
+  "peak_temp_bytes": 2081386,
+  "min_ram_bytes": 63740788736,
+  "min_vram_free_MiB": 15826,
+  "termination_reason": null,
+  "postflight_gpu": "0, GPU-e8853ae7-a302-6a17-bcfa-aa767e9ed20c, Tesla V100-SXM2-16GB, 5, 16140, 0\n1, GPU-f1c9fd5a-e917-56e0-21fb-24035ba44a36, Tesla V100-SXM2-16GB, 5, 16140, 0\n2, GPU-b8c11c01-c91f-aa0b-abf6-dad35085cc76, Tesla V100-SXM2-16GB, 5, 16140, 0\n3, GPU-8b71b032-1b75-2891-935c-ce106a53034a, Tesla V100-SXM2-16GB, 5, 16140, 0\n",
+  "postflight_apps": "",
+  "exit_code": 0,
+  "elapsed_seconds": 9.595732301007956,
+  "scratch_removed": true
+}

research/fine_surface_joint_20261014/incremental.diff

@@ -0,0 +1,10 @@
+--- a/src/CelerisLab/lbm/refinement_stepper.py
++++ b/src/CelerisLab/lbm/refinement_stepper.py
+@@ -39,6 +39,7 @@
+     velocities are in coarse lattice units (dx=dt=1). Independent local copies
+     are projected at fine cell centers. Their complete stencil must be active
+     and disjoint from the actual two-hop transfer footprint.
++    These use the edge/cell-center frame (coarse centers I+.5), whereas ordinary Simulation objects use the integer-node frame.
+ 
+     ``initialize(coarse_g, fine_g)`` accepts physical Q-major (9,ny,nx) arrays
+     already in postcollision phase. It does not collide or build channel flags.

research/fine_surface_joint_20261014/integrity.json

@@ -0,0 +1,38 @@
+{
+  "baseline_files": 610,
+  "changed_previous_files": [
+    "src/CelerisLab/lbm/refinement_stepper.py"
+  ],
+  "incremental_lines_added": 1,
+  "incremental_lines_deleted": 0,
+  "frozen_hashes_unchanged": true,
+  "frozen_file_count": 100,
+  "rows": {
+    "zero": {
+      "ledger": 24,
+      "collisions": 72,
+      "boundary": 48
+    },
+    "blow": {
+      "ledger": 24,
+      "collisions": 72,
+      "boundary": 48
+    },
+    "suction": {
+      "ledger": 24,
+      "collisions": 72,
+      "boundary": 48
+    }
+  },
+  "regions": {
+    "coarse_interface": 68,
+    "coarse_bulk": 252,
+    "fine_band": 124,
+    "transfer_slots": 196
+  },
+  "all_text_files_within_40000_chars": true,
+  "scratch_removed": true,
+  "temporary_before_copy_removed": true,
+  "review_complete": true,
+  "total_evidence_bytes_before_manifest": 936489
+}

research/fine_surface_joint_20261014/manifest.json

@@ -0,0 +1,138 @@
+{
+  "baseline_00.json": {
+    "bytes": 21302,
+    "sha256": "24564bba03c0d0563a04a8ef41c2c66f272c2e23d3992694e032c436b3272985"
+  },
+  "baseline_01.json": {
+    "bytes": 26191,
+    "sha256": "1aa54afbe77b4db806ed852aa9166c6b098de8271318f33c1aec9dbca73fee00"
+  },
+  "baseline_02.json": {
+    "bytes": 22440,
+    "sha256": "4ad20625dd7be154983bd5e834b7d9c22a9bf103fbb821198d081efab9723229"
+  },
+  "baseline_03.json": {
+    "bytes": 8584,
+    "sha256": "c0296688fdb2e19634d4c82b389d3bfb5cc1c442e465fc35139cc5b1d6d47944"
+  },
+  "blow_boundary.csv": {
+    "bytes": 12536,
+    "sha256": "136c42ab6daab369f813681a55546da96b9280d918178a4b7ff03d0fd5847c72"
+  },
+  "blow_collisions.csv": {
+    "bytes": 19145,
+    "sha256": "229245407e1eb436867a6110b7b7487effeaa8dd73540d05f25288c01f5e8670"
+  },
+  "blow_ledger.csv": {
+    "bytes": 15977,
+    "sha256": "89d9a88147b9c609d15e06c98f279daf27060cc914acd53910e74e2b46108977"
+  },
+  "blow_propagation.csv": {
+    "bytes": 9714,
+    "sha256": "4c452e4bffaec594f8b9e17dc992a9106541d5b0d283e0a2725cdc040808b257"
+  },
+  "blow_signals.npz": {
+    "bytes": 221114,
+    "sha256": "a78440514365bdb6c2af5424f729d856446adf14c2728da471606e24e5f8ce9a"
+  },
+  "blow_summary.json": {
+    "bytes": 4113,
+    "sha256": "e5b574ba02848b88487bfaa64e934b4d07c598658f4012a71f014ea6d883c351"
+  },
+  "command.txt": {
+    "bytes": 232,
+    "sha256": "99d80134c654c9eca51ba107b49bc077dfe83c7ac6f40b85378ec0b308c260a7"
+  },
+  "criteria.txt": {
+    "bytes": 7480,
+    "sha256": "d80d6f1218b3db449ea9115fa701b9173bc866929e634e2a3b17278b65f0c256"
+  },
+  "frozen.json": {
+    "bytes": 11972,
+    "sha256": "68fdac18ac1b4371c2a7856456c7cc5b6f360c5dde52d282c44a68237d74028d"
+  },
+  "gpu_run.json": {
+    "bytes": 1955,
+    "sha256": "ff90cf37cf7e198cea3a26bc00a2fd905b3eb07e6dbc5028ee58c299977b8de7"
+  },
+  "incremental.diff": {
+    "bytes": 625,
+    "sha256": "b5e3f04adf67ccc9ac79dd2e33d7871ce3247e168783df355b1224bd2c8a0941"
+  },
+  "integrity.json": {
+    "bytes": 826,
+    "sha256": "1fb4e8332dee509528b2d18edcbf733d2d8e632c9635039def62c662b7b031e0"
+  },
+  "regions.json": {
+    "bytes": 27525,
+    "sha256": "f31c6d6723a10df5dbb14bff7758bdf321b1cc5a395cf0b6a169ff5f44d3c54d"
+  },
+  "report.txt": {
+    "bytes": 8207,
+    "sha256": "8a5643409f9d1796406d190fa533a2a0058acf2b3765d83606311ee385504fae"
+  },
+  "result.json": {
+    "bytes": 11442,
+    "sha256": "846fb625d15270a906cbcfd65df4202768929ff391507856a0fe31981d611cba"
+  },
+  "review.txt": {
+    "bytes": 2117,
+    "sha256": "d2e40a8eabe9b88e514a79eff6374a3abfe5f4db2e9a98f9a483dcbaa6464a4c"
+  },
+  "runner.py": {
+    "bytes": 5847,
+    "sha256": "2e52a6fd8306c07415c82d9275e17d58e0597ebd9f1f45b3be81dcdb005d4737"
+  },
+  "stdout.txt": {
+    "bytes": 19940,
+    "sha256": "81c8de698c6e141e734545df8dee063edc51829f339afb2bd15b1efa21482deb"
+  },
+  "suction_boundary.csv": {
+    "bytes": 12505,
+    "sha256": "7a92dd8bc5e94a0262d7b06e01c03a2c2b3f808bc611e4e27820671a5bda6d32"
+  },
+  "suction_collisions.csv": {
+    "bytes": 19173,
+    "sha256": "46d0dfaad18cb6bd988169c5a91f15bc6e7ba77e8444965361b8393fd7f86c9b"
+  },
+  "suction_ledger.csv": {
+    "bytes": 16208,
+    "sha256": "12c8118a4ef769565e1f89476d0860dc4b4f96bc1bcad995ed083eaa53e36085"
+  },
+  "suction_propagation.csv": {
+    "bytes": 9720,
+    "sha256": "2991ef8dbad2fa52b8382e24974782ea533ee233ad1833e1e3bdd78c3fdd4992"
+  },
+  "suction_signals.npz": {
+    "bytes": 220058,
+    "sha256": "44f593b3c0129b575fae00ea1bc0fdb14961a4bdf9491c7db0325acc4c682f8c"
+  },
+  "suction_summary.json": {
+    "bytes": 4126,
+    "sha256": "e2aa6da27b04a5432508c5ed440179a5075dedbd52c38478596f3248f3e8b53b"
+  },
+  "validate.py": {
+    "bytes": 19576,
+    "sha256": "346f1223daa7ce1fb376be5e921fec5ad77c3a10992806d54ececdf199e7c3ea"
+  },
+  "zero_boundary.csv": {
+    "bytes": 11491,
+    "sha256": "f9785fcb1bb68064675beb6240a78e23c34f5123219eb91bbe748211c5cb1f38"
+  },
+  "zero_collisions.csv": {
+    "bytes": 18915,
+    "sha256": "2496ccaeb9a1cf3cfed81ba412d9017b7eb9e375176551abe41572b9f09931cc"
+  },
+  "zero_ledger.csv": {
+    "bytes": 16051,
+    "sha256": "b86d46933a0193dcd7e681982406cc91f89e56d55ac57be0afa514b492e827db"
+  },
+  "zero_signals.npz": {
+    "bytes": 127958,
+    "sha256": "71a833a056f7370dc929d9c0d321dc0f83b2fd8b2894d14403f2f16d372297a0"
+  },
+  "zero_summary.json": {
+    "bytes": 1508,
+    "sha256": "facbe3d1568f80643ed7af3ebe93f076f9a3e0f7b1b90cb33e4b2fb27f6c25e9"
+  }
+}

research/fine_surface_joint_20261014/report.txt

@@ -0,0 +1,110 @@
+2026-10-14 — fine surface + fixed patch：24粗步短联合验证
+
+结果：仅运行0、+.002、-.002三条同时间轨迹，各24coarse/48fine、物理时间24；
+唯一GPU批次exit0，全部预设局部算子、有效性、记账与传播检查通过，已停止。
+这不是严格守恒、物理精度、成熟喷流、空间收敛或长期稳定性认证。
+
+先报告未修正累计收支残差（质量、Px、Py；实际FP32 transfer账本）：
+  零驱动   +2.2911839187e-4  +5.9055164456e-6  +3.9162114263e-6
+  正吹     +2.8965249658e-4  +8.0140307546e-6  +4.8289075494e-6
+  负吸     +3.3393828198e-4  +2.1932646632e-7  +2.6496127248e-7
+相对零驱动的原始残差差值（不是修正后的守恒量）：
+  正吹     +6.0534104705e-5  +2.1085143089e-6  +9.1269612312e-7
+  负吸     +1.0481989011e-4  -5.6861899793e-6  -3.6512501538e-6
+零驱动本身有FP32累计漂移，不能把bitwise非零视为传播，也不能把舍入后闭合0
+说成原始残差为0。正吹/负吸的原始质量残差分别约占实际边界净质量交换的
+0.310%/0.357%；扣同时间零驱动基线后的差值分别约占0.0647%/0.1122%。
+这里只报告比例，没有事后以这些比例新增通过判据。
+
+传播证据（两驱动同样的首次达标时间和物理坐标；时间以整数粗步采样）：
+量                         首次t/位置                  正吹差值       负吸差值
+fine接口内侧post-G neq     6 /(19.75,13.25)           3.86611e-7    3.73349e-7
+真实transfer arrival neq   7 /(20.5,13.5),q1          9.91749e-7    1.00666e-6
+coarse接收圈post-G速度     7 /(20.5,13.5)             4.06647e-6    4.09198e-6
+接收圈之外coarse bulk速度  8 /(13.5,21.5)             1.10692e-6    1.01799e-6
+对应零驱动基线依次9.93410e-9、1.49012e-8、2.01166e-7、1.00583e-7。
+预先固定速度差>1e-6，neq差>1e-7，且均>同位置/时间/阶段基线10倍；两符号均满足。
+负吸bulk首次点的绝对速度9.17512e-7，差值1.01799e-6；判据本来就针对差值，
+未把它改写为绝对速度超过1e-6。随后峰值处绝对速度和差值均明显非零。
+
+峰值（相对零驱动，全部位于预设采样窗口内）：
+量                         峰值t/位置                  正吹            负吸
+fine接口内侧neq           10 /(19.75,15.25)          7.49818e-6     7.38603e-6
+真实transfer neq          11 /(20.5,14.5),q1         2.63668e-5     2.62411e-5
+coarse接收圈速度          14 /(20.5,15.5)            2.88503e-4     2.87819e-4
+接收圈之外bulk速度        16 /(21.5,15.5)            2.56991e-4     2.56441e-4
+这里证明喷吸启动扰动实际到达并通过接口，可能含压力/声学传播。不同指标的
+首次点是各自固定区域的检测见证，不冒称同一个流体质点的轨迹。24粗步内不能
+判断成熟射流或纯剪切扰动的跨接口精度。区域及实际传递方向保存在regions.json；
+每步指标、first/peak、同点基线和绝对值均有CSV/JSON；小型NPZ供离线复核。
+
+逐步收支与舍入：
+每条轨迹24行复合叶节点质量/动量账本；48行真实fine边界交换（每区间2行、
+每次面积权重1/4）；72行局部collision诊断（每区间fine2次、coarse1次）。
+实际fluid boundary、fine transfer和coarse transfer分别统计，未用最新一帧
+link_exchange代替两子步累计。最新body impulse另列，仅为该子步的动量交换；
+fine rate=该子步交换/.5，coarse rate=两子步之和/1，不冒充总推力。
+
+24区间累计（质量、Px、Py）：
+正吹B = (+.0935678868555, +.0148278460838, +.0125229167752)
+正吹F = (-.0672332551330, -.0119119063020, -.0101141575724)
+正吹C = (+.0672331918031, +.0119117666036, +.0101140532643)
+负吸B = (-.0934597565793, -.0147664458491, -.0124674369581)
+负吸F = (+.0670307464898, +.0118954917416, +.0100988540798)
+负吸C = (-.0670307874680, -.0118956044316, -.0100990422070)
+其中B为solid边界净交换，F为fine叶/halo交换，C为coarse真实incoming收支。
+正吹/负吸同实际population上相对passive BFL oracle的累计附加质量分别
++.0743640140662、-.0742686590511，符号正确；这不是额外轨迹或守恒修正。
+
+每个碰撞逐q/节点独立FP64 SRT参考：使用实际读回FP32omega并核对tau/force；
+固定近静止判据|GPUout-SRT64(actual_input)|<=8*eps32*|input_q|。
+三轨迹最大归一化误差分别.463942、.569605、.528511，全部<1；
+最大绝对误差分别1.29143e-7、1.58655e-7、1.64771e-7。
+它是本例的固定局部容差，考虑实际fast-math/FMA路径，不是一般舍入定理。
+每次局部M(output-input)独立测得的累计漂移与原始账本残差吻合；逐区间和累计
+剩余闭合误差在FP64计账中恰为0，满足预设1e-10/1e-9。这个零是记账分解验证，
+不是离散方案的精确物理守恒结论，也未以全域大容差掩盖raw残差。
+
+coalescence的顺序FP32四子格平均与精确FP64均值之差独立由实际children计算，
+所有槽通过固定gamma3局部界限；实际transfer账本已经包含它，没有重复扣除。
+累计平均舍入（质量、Px、Py）：
+  零驱动 (-5.7183206081e-7, -1.8812716007e-7, -2.8312206268e-7)
+  正吹   (-6.3329935074e-8, -1.3969838619e-7, -1.0430812836e-7)
+  负吸   (-4.0978193283e-8, -1.1269003153e-7, -1.8812716007e-7)
+采用精确平均记账的原始残差亦保存在各summary的exact_average_residual中。
+BFL最大局部误差三轨迹均<=1.27259e-8，低于冻结1e-7。
+未从末态差反推任何收支项，也未看到结果后改公式、阈值、窗口或步数。
+
+有效性：每细步active流体有限、solid与最外2层halo为NaN；inner ghost按真实
+逐方向stream-only（包含合法NaN）核对。每粗步发布fine全部非叶和coarse covered
+均NaN；leaf finite、局部密度/速度范围达标；几何/flags/源对象不变。
+coarse320叶节点，其中68接口接收节点、252外部bulk；fine963流体叶，
+124接口内侧节点；实际coalescence196方向槽，包括原有8个grazing-corner槽。
+
+执行和范围：
+冻结2026-10-14 05:55:03 UTC，GPU启动05:55:16 UTC，实际耗时9.596s，exit0。
+GPU0 UUID GPU-e8853ae7-a302-6a17-bcfa-aa767e9ed20c，预检5MiB/util0/无计算进程。
+包来源严格为/home/frank14f/CelerisLab/src；现有pycuda_3_10环境；未安装依赖。
+峰值进程组RSS297836544bytes，最少可用RAM63740788736bytes，最少可用VRAM
+15826MiB，本轮临时与证据采样峰值2081386bytes，远小于2GB；无保护触发。
+采样保护不是OS硬隔离；独占scratch已删除，GPU退出后5MiB且无计算进程。
+
+生产增量只有refinement_stepper.py一行文档，+1/-0，明确fine_objects采用
+edge/cell-center坐标（coarse中心I+.5），普通Simulation使用integer-node坐标。
+完整610文件基线比对仅这一文件改变；既有dirty、旧审查和运行证据全部保留；
+100个冻结脚本/源码哈希复核一致；不改生产公式、helper、网格或推进时序；
+无提交/推送、无DynamisLab修改、无额外GPU矩阵。默认旧测试未改未重跑。
+
+证据导航：
+criteria.txt + frozen.json：运行前完整判据、时间戳、SHA256；不可事后改写。
+command.txt + runner.py + gpu_run.json + stdout.txt：确切命令、环境、预检、退出。
+validate.py：本次独立验证脚本，复用已接受test_fine_surface_gpu.py的只读钩子。
+zero/blow/suction_{ledger,collisions,boundary}.csv：必要逐步量与分解。
+blow/suction_propagation.csv、*_summary.json、*_signals.npz：信号与对齐基线。
+result.json：固定判据结果；regions.json：坐标/方向；integrity.json：范围完整性。
+incremental.diff：唯一生产增量；baseline_*.json：保留旧文件的哈希基线。
+代码/数值只读agent交叉复核见review.txt。所有最终文本每份<=40000字符。
+
+限制：以上仅短时离散联合一致性和启动扰动跨接口证据。原始FP32漂移仍存在，
+未在本轮修正；不证明物理精度、空间收敛、稳态、长时稳定、性能或通用AMR。
+此步已完成并停止，没有延伸B墙穿接口候选、checkpoint或其他特性。

research/fine_surface_joint_20261014/result.json

@@ -0,0 +1,412 @@
+{
+  "passed": true,
+  "runs": {
+    "zero": {
+      "speed": 0.0,
+      "initial_leaf": [
+        560.7500041779131,
+        0.0,
+        0.0
+      ],
+      "final_leaf": [
+        560.7502328557894,
+        4.124827682971954e-06,
+        3.1795352697372437e-06
+      ],
+      "raw_residual": [
+        0.00022911839187145233,
+        5.905516445636749e-06,
+        3.916211426258087e-06
+      ],
+      "exact_average_residual": [
+        0.00022854655981063843,
+        5.717389285564423e-06,
+        3.6330893635749817e-06
+      ],
+      "cumulative": {
+        "boundary": [
+          1.3131648302078247e-07,
+          -1.5925616025924683e-06,
+          -4.5355409383773804e-07
+        ],
+        "fine_transfer": [
+          -9.47713851928711e-05,
+          3.1068921089172363e-06,
+          -2.084299921989441e-06
+        ],
+        "coarse_transfer": [
+          9.419955313205719e-05,
+          -3.295019268989563e-06,
+          1.8011778593063354e-06
+        ],
+        "rounding": [
+          0.00022911839187145233,
+          5.905516445636749e-06,
+          3.916211426258087e-06
+        ],
+        "average": [
+          -5.718320608139038e-07,
+          -1.8812716007232666e-07,
+          -2.8312206268310547e-07
+        ]
+      },
+      "checks": {
+        "validity": true,
+        "geometry_unchanged": true,
+        "boundary_count": 48,
+        "collision_count": 72,
+        "local_collision": true,
+        "local_regime": true,
+        "bfl": true,
+        "transfer_rounding": true,
+        "interval_closure": true,
+        "cumulative_closure": true
+      },
+      "max_collision_ratio": 0.46394191845799526,
+      "max_collision_error": 1.2914339875269576e-07,
+      "max_bfl_error": 1.0332863675799331e-08,
+      "max_interval_closure": 0.0,
+      "drive_mass": 3.733417470608985e-07
+    },
+    "blow": {
+      "speed": 0.002,
+      "initial_leaf": [
+        560.7500041779131,
+        0.0,
+        0.0
+      ],
+      "final_leaf": [
+        560.8438616539352,
+        0.014835720416158438,
+        0.012527641374617815
+      ],
+      "raw_residual": [
+        0.0002896524965763092,
+        8.014030754566193e-06,
+        4.828907549381256e-06
+      ],
+      "exact_average_residual": [
+        0.00028958916664123535,
+        7.874332368373871e-06,
+        4.7245994210243225e-06
+      ],
+      "cumulative": {
+        "boundary": [
+          0.09356788685545325,
+          0.014827846083790064,
+          0.01252291677519679
+        ],
+        "fine_transfer": [
+          -0.0672332551330328,
+          -0.01191190630197525,
+          -0.010114157572388649
+        ],
+        "coarse_transfer": [
+          0.06723319180309772,
+          0.011911766603589058,
+          0.010114053264260292
+        ],
+        "rounding": [
+          0.0002896524965763092,
+          8.014030754566193e-06,
+          4.828907549381256e-06
+        ],
+        "average": [
+          -6.332993507385254e-08,
+          -1.3969838619232178e-07,
+          -1.043081283569336e-07
+        ]
+      },
+      "checks": {
+        "validity": true,
+        "geometry_unchanged": true,
+        "boundary_count": 48,
+        "collision_count": 72,
+        "local_collision": true,
+        "local_regime": true,
+        "bfl": true,
+        "transfer_rounding": true,
+        "interval_closure": true,
+        "cumulative_closure": true,
+        "propagation": true,
+        "drive_sign": true
+      },
+      "max_collision_ratio": 0.5696050037738337,
+      "max_collision_error": 1.5865499780609582e-07,
+      "max_bfl_error": 1.2725840020655355e-08,
+      "max_interval_closure": 0.0,
+      "drive_mass": 0.07436401406617413,
+      "propagation": {
+        "coarse_interface_u": {
+          "threshold": 1e-06,
+          "baseline_factor": 10,
+          "first_arrival": {
+            "time": 7,
+            "signal": 4.0664670353703905e-06,
+            "baseline": 2.0116559817931723e-07,
+            "absolute": 4.267265792606936e-06,
+            "x": 20.5,
+            "y": 13.5
+          },
+          "peak": {
+            "metric": "coarse_interface_u",
+            "time": 14,
+            "signal": 0.00028850325159438407,
+            "baseline": 3.003423681142711e-08,
+            "absolute": 0.00028847339892346693,
+            "any_crossed": true,
+            "peak_crossed": true,
+            "x": 20.5,
+            "y": 15.5
+          }
+        },
+        "coarse_bulk_u": {
+          "threshold": 1e-06,
+          "baseline_factor": 10,
+          "first_arrival": {
+            "time": 8,
+            "signal": 1.1069172403255332e-06,
+            "baseline": 1.005827957173589e-07,
+            "absolute": 1.2074577299858699e-06,
+            "x": 13.5,
+            "y": 21.5
+          },
+          "peak": {
+            "metric": "coarse_bulk_u",
+            "time": 16,
+            "signal": 0.00025699080829703886,
+            "baseline": 0.0,
+            "absolute": 0.00025699080829703886,
+            "any_crossed": true,
+            "peak_crossed": true,
+            "x": 21.5,
+            "y": 15.5
+          }
+        },
+        "fine_band_neq": {
+          "threshold": 1e-07,
+          "baseline_factor": 10,
+          "first_arrival": {
+            "time": 6,
+            "signal": 3.8661114470928126e-07,
+            "baseline": 9.934099098884985e-09,
+            "absolute": 3.766770456103963e-07,
+            "x": 19.75,
+            "y": 13.25
+          },
+          "peak": {
+            "metric": "fine_band_neq",
+            "time": 10,
+            "signal": 7.498180437826019e-06,
+            "baseline": 9.106256526614231e-09,
+            "absolute": 7.489074181299404e-06,
+            "any_crossed": true,
+            "peak_crossed": true,
+            "x": 19.75,
+            "y": 15.25
+          }
+        },
+        "transfer_neq": {
+          "threshold": 1e-07,
+          "baseline_factor": 10,
+          "first_arrival": {
+            "time": 7,
+            "signal": 9.917490157301811e-07,
+            "baseline": 1.4901174696935193e-08,
+            "absolute": 9.76847841033246e-07,
+            "q": 1,
+            "x": 20.5,
+            "y": 13.5
+          },
+          "peak": {
+            "metric": "transfer_neq",
+            "time": 11,
+            "signal": 2.6366830318105827e-05,
+            "baseline": 8.692339972804497e-09,
+            "absolute": 2.6375522658078632e-05,
+            "any_crossed": true,
+            "peak_crossed": true,
+            "q": 1,
+            "x": 20.5,
+            "y": 14.5
+          }
+        }
+      },
+      "raw_minus_zero": [
+        6.053410470485687e-05,
+        2.1085143089294434e-06,
+        9.126961231231689e-07
+      ]
+    },
+    "suction": {
+      "speed": -0.002,
+      "initial_leaf": [
+        560.7500041779131,
+        0.0,
+        0.0
+      ],
+      "final_leaf": [
+        560.6568783186376,
+        -0.014766339212656021,
+        -0.012467360123991966
+      ],
+      "raw_residual": [
+        0.00033393828198313713,
+        2.193264663219452e-07,
+        2.6496127247810364e-07
+      ],
+      "exact_average_residual": [
+        0.00033389730378985405,
+        1.0663643479347229e-07,
+        7.683411240577698e-08
+      ],
+      "cumulative": {
+        "boundary": [
+          -0.0934597565792501,
+          -0.014766445849090815,
+          -0.012467436958104372
+        ],
+        "fine_transfer": [
+          0.06703074648976326,
+          0.011895491741597652,
+          0.010098854079842567
+        ],
+        "coarse_transfer": [
+          -0.06703078746795654,
+          -0.011895604431629181,
+          -0.01009904220700264
+        ],
+        "rounding": [
+          0.00033393828198313713,
+          2.193264663219452e-07,
+          2.6496127247810364e-07
+        ],
+        "average": [
+          -4.0978193283081055e-08,
+          -1.126900315284729e-07,
+          -1.8812716007232666e-07
+        ]
+      },
+      "checks": {
+        "validity": true,
+        "geometry_unchanged": true,
+        "boundary_count": 48,
+        "collision_count": 72,
+        "local_collision": true,
+        "local_regime": true,
+        "bfl": true,
+        "transfer_rounding": true,
+        "interval_closure": true,
+        "cumulative_closure": true,
+        "propagation": true,
+        "drive_sign": true
+      },
+      "max_collision_ratio": 0.5285112236646456,
+      "max_collision_error": 1.6477090769573266e-07,
+      "max_bfl_error": 1.2498588997100768e-08,
+      "max_interval_closure": 0.0,
+      "drive_mass": -0.07426865905109248,
+      "propagation": {
+        "coarse_interface_u": {
+          "threshold": 1e-06,
+          "baseline_factor": 10,
+          "first_arrival": {
+            "time": 7,
+            "signal": 4.091979903802207e-06,
+            "baseline": 2.0116559817931723e-07,
+            "absolute": 3.8910894220610345e-06,
+            "x": 20.5,
+            "y": 13.5
+          },
+          "peak": {
+            "metric": "coarse_interface_u",
+            "time": 14,
+            "signal": 0.0002878189146376881,
+            "baseline": 3.003423681142711e-08,
+            "absolute": 0.0002878487673732557,
+            "any_crossed": true,
+            "peak_crossed": true,
+            "x": 20.5,
+            "y": 15.5
+          }
+        },
+        "coarse_bulk_u": {
+          "threshold": 1e-06,
+          "baseline_factor": 10,
+          "first_arrival": {
+            "time": 8,
+            "signal": 1.0179867624062477e-06,
+            "baseline": 1.005827957173589e-07,
+            "absolute": 9.175116276483961e-07,
+            "x": 13.5,
+            "y": 21.5
+          },
+          "peak": {
+            "metric": "coarse_bulk_u",
+            "time": 16,
+            "signal": 0.00025644070267233306,
+            "baseline": 0.0,
+            "absolute": 0.00025644070267233306,
+            "any_crossed": true,
+            "peak_crossed": true,
+            "x": 21.5,
+            "y": 15.5
+          }
+        },
+        "fine_band_neq": {
+          "threshold": 1e-07,
+          "baseline_factor": 10,
+          "first_arrival": {
+            "time": 6,
+            "signal": 3.733491271140643e-07,
+            "baseline": 9.934099098884985e-09,
+            "absolute": 3.832832262129493e-07,
+            "x": 19.75,
+            "y": 13.25
+          },
+          "peak": {
+            "metric": "fine_band_neq",
+            "time": 10,
+            "signal": 7.386030289713297e-06,
+            "baseline": 9.106256526614231e-09,
+            "absolute": 7.395136546239911e-06,
+            "any_crossed": true,
+            "peak_crossed": true,
+            "x": 19.75,
+            "y": 15.25
+          }
+        },
+        "transfer_neq": {
+          "threshold": 1e-07,
+          "baseline_factor": 10,
+          "first_arrival": {
+            "time": 7,
+            "signal": 1.0066612778220074e-06,
+            "baseline": 1.4901174696935193e-08,
+            "absolute": 1.0215624525189426e-06,
+            "q": 1,
+            "x": 20.5,
+            "y": 13.5
+          },
+          "peak": {
+            "metric": "transfer_neq",
+            "time": 11,
+            "signal": 2.6241128339946074e-05,
+            "baseline": 8.692339972804497e-09,
+            "absolute": 2.623243599997327e-05,
+            "any_crossed": true,
+            "peak_crossed": true,
+            "q": 1,
+            "x": 20.5,
+            "y": 14.5
+          }
+        }
+      },
+      "raw_minus_zero": [
+        0.0001048198901116848,
+        -5.686189979314804e-06,
+        -3.6512501537799835e-06
+      ]
+    }
+  }
+}

research/fine_surface_joint_20261014/review.txt

@@ -0,0 +1,36 @@
+Read-only agent review, 2026-10-14
+
+/root/architecture — pre-run:
+No blocking issue in hooked kernel arguments/order, masks or area weighting.
+Caught CSV signal-location ambiguity and exchange-unit ambiguity before freeze:
+fixed any_crossed versus peak_crossed; renamed latest_body_impulse_x/y and
+latest_body_angular_impulse. No production behavior changes.
+
+/root/numerical — pre-run:
+Avoid rho/u at partly valid halo children; transfer neq is defined at full
+coarse incoming vector, actual replaced q. No double-counting average rounding.
+Require independent local SRT oracle before describing measured local drift as
+rounding. Freeze pointwise baseline comparisons; startup propagation may be
+acoustic, not established jet advection. Suggestions incorporated before GPU.
+
+/root/architecture — post-run:
+All frozen hashes match current sources; frozen.json digest matches gpu_run.
+Freeze05:55:03 precedes launch05:55:16UTC, real exit0. Each trajectory has correct
+ordered24ledger/72collision/48boundary rows; result/summary/final ledger agree.
+Independently reconstructed all4metrics' per-time any_crossed/peak_crossed,
+first-arrival and peaks/locations from saved signals.npz; all agree.
+All text artifacts inspected within40000characters. No material gap.
+
+/root/numerical — post-run:
+Independently summed all3ledger/collision CSVs: all components of locally
+measured collision drift exactly reproduce raw global residual. Each interval
+fine_transfer+coarse_transfer-average_rounding is0. Largest FP64ideal moment
+defect about2.94e-14. Maximum independent local oracle normalized error.569605
+is below fixed1. Thus ledger closure is not the sole acceptance gate.
+No blocking issue. Raw mass residuals2.29118e-4/2.89652e-4/3.33938e-4 remain;
+identifying their FP32 source does not physically repair them or establish
+strict conservation. First6/7/8 are integer sampling threshold witnesses,
+not accurate propagation-speed or mature-jet/accuracy claims.
+
+Agents performed read-only inspection/offline data parsing, no file edits,
+no GPU launch and no old regression runs. Root is the sole editor/launcher.

research/fine_surface_joint_20261014/runner.py

@@ -0,0 +1,130 @@
+"""One launch, fresh resource guards, only owned scratch/process-group cleanup."""
+import hashlib
+import json
+import os
+from pathlib import Path
+import shutil
+import signal
+import subprocess
+import tempfile
+import time
+from datetime import datetime, timezone
+
+ROOT = Path('/home/frank14f/CelerisLab')
+OUT = Path(__file__).resolve().parent
+PYTHON = '/home/frank14f/anaconda3/envs/pycuda_3_10/bin/python'
+UUID = 'GPU-e8853ae7-a302-6a17-bcfa-aa767e9ed20c'
+
+
+def command(args):
+    return subprocess.check_output(args, text=True, timeout=10)
+
+
+def gpu():
+    return command(['nvidia-smi', '--query-gpu=index,uuid,name,memory.used,memory.free,utilization.gpu', '--format=csv,noheader,nounits'])
+
+
+def apps():
+    return command(['nvidia-smi', '--query-compute-apps=gpu_uuid,pid,process_name,used_memory', '--format=csv,noheader,nounits'])
+
+
+def ram():
+    for line in Path('/proc/meminfo').read_text().splitlines():
+        if line.startswith('MemAvailable:'):
+            return int(line.split()[1])*1024
+    raise RuntimeError('MemAvailable unavailable')
+
+
+def disk(paths):
+    return sum(p.stat().st_size for root in paths for p in root.rglob('*') if p.is_file())
+
+
+def group_rss(pgid):
+    total = 0
+    for proc in Path('/proc').iterdir():
+        if not proc.name.isdigit():
+            continue
+        try:
+            fields = (proc/'stat').read_text().rsplit(') ', 1)[1].split()
+            if int(fields[2]) == pgid:
+                for line in (proc/'status').read_text().splitlines():
+                    if line.startswith('VmRSS:'):
+                        total += int(line.split()[1])*1024
+        except (OSError, ValueError, IndexError):
+            pass
+    return total
+
+
+def main():
+    assert not (OUT/'gpu_run.json').exists(), 'Do not repeat an existing launch'
+    data = dict(start_utc=datetime.now(timezone.utc).isoformat(), command=[PYTHON, str(OUT/'validate.py')],
+                cwd=str(ROOT), physical_gpu_uuid=UUID, note='Sampled guards, not an OS hard isolation; no fixed RSS/AS cap.')
+    scratch = None
+    process = None
+    started = time.monotonic()
+    code = 1
+    try:
+        frozen = json.loads((OUT/'frozen.json').read_text())
+        for path, digest in frozen['hashes'].items():
+            assert hashlib.sha256((ROOT/path).read_bytes()).hexdigest() == digest, path
+        data['preflight_gpu'], data['preflight_apps'], data['preflight_ram_bytes'] = gpu(), apps(), ram()
+        fields = next(line.split(', ') for line in data['preflight_gpu'].splitlines() if UUID in line)
+        used, free, util = map(int, fields[-3:])
+        assert fields[0] == '0' and used <= 16 and free >= 2048 and util == 0
+        assert UUID not in data['preflight_apps'] and data['preflight_ram_bytes'] >= 4*1024**3
+        limits = dict(wall_seconds=180, temp_bytes=2_000_000_000,
+                      ram_reserve_bytes=max(4*1024**3, data['preflight_ram_bytes']//10),
+                      vram_reserve_MiB=max(512, free//10))
+        data['limits'] = limits
+        scratch = Path(tempfile.mkdtemp(prefix='celeris-joint24-'))
+        env = dict(PYTHONPATH=str(ROOT/'src'), PYTHONNOUSERSITE='1', PYTHONDONTWRITEBYTECODE='1',
+                   OPENBLAS_NUM_THREADS='1', CUDA_VISIBLE_DEVICES=UUID,
+                   CUDA_CACHE_DISABLE='1', TMPDIR=str(scratch))
+        data['env'] = env
+        data['frozen_sha256'] = hashlib.sha256((OUT/'frozen.json').read_bytes()).hexdigest()
+        data['peak_group_rss_bytes'] = 0
+        data['peak_temp_bytes'] = disk([OUT,scratch])
+        data['min_ram_bytes'] = data['preflight_ram_bytes']
+        data['min_vram_free_MiB'] = free
+        data['termination_reason'] = None
+        with (OUT/'stdout.txt').open('w') as output:
+            process = subprocess.Popen(data['command'], cwd=ROOT, env={**os.environ, **env},
+                                       stdout=output, stderr=subprocess.STDOUT, start_new_session=True)
+            while process.poll() is None:
+                available, occupied = ram(), disk([OUT,scratch])
+                free = int(next(line.split(', ')[-2] for line in gpu().splitlines() if UUID in line))
+                data['peak_group_rss_bytes'] = max(data['peak_group_rss_bytes'], group_rss(process.pid))
+                data['peak_temp_bytes'] = max(data['peak_temp_bytes'], occupied)
+                data['min_ram_bytes'] = min(data['min_ram_bytes'], available)
+                data['min_vram_free_MiB'] = min(data['min_vram_free_MiB'], free)
+                if (time.monotonic()-started > limits['wall_seconds'] or occupied > limits['temp_bytes']
+                        or available < limits['ram_reserve_bytes'] or free < limits['vram_reserve_MiB']):
+                    data['termination_reason'] = 'Time/disk/RAM/VRAM guard triggered'
+                    os.killpg(process.pid, signal.SIGTERM)
+                    try:
+                        process.wait(timeout=5)
+                    except subprocess.TimeoutExpired:
+                        os.killpg(process.pid, signal.SIGKILL)
+                    break
+                time.sleep(.5)
+            code = process.wait(timeout=10)
+        data['postflight_gpu'], data['postflight_apps'] = gpu(), apps()
+    except BaseException as error:
+        data['runner_error'] = repr(error)
+        if process is not None and process.poll() is None:
+            os.killpg(process.pid, signal.SIGKILL)
+            process.wait(timeout=10)
+        raise
+    finally:
+        data['exit_code'] = code
+        data['elapsed_seconds'] = time.monotonic()-started
+        if scratch is not None:
+            shutil.rmtree(scratch)
+        data['scratch_removed'] = scratch is None or not scratch.exists()
+        (OUT/'gpu_run.json').write_text(json.dumps(data, indent=2)+'\n')
+        print(json.dumps(data, indent=2), flush=True)
+    raise SystemExit(code)
+
+
+if __name__ == '__main__':
+    main()

research/fine_surface_joint_20261014/suction_boundary.csv

@@ -0,0 +1,49 @@
+step,substep,time,bfl_error,drive_mass,latest_body_impulse_x,latest_body_impulse_y,latest_body_angular_impulse,boundary_m,boundary_px,boundary_py,fine_transfer_m,fine_transfer_px,fine_transfer_py
+1,1,0.5,3.7331066016221826e-09,-0.0015482641756534576,0.0010669892653822899,0.0009111212566494942,1.329833948571224e-05,-0.0015482641756534576,-0.0010669846087694168,-0.0009111212566494942,0.0,0.0,0.0
+1,2,1.0,7.450580596923828e-09,-0.001546488821844781,0.0005881106480956078,0.0005055302754044533,7.090981909652072e-06,-0.0018966365605592728,-0.000588112510740757,-0.0005055312067270279,-3.557652235031128e-07,0.0,0.0
+2,1,1.5,7.450580596923828e-09,-0.0015455698188904868,0.0007474450394511223,0.000630686990916729,6.323601846380811e-06,-0.0017942930571734905,-0.0007474464364349842,-0.0006306902505457401,-8.530914783477783e-07,-7.450580596923828e-09,-1.6763806343078613e-07
+2,2,2.0,7.450580596923828e-09,-0.0015454305605910922,0.0006957640871405602,0.0005812598392367363,-9.326976928458741e-06,-0.0019257990643382072,-0.0006957687437534332,-0.0005812682211399078,-1.3401731848716736e-06,2.7939677238464355e-09,-9.313225746154785e-10
+3,1,2.5,7.450580596923828e-09,-0.0015454182331193405,0.0007162690162658691,0.0006032083183526993,2.0262676536653146e-06,-0.0019086366519331932,-0.0007162792608141899,-0.0006032129749655724,-1.6577541828155518e-06,1.5832483768463135e-07,1.5832483768463135e-07
+3,2,3.0,8.221284986120736e-09,-0.0015455955498631406,0.000675516203045845,0.0005694478750228882,-2.283530538660372e-06,-0.0019611637108027935,-0.0006755241192877293,-0.0005694576539099216,-1.982320100069046e-06,3.1152740120887756e-07,3.096647560596466e-07
+4,1,3.5,7.450580596923828e-09,-0.0015457821940822736,0.0006534429267048836,0.000552385114133358,3.1464089307320364e-06,-0.001949384342879057,-0.0006534415297210217,-0.000552391167730093,-3.2121315598487854e-06,3.5297125577926636e-07,3.762543201446533e-07
+4,2,4.0,7.450580596923828e-09,-0.0015460265831878312,0.0006101150065660477,0.0005156379193067551,2.1656969761973954e-07,-0.001972564961761236,-0.000610120128840208,-0.0005156439729034901,-3.698747605085373e-06,-3.585591912269592e-08,1.909211277961731e-08
+5,1,4.5,7.450580596923828e-09,-0.0015462236236817618,0.0005800491198897362,0.0004902100190520287,2.4401852956046355e-06,-0.0019627874717116356,-0.0005800472572445869,-0.0004902174696326256,-3.6563724279403687e-06,5.550682544708252e-07,2.4121254682540894e-07
+5,2,5.0,8.17224322935406e-09,-0.001546429669342637,0.0005416562780737877,0.00045779068022966385,6.411905253411732e-07,-0.0019741454161703587,-0.0005416539497673512,-0.000457793939858675,-3.6312267184257507e-06,5.122274160385132e-07,2.2258609533309937e-07
+6,1,5.5,7.450580596923828e-09,-0.0015465991853560995,0.0005121780559420586,0.00043242890387773514,1.926527342988038e-06,-0.001966074574738741,-0.0005121775902807713,-0.000432425644248724,-2.8940849006175995e-06,5.164183676242828e-07,3.213062882423401e-08
+6,2,6.0,1.0613033563089402e-08,-0.001546759810737387,0.00047842320054769516,0.00040392857044935226,7.323118594859679e-07,-0.001972377300262451,-0.0004784250631928444,-0.00040392763912677765,-2.0721927285194397e-06,6.435438990592957e-07,9.12696123123169e-08
+7,1,6.5,7.450580596923828e-09,-0.0015468885373133533,0.00045062508434057236,0.0003800736740231514,1.5839877249845813e-06,-0.0019662114791572094,-0.0004506339319050312,-0.00038006948307156563,2.334360033273697e-06,3.114808350801468e-06,1.4849938452243805e-06
+7,2,7.0,8.999190503899968e-09,-0.0015470132347384351,0.00042080413550138474,0.0003548497334122658,8.012649583832854e-07,-0.0019701728597283363,-0.0004208004102110863,-0.00035485532134771347,1.5432480722665787e-05,1.1287163943052292e-05,5.935784429311752e-06
+8,1,7.5,1.0738867337045654e-08,-0.0015471137993936443,0.0003952737897634506,0.00033300556242465973,1.388882160391347e-06,-0.0019654585048556328,-0.0003952831029891968,-0.0003329990431666374,5.064625293016434e-05,2.6551075279712677e-05,1.5786848962306976e-05
+8,2,8.0,7.94032639639397e-09,-0.0015472117748432483,0.00036898814141750336,0.00031079165637493134,8.204820101109789e-07,-0.0019681239500641823,-0.0003689778968691826,-0.0003107842057943344,0.00010942388325929642,6.19497150182724e-05,3.8951635360717773e-05
+9,1,8.5,8.976009713279609e-09,-0.0015472804270270975,0.00034602265805006027,0.0002911807969212532,1.3696224959725e-06,-0.001964463386684656,-0.0003460417501628399,-0.00029119057580828667,0.0002314508892595768,9.650783613324165e-05,6.443960592150688e-05
+9,2,9.0,1.0052167986884797e-08,-0.001547337366734857,0.00032305438071489334,0.0002718055620789528,8.737507810607781e-07,-0.00196637911722064,-0.00032305577769875526,-0.0002718069590628147,0.0003751874901354313,0.00017973734065890312,0.00012484891340136528
+10,1,9.5,7.4023787099974925e-09,-0.001547404346943595,0.00030282605439424515,0.0002545500174164772,1.3337265093449346e-06,-0.0019635148346424103,-0.00030282698571681976,-0.00025455933064222336,0.0006195390596985817,0.00022383593022823334,0.000162455253303051
+10,2,10.0,6.968939966767174e-09,-0.001547448671976346,0.0002828845754265785,0.00023786630481481552,9.501839344228102e-07,-0.001965020317584276,-0.00028289156034588814,-0.00023785652592778206,0.0008522137068212032,0.00035300618037581444,0.0002658138982951641
+11,1,10.5,1.0530962046839676e-08,-0.0015474870615136364,0.00026516150683164597,0.00022298935800790787,1.3016631345008634e-06,-0.0019626920111477375,-0.00026516104117035866,-0.00022298330441117287,0.0011819470673799515,0.0003880225121974945,0.00030118972063064575
+11,2,11.0,7.354702624695619e-09,-0.0015475354224584415,0.0002481304109096527,0.00020870380103588104,8.941672690054858e-07,-0.0019638948142528534,-0.00024813972413539886,-0.00020870286971330643,0.00145752914249897,0.0005337242037057877,0.00042963773012161255
+12,1,11.5,8.767222503536232e-09,-0.001547562607513273,0.00023286882787942886,0.00019576307386159897,1.1601679523742803e-06,-0.001962078735232353,-0.0002328716218471527,-0.00019576400518417358,0.0017802291549742222,0.0005506309680640697,0.00045162299647927284
+12,2,12.0,9.096382980189333e-09,-0.0015476002059964218,0.00021828524768352509,0.00018361210823059082,8.859918445569548e-07,-0.0019631017930805683,-0.00021829502657055855,-0.00018362188711762428,0.002031440380960703,0.0006739604286849499,0.000572004821151495
+13,1,12.5,6.5197561377461355e-09,-0.0015476129016728998,0.00020523089915513992,0.00017269793897867203,1.2139267550059785e-06,-0.0019616251811385155,-0.00020523276180028915,-0.00017269421368837357,0.0022674263454973698,0.00067532854154706,0.0005780183710157871
+13,2,13.0,5.146194359539891e-09,-0.0015476392796307777,0.00019292067736387253,0.00016248133033514023,9.107929975771256e-07,-0.0019624661654233932,-0.0001929309219121933,-0.0001624850556254387,0.002446614671498537,0.0007499088533222675,0.0006604096852242947
+14,1,13.5,8.330306375259333e-09,-0.0015476535128897996,0.0001819990575313568,0.00015316344797611237,1.1346972110803932e-06,-0.0019612740725278854,-0.0001819925382733345,-0.00015317555516958237,0.0025721797719597816,0.0007412796840071678,0.0006537484005093575
+14,2,14.0,8.454041688921166e-09,-0.0015476762461938956,0.00017176009714603424,0.00014458410441875458,9.925571977653647e-07,-0.0019619660452008247,-0.00017175264656543732,-0.0001445794478058815,0.0026705721393227577,0.000760519877076149,0.0006827609613537788
+15,1,14.5,8.024249306681774e-09,-0.0015476863880568553,0.0001627029851078987,0.00013693515211343765,1.1326488877916319e-06,-0.0019609066657721996,-0.00016270345076918602,-0.00013692351058125496,0.0027098902501165867,0.0007453667931258678,0.0006675352342426777
+15,2,15.0,8.5509712643983e-09,-0.0015477023138736976,0.00015427079051733017,0.0001298980787396431,1.0080659256228586e-06,-0.0019614454358816147,-0.00015425775200128555,-0.00012989435344934464,0.0027480190619826317,0.0007168371230363846,0.0006446875631809235
+16,1,15.5,1.2498588997100768e-08,-0.0015477122014419843,0.0001468295231461525,0.000123598612844944,1.1824087963185903e-06,-0.001960494089871645,-0.00014683278277516365,-0.000123604666441679,0.002740874420851469,0.0006989189423620701,0.000626422930508852
+16,2,16.0,9.256705402194143e-09,-0.0015477301148594871,0.00014006812125444412,0.00011796411126852036,9.308136234009723e-07,-0.0019609369337558746,-0.00014007184654474258,-0.00011796131730079651,0.002747458405792713,0.0006359582766890526,0.0005640769377350807
+17,1,16.5,9.86708736938624e-09,-0.0015477351078586202,0.00013425014913082123,0.00011301040649414062,1.1052945718681428e-06,-0.001960096415132284,-0.0001342552714049816,-0.0001130090095102787,0.002724500373005867,0.0006184643134474754,0.0005468325689435005
+17,2,17.0,8.028477438415393e-09,-0.0015477600973967448,0.00012889597564935684,0.00010859500616788864,9.277017700703993e-07,-0.001960489433258772,-0.0001288936473429203,-0.00010859174653887749,0.0027201655320823193,0.0005353703163564205,0.00046224379912018776
+18,1,17.5,7.699842763386755e-09,-0.0015477556081742207,0.00012428779155015945,0.00010465551167726517,1.036442421664674e-06,-0.00195977371186018,-0.0001242849975824356,-0.00010466109961271286,0.0026930058375000954,0.0005191462114453316,0.0004479791969060898
+18,2,18.0,7.779478172764698e-09,-0.0015477652772308585,0.00011980719864368439,0.00010108202695846558,9.591615347526172e-07,-0.001960138790309429,-0.00011981278657913208,-0.0001010717824101448,0.0026853615418076515,0.00042929593473672867,0.0003578970208764076
+19,1,18.5,1.0115823734224705e-08,-0.0015477747316547663,0.00011577177792787552,9.778235107660294e-05,1.1382919499203226e-06,-0.001959627028554678,-0.00011577224358916283,-9.777536615729332e-05,0.002648819237947464,0.0004100445657968521,0.0003434009850025177
+19,2,19.0,9.594118610678493e-09,-0.0015477738185972504,0.00011185649782419205,9.45916399359703e-05,8.908682038732962e-07,-0.0019600135274231434,-0.0001118597574532032,-9.458651766180992e-05,0.0026350892148911953,0.0003254576586186886,0.00026165833696722984
+20,1,19.5,8.744199350707582e-09,-0.0015477812550560438,0.00010816752910614014,9.154155850410461e-05,1.0807081907149296e-06,-0.001959587913006544,-0.0001081652007997036,-9.154481813311577e-05,0.0025749970227479935,0.0002942616119980812,0.00023942533880472183
+20,2,20.0,7.241793387180451e-09,-0.0015478027222764852,0.00010451860725879669,8.863583207130432e-05,9.283607647070369e-07,-0.0019599981606006622,-0.00010452233254909515,-8.862745016813278e-05,0.002547156997025013,0.00022500474005937576,0.0001754332333803177
+21,1,20.5,9.080666218963529e-09,-0.0015478099147822168,0.00010123103857040405,8.586794137954712e-05,1.0566826715852073e-06,-0.0019596004858613014,-0.00010123662650585175,-8.586607873439789e-05,0.0024467245675623417,0.0001708432100713253,0.0001354874111711979
+21,2,21.0,8.309436028142159e-09,-0.001547811782321707,9.799562394618988e-05,8.317828178405762e-05,9.359370445327642e-07,-0.0019598989747464657,-9.798770770430565e-05,-8.317967876791954e-05,0.0023957067169249058,0.0001242239959537983,9.476905688643456e-05
+22,1,21.5,8.807171658631319e-09,-0.0015478071837582907,9.528174996376038e-05,8.07885080575943e-05,1.0299947542646848e-06,-0.001959493849426508,-9.528035297989845e-05,-8.077593520283699e-05,0.0022453111596405506,3.82973812520504e-05,2.8362032026052475e-05
+22,2,22.0,7.708700941466695e-09,-0.0015478350620986127,9.280815720558167e-05,7.856637239456177e-05,9.84289633354507e-07,-0.0019597294740378857,-9.280489757657051e-05,-7.857801392674446e-05,0.0021656760945916176,1.8442049622535706e-05,1.2994743883609772e-05
+23,1,22.5,5.829010607527607e-09,-0.0015478298144738873,9.077228605747223e-05,7.675401866436005e-05,1.0561968476485717e-06,-0.0019593103788793087,-9.077740833163261e-05,-7.675448432564735e-05,0.001967994961887598,-0.00010093534365296364,-8.322251960635185e-05
+23,2,23.0,1.00678847481106e-08,-0.0015478396129139588,8.917506784200668e-05,7.518846541643143e-05,9.189075473869934e-07,-0.001959436573088169,-8.916761726140976e-05,-7.51987099647522e-05,0.0018595317378640175,-9.398628026247025e-05,-7.435213774442673e-05
+24,1,23.5,9.096645881001564e-09,-0.0015478476094394076,8.79606232047081e-05,7.397029548883438e-05,9.397743796490943e-07,-0.0019590607844293118,-8.79545696079731e-05,-7.396889850497246e-05,0.0016328254714608192,-0.00023874826729297638,-0.00019633769989013672
+24,2,24.0,8.815424390462567e-09,-0.001547844811637395,8.694268763065338e-05,7.304549217224121e-05,9.335749210359623e-07,-0.001959147397428751,-8.693570271134377e-05,-7.305433973670006e-05,0.0015028249472379684,-0.0002091461792588234,-0.00016683153808116913

research/fine_surface_joint_20261014/suction_collisions.csv

@@ -0,0 +1,73 @@
+step,level,substep,max_error,max_ratio,regime,drift_m,drift_px,drift_py,ideal_defect_m,ideal_defect_px,ideal_defect_py,measured_rounding_m,measured_rounding_px,measured_rounding_py
+1,fine,1,8.229037262719174e-08,0.3569820693406681,True,1.626182347536087e-05,-3.3527612686157227e-08,-1.7695128917694092e-08,-3.0010716134398763e-16,-1.214306433183765e-17,-1.734723475976807e-18,1.6261823475660978e-05,-3.352761267401416e-08,-1.7695128915959368e-08
+1,fine,2,5.173531247848473e-08,0.2677766155245442,True,-3.394670784473419e-07,1.3969838619232178e-09,1.7229467630386353e-08,-5.745404152435185e-15,-1.0408340855860843e-17,5.898059818321144e-17,-3.3946707270193777e-07,1.3969838723315586e-09,1.7229467571405754e-08
+1,coarse,1,1.1080350609260492e-08,0.10456730670501622,True,-1.5292316675186157e-06,-1.30385160446167e-08,-1.5832483768463135e-07,-4.288236432614667e-15,-5.551115123125783e-17,1.3877787807814457e-17,-1.5292316632303793e-06,-1.3038515989105548e-08,-1.5832483769850914e-07
+2,fine,1,9.892327201832529e-08,0.29769478490638285,True,9.881332516670227e-07,-3.3527612686157227e-08,-1.993030309677124e-07,-5.195496810550537e-15,-2.949029909160572e-17,2.1337098754514727e-16,9.881332568625195e-07,-3.352761265666693e-08,-1.993030311810834e-07
+2,fine,2,8.832159215099722e-08,0.3121116042355555,True,2.668239176273346e-06,-4.284083843231201e-08,1.2852251529693604e-07,-1.1539380562197721e-14,-1.457167719820518e-16,2.2898349882893854e-16,2.6682391878127265e-06,-4.284083828659524e-08,1.2852251506795254e-07
+2,coarse,1,1.6365805183271576e-08,0.1544470929589978,True,-1.426786184310913e-06,-3.0919909477233887e-07,-3.0919909477233887e-07,-6.286637876939949e-15,-8.326672684688674e-17,-8.326672684688674e-17,-1.4267861780242752e-06,-3.0919909468907214e-07,-3.0919909468907214e-07
+3,fine,1,8.23703105723439e-08,0.31152334896616624,True,4.902016371488571e-06,1.5227124094963074e-07,1.280568540096283e-07,-1.1922754450388595e-14,9.540979117872439e-17,3.452099717193846e-16,4.902016383411326e-06,1.5227124085422095e-07,1.2805685366441832e-07
+3,fine,2,1.0607572520360264e-07,0.3828123813437159,True,8.435919880867004e-06,7.35744833946228e-08,-3.259629011154175e-08,-1.7525911277793682e-14,9.540979117872439e-17,3.5561831257524545e-16,8.435919898392916e-06,7.357448329921301e-08,-3.259629046716006e-08
+3,coarse,1,1.0010523732173482e-07,0.2854567053212911,True,9.115785360336304e-06,3.3155083656311035e-07,3.203749656677246e-07,-3.837208328860697e-15,1.5334955527634975e-15,1.2420620087993939e-15,9.115785364173512e-06,3.315508350296148e-07,3.203749644256626e-07
+4,fine,1,9.437402781475868e-08,0.3632811360585352,True,1.0774470865726471e-05,2.8405338525772095e-07,3.0174851417541504e-07,-2.0582494042464816e-14,2.411265631607762e-16,2.7929047963226594e-16,1.0774470886308965e-05,2.840533850165944e-07,3.0174851389612456e-07
+4,fine,2,1.411709008580786e-07,0.4323516759917293,True,1.1160969734191895e-05,2.169981598854065e-07,5.774199962615967e-08,-1.6453852169640015e-14,-5.533767888366015e-16,-4.2847669856627135e-16,1.1160969750645747e-05,2.1699816043878328e-07,5.7742000054636367e-08
+4,coarse,1,1.2150177930436712e-07,0.37139422446265463,True,1.3064593076705933e-05,5.997717380523682e-07,5.62518835067749e-07,-1.2559397966072083e-14,-5.967448757360216e-16,-2.498001805406602e-16,1.306459308926533e-05,5.99771738649113e-07,5.625188353175492e-07
+5,fine,1,1.2376571800754022e-07,0.4335945297787668,True,1.0852236300706863e-05,-3.022141754627228e-07,-3.1618401408195496e-07,-1.5610776560315287e-14,5.377642775528102e-17,-3.625572064791527e-16,1.085223631631764e-05,-3.022141755164992e-07,-3.1618401371939775e-07
+5,fine,2,1.2417755734794866e-07,0.3644862055932074,True,8.977483958005905e-06,-2.621673047542572e-07,-7.031485438346863e-08,-1.519617764955683e-14,-1.8041124150158794e-16,8.430756093247282e-16,8.977483973202083e-06,-2.6216730457384596e-07,-7.031485522654424e-08
+5,coarse,1,1.2532259030528792e-07,0.38942307019337585,True,1.49458646774292e-05,9.723007678985596e-07,1.2628734111785889e-06,-1.6535384173010925e-14,1.5959455978986625e-16,6.175615574477433e-16,1.4945864693964583e-05,9.72300767738965e-07,1.2628734105610273e-06
+6,fine,1,9.483337493065847e-08,0.32226540864225656,True,6.834045052528381e-06,4.284083843231201e-08,-1.0244548320770264e-07,-1.4689638394571602e-14,1.1102230246251565e-16,2.914335439641036e-16,6.83404506721802e-06,4.284083832128971e-08,-1.0244548349913618e-07
+6,fine,2,1.1486422213380365e-07,0.36328113343919116,True,6.2193721532821655e-06,-4.190951585769653e-08,-1.30385160446167e-08,-1.437044927499187e-14,1.7694179454963432e-16,-1.0408340855860843e-17,6.219372167652615e-06,-4.190951603463833e-08,-1.3038516034208358e-08
+6,coarse,1,1.0239773140519048e-07,0.43028837580529966,True,1.383945345878601e-05,4.954636096954346e-07,4.284083843231201e-07,-2.0011770018868447e-14,3.191891195797325e-16,1.0269562977782698e-15,1.383945347879778e-05,4.954636093762455e-07,4.284083832961638e-07
+7,fine,1,1.1381071352012384e-07,0.39830750519457453,True,5.2102841436862946e-06,-2.0023435354232788e-08,-1.0477378964424133e-07,-1.6167622796103842e-14,9.020562075079397e-17,0.0,5.210284159853917e-06,-2.002343544443841e-08,-1.0477378964424133e-07
+7,fine,2,1.1557639800763297e-07,0.4252975630997776,True,4.476867616176605e-06,-1.2479722499847412e-07,4.0046870708465576e-08,-1.4878723253453074e-14,8.673617379884035e-18,4.388850394221322e-16,4.4768676310553285e-06,-1.2479722500714774e-07,4.004687026958054e-08
+7,coarse,1,1.0902046165828239e-07,0.38161058826685446,True,1.321360468864441e-05,9.126961231231689e-07,-2.086162567138672e-07,-2.4445723223465166e-14,-5.898059818321144e-16,-3.122502256758253e-16,1.3213604713090132e-05,9.126961237129749e-07,-2.0861625640161696e-07
+8,fine,1,1.2369974378145798e-07,0.3659033398608433,True,4.209578037261963e-06,-1.2479722499847412e-07,-2.421438694000244e-08,-1.5269036035547856e-14,-1.4224732503009818e-16,-7.28583859910259e-17,4.209578052530999e-06,-1.247972248562268e-07,-2.4214386867144055e-08
+8,fine,2,1.3039186863572638e-07,0.3566417233064843,True,4.0014274418354034e-06,5.075708031654358e-08,-1.6298145055770874e-08,-1.6002824065886045e-14,-2.949029909160572e-17,-2.5153490401663703e-16,4.0014274578382275e-06,5.075708034603388e-08,-1.629814480423597e-08
+8,coarse,1,1.265961931951054e-07,0.38341345468786764,True,9.08784568309784e-06,6.09084963798523e-07,-5.979090929031372e-07,-2.2336299476677368e-14,-1.4224732503009818e-15,2.0816681711721685e-17,9.087845705434139e-06,6.090849652209962e-07,-5.979090929239539e-07
+9,fine,1,1.1700286717264419e-07,0.42325024900493485,True,2.2551976144313812e-06,-1.150183379650116e-07,-3.026798367500305e-08,-1.5406079190150024e-14,6.418476861114186e-17,2.6194324487249787e-16,2.2551976298374604e-06,-1.1501833802919637e-07,-3.0267983936946297e-08
+9,fine,2,1.05960657470483e-07,0.3591277749177671,True,3.159046173095703e-06,-5.8673322200775146e-08,-1.471489667892456e-07,-1.5987211554602254e-14,-6.245004513516506e-17,-2.0816681711721685e-17,3.1590461890829147e-06,-5.86733221383251e-08,-1.4714896676842892e-07
+9,coarse,1,1.1063907701114317e-07,0.4156431955412631,True,5.3513795137405396e-06,-3.1478703022003174e-07,-5.345791578292847e-07,-2.5042468099201187e-14,1.0408340855860843e-16,-2.2898349882893854e-16,5.351379538783008e-06,-3.1478703032411515e-07,-5.345791576003012e-07
+10,fine,1,1.6477090769573266e-07,0.3991506368171169,True,2.605374902486801e-06,1.2619420886039734e-07,6.007030606269836e-08,-1.5024440025435126e-14,-3.2786273695961654e-16,-2.8622937353617317e-16,2.605374917511241e-06,1.2619420918826008e-07,6.007030634892774e-08
+10,fine,2,1.233670676725751e-07,0.3467327260376902,True,2.4153850972652435e-06,-1.5133991837501526e-07,-1.19674950838089e-07,-1.5607307113363333e-14,-1.9949319973733282e-16,4.631711680858075e-16,2.4153851128725506e-06,-1.5133991817552206e-07,-1.1967495130126016e-07
+10,coarse,1,1.3984166169489498e-07,0.4038458162128909,True,6.22868537902832e-06,-2.942979335784912e-07,3.725290298461914e-09,-2.3592239273284576e-14,-4.163336342344337e-16,1.1657341758564144e-15,6.22868540262056e-06,-2.942979331621576e-07,3.725289132727738e-09
+11,fine,1,1.1264907540109448e-07,0.37435057774799535,True,1.6032718122005463e-06,4.190951585769653e-09,2.9336661100387573e-08,-1.5607307113363333e-14,2.723515857283587e-16,-1.0234868508263162e-16,1.6032718278078534e-06,4.190951313418068e-09,2.9336661202736258e-08
+11,fine,2,1.3385929209519531e-07,0.4296446436631812,True,1.1781230568885803e-06,2.3469328880310059e-07,1.126900315284729e-07,-1.665854953980528e-14,2.0296264668928643e-16,3.2959746043559335e-17,1.1781230735471299e-06,2.3469328860013794e-07,1.1269003149551315e-07
+11,coarse,1,1.2484760447684096e-07,0.3737977990108256,True,1.9688159227371216e-06,-6.146728992462158e-08,-2.421438694000244e-08,-2.295386103412511e-14,-1.5265566588595902e-16,-9.575673587391975e-16,1.9688159456909826e-06,-6.146728977196592e-08,-2.4214385982435083e-08
+12,fine,1,1.1342225503252479e-07,0.3929712248585018,True,2.9103830456733704e-06,1.1827796697616577e-07,1.6670674085617065e-07,-1.6981208106336965e-14,2.5153490401663703e-16,1.0234868508263162e-16,2.9103830626545785e-06,1.1827796672463087e-07,1.6670674075382197e-07
+12,fine,2,1.2337913590787508e-07,0.3632480304781915,True,2.22865492105484e-06,7.450580596923828e-09,1.3690441846847534e-07,-1.7019372022808454e-14,-1.9081958235744878e-17,1.6479873021779667e-16,2.228654938074212e-06,7.450580616005786e-09,1.369044183036766e-07
+12,coarse,1,1.0392955884785948e-07,0.34435036745116887,True,4.416331648826599e-06,8.009374141693115e-08,-7.264316082000732e-08,-2.665923037881157e-14,1.942890293094024e-16,3.3306690738754696e-16,4.4163316754858295e-06,8.009374122264212e-08,-7.264316115307423e-08
+13,fine,1,1.120637568297056e-07,0.3794727716066827,True,1.1702068150043488e-06,-1.4016404747962952e-07,-1.0477378964424133e-07,-1.6571813366006438e-14,8.153200337090993e-17,-1.0928757898653885e-16,1.1702068315761621e-06,-1.4016404756116152e-07,-1.0477378953495375e-07
+13,fine,2,1.1608141914365433e-07,0.3684207409368108,True,1.93621963262558e-06,-2.1979212760925293e-07,-7.543712854385376e-08,-1.696733031852915e-14,1.5612511283791264e-17,4.0072112295064244e-16,1.93621964959291e-06,-2.1979212762486544e-07,-7.543712894457488e-08
+13,coarse,1,1.1553440504297185e-07,0.413461159221051,True,2.12155282497406e-06,9.872019290924072e-08,3.1851232051849365e-07,-2.4966140266258208e-14,1.0685896612017132e-15,3.885780586188048e-16,2.1215528499402003e-06,9.872019184065106e-08,3.185123201299156e-07
+14,fine,1,1.3012184874039434e-07,0.4470057319678252,True,2.093147486448288e-06,-2.7474015951156616e-08,1.816079020500183e-08,-1.6941309466389498e-14,2.0469737016526324e-16,-2.393918396847994e-16,2.0931475033895974e-06,-2.7474016155853986e-08,1.816079044439367e-08
+14,fine,2,1.161938236737825e-07,0.43455223301865037,True,2.180226147174835e-06,1.6577541828155518e-07,3.166496753692627e-08,-1.662038562333379e-14,-3.139849491518021e-16,-5.724587470723463e-17,2.180226163795221e-06,1.6577541859554012e-07,3.1664967594172144e-08
+14,coarse,1,1.171716388359556e-07,0.34014613609932465,True,3.285706043243408e-06,5.21540641784668e-08,-8.940696716308594e-08,-2.5222879340702775e-14,2.0122792321330962e-16,-3.95516952522712e-16,3.2857060684662875e-06,5.2154063977238874e-08,-8.940696676756898e-08
+15,fine,1,1.188765739179587e-07,0.3778719310571328,True,2.386048436164856e-06,1.0989606380462646e-07,4.190951585769653e-08,-1.6297727056802103e-14,3.0010716134398763e-16,5.0306980803327406e-17,2.386048452462583e-06,1.098960635045193e-07,4.190951580738955e-08
+15,fine,2,1.2815464434101642e-07,0.3887039950605819,True,2.2151507437229156e-06,5.3551048040390015e-08,1.5599653124809265e-07,-1.6632528687665626e-14,-3.469446951953614e-17,-2.220446049250313e-16,2.2151507603554443e-06,5.3551048075084484e-08,1.5599653147013726e-07
+15,coarse,1,1.132467172260121e-07,0.3798076391349909,True,4.431232810020447e-06,-6.891787052154541e-08,-4.6566128730773926e-08,-2.4917568008930857e-14,5.898059818321144e-16,7.008282842946301e-16,4.431232834938015e-06,-6.891787111135139e-08,-4.656612943160221e-08
+16,fine,1,1.1449205894464853e-07,0.4232816528057199,True,1.267995685338974e-06,7.962808012962341e-08,8.89413058757782e-08,-1.7224069392973718e-14,1.9255430583342559e-16,2.3071822230491534e-16,1.2679957025630434e-06,7.962807993706911e-08,8.894130564505998e-08
+16,fine,2,1.1465035798519096e-07,0.38660659294745114,True,1.61072239279747e-06,2.0070001482963562e-07,8.242204785346985e-08,-1.688579831515824e-14,2.0816681711721685e-16,-3.95516952522712e-16,1.6107224096832684e-06,2.007000146214688e-07,8.24220482489868e-08
+16,coarse,1,1.026492656430733e-07,0.39551928594354874,True,4.755333065986633e-06,2.8870999813079834e-07,-1.30385160446167e-08,-2.5340840537069198e-14,8.465450562766819e-16,-1.4988010832439613e-15,4.755333091327474e-06,2.887099972842533e-07,-1.3038514545815616e-08
+17,fine,1,1.4306400941688224e-07,0.3804206132029011,True,2.477318048477173e-06,2.952292561531067e-07,2.1420419216156006e-07,-1.6018436577169837e-14,1.1102230246251565e-16,-2.498001805406602e-16,2.4773180644956094e-06,2.952292560420844e-07,2.1420419241136024e-07
+17,fine,2,1.206053866775747e-07,0.40931703720753354,True,2.6957131922245026e-06,3.655441105365753e-07,1.7834827303886414e-07,-1.704365815147213e-14,3.382710778154774e-16,-1.43982048506075e-16,2.6957132092681607e-06,3.6554411019830424e-07,1.7834827318284618e-07
+17,coarse,1,1.3320810943184824e-07,0.4098554436464823,True,4.893168807029724e-06,2.3655593395233154e-07,3.632158041000366e-07,-2.93723378952393e-14,-4.649058915617843e-16,4.2327252813834093e-16,4.893168836402062e-06,2.3655593441723743e-07,3.632158036767641e-07
+18,fine,1,1.1518374609664761e-07,0.37525164303996766,True,3.0049122869968414e-06,2.92900949716568e-07,2.4633482098579407e-07,-1.704365815147213e-14,-1.474514954580286e-16,5.724587470723463e-17,3.0049123040404996e-06,2.929009498640195e-07,2.463348209285482e-07
+18,fine,2,1.5383020013359783e-07,0.4339170567027524,True,2.28220596909523e-06,3.2549723982810974e-07,2.48197466135025e-07,-1.700029006457271e-14,-1.214306433183765e-16,-3.122502256758253e-16,2.28220598609552e-06,3.254972399495404e-07,2.4819746644727525e-07
+18,coarse,1,1.4574858631100085e-07,0.42004802685791165,True,4.898756742477417e-06,-1.564621925354004e-07,-2.123415470123291e-07,-2.679106936298581e-14,1.457167719820518e-16,-4.85722573273506e-17,4.898756769268486e-06,-1.5646219268111716e-07,-2.1234154696375684e-07
+19,fine,1,1.1289196333308382e-07,0.4426868958150174,True,2.4051405489444733e-06,3.8230791687965393e-07,4.23286110162735e-07,-1.7246620798161416e-14,-5.447031714567174e-16,-2.42861286636753e-16,2.405140566191094e-06,3.823079174243571e-07,4.2328611040559627e-07
+19,fine,2,1.3318459290978524e-07,0.4458767766498759,True,2.4051405489444733e-06,-1.3504177331924438e-08,-1.6298145055770874e-08,-1.6679366221517e-14,-1.8561541192951836e-16,4.683753385137379e-17,2.4051405656238395e-06,-1.3504177146309027e-08,-1.6298145102608408e-08
+19,coarse,1,1.3627775263813646e-07,0.37598585924709055,True,6.38328492641449e-06,-2.514570951461792e-07,2.1792948246002197e-07,-2.724209746673978e-14,-7.91033905045424e-16,-1.3877787807814457e-17,6.383284953656587e-06,-2.514570943551453e-07,2.1792948247389976e-07
+20,fine,1,1.2067538701643343e-07,0.397654453667931,True,3.3676624298095703e-06,-7.636845111846924e-08,8.195638656616211e-08,-1.6471199404399783e-14,1.0581813203458523e-16,7.806255641895632e-17,3.3676624462807697e-06,-7.636845122428737e-08,8.195638648809955e-08
+20,fine,2,1.1349498318935503e-07,0.4276325956343959,True,3.5767443478107452e-06,-7.869675755500793e-08,6.565824151039124e-08,-1.5959455978986625e-14,9.020562075079397e-17,5.898059818321144e-17,3.5767443637702012e-06,-7.869675764521356e-08,6.565824145141064e-08
+20,coarse,1,1.5850306378517587e-07,0.5285112236646456,True,3.5408884286880493e-06,-1.993030309677124e-07,-3.7066638469696045e-07,-2.525757381022231e-14,7.91033905045424e-16,-2.3592239273284576e-16,3.540888453945623e-06,-1.993030317587463e-07,-3.7066638446103806e-07
+21,fine,1,1.2747028055315468e-07,0.3807671146447972,True,3.180466592311859e-06,-9.872019290924072e-08,-4.377216100692749e-08,-1.619537837171947e-14,5.204170427930421e-17,-1.4224732503009818e-16,3.1804666085072375e-06,-9.872019296128243e-08,-4.3772160864680165e-08
+21,fine,2,1.1436689684174439e-07,0.41457208617159613,True,2.8158538043498993e-06,-4.516914486885071e-08,3.119930624961853e-08,-1.622833811776303e-14,-2.0296264668928643e-16,-1.7867651802561113e-16,2.8158538205782374e-06,-4.516914466588806e-08,3.119930642829505e-08
+21,coarse,1,1.3219836714206679e-07,0.4111722561110483,True,5.48921525478363e-06,-9.816139936447144e-07,-5.345791578292847e-07,-2.7602919949742954e-14,4.0245584642661925e-16,2.7755575615628914e-16,5.48921528238655e-06,-9.816139940471702e-07,-5.345791581068404e-07
+22,fine,1,1.247986221031283e-07,0.4025936491208882,True,2.5955960154533386e-06,-1.1734664440155029e-07,7.636845111846924e-08,-1.670712179713263e-14,2.0643209364124004e-16,-1.196959198423997e-16,2.5955960321604604e-06,-1.1734664460798239e-07,7.636845123816516e-08
+22,fine,2,1.2467687349193568e-07,0.4026463456064581,True,2.169981598854065e-06,-2.0023435354232788e-07,-2.5331974029541016e-07,-1.5954251808558695e-14,4.336808689942018e-17,8.847089727481716e-17,2.1699816148083167e-06,-2.0023435358569597e-07,-2.5331974038388105e-07
+22,coarse,1,1.303169513411362e-07,0.4534581358023719,True,4.8317015171051025e-06,-1.4826655387878418e-06,-8.456408977508545e-07,-2.6728619317850644e-14,-9.71445146547012e-17,-4.163336342344337e-16,4.831701543833722e-06,-1.4826655386906973e-06,-8.456408973345209e-07
+23,fine,1,1.1580148451262318e-07,0.3892248238329876,True,2.83215194940567e-06,-4.284083843231201e-08,-1.3317912817001343e-07,-1.7317744460676465e-14,2.2551405187698492e-17,-3.9898639947466563e-17,2.8321519667234146e-06,-4.284083845486342e-08,-1.331791281301148e-07
+23,fine,2,1.4772394407724931e-07,0.44883956143532583,True,2.432148903608322e-06,-1.0570511221885681e-07,-3.306195139884949e-08,-1.628211454551831e-14,4.85722573273506e-17,1.1796119636642288e-16,2.4321489198904367e-06,-1.0570511226742907e-07,-3.3061951516810684e-08
+23,coarse,1,1.4415727089822639e-07,0.46236304392819116,True,8.864328265190125e-06,-8.624047040939331e-07,-5.19677996635437e-07,-2.839395385478838e-14,-3.7470027081099033e-16,-1.0269562977782698e-15,8.864328293584078e-06,-8.624047037192328e-07,-5.196779956084807e-07
+24,fine,1,1.1816075007331506e-07,0.40334771123509106,True,2.196524292230606e-06,-5.2619725465774536e-08,-1.327134668827057e-07,-1.619537837171947e-14,3.400058012914542e-16,7.979727989493313e-17,2.1965243084259845e-06,-5.261972580578034e-08,-1.3271346696250297e-07
+24,fine,2,1.2605529897680157e-07,0.4651221485857391,True,2.941582351922989e-06,-2.2584572434425354e-07,6.05359673500061e-09,-1.802204219192305e-14,-2.5153490401663703e-16,2.3418766925686896e-16,2.941582369945031e-06,-2.2584572409271864e-07,6.053596500812941e-09
+24,coarse,1,1.573361411155716e-07,0.43294013951653565,True,9.939074516296387e-06,-2.905726432800293e-07,1.4156103134155273e-07,-2.768618667658984e-14,-1.6653345369377348e-16,1.1102230246251565e-15,9.939074543982573e-06,-2.9057264311349584e-07,1.415610302313297e-07

research/fine_surface_joint_20261014/suction_ledger.csv

@@ -0,0 +1,25 @@
+step,time,average_bound_ratio,leaf_m,leaf_px,leaf_py,delta_m,delta_px,delta_py,boundary_m,boundary_px,boundary_py,fine_transfer_m,fine_transfer_px,fine_transfer_py,coarse_transfer_m,coarse_transfer_px,coarse_transfer_py,raw_m,raw_px,raw_py,collision_drift_m,collision_drift_px,collision_drift_py,average_rounding_m,average_rounding_px,average_rounding_py,closure_m,closure_px,closure_py,cumulative_raw_m,cumulative_raw_px,cumulative_raw_py,cumulative_closure_m,cumulative_closure_px,cumulative_closure_py
+1,1,0.28124994289828603,560.7465738453902,-0.0016551441513001919,-0.001416988205164671,-0.003430332522839308,-0.0016551441513001919,-0.001416988205164671,-0.0034449007362127304,-0.0016550971195101738,-0.001416652463376522,-3.557652235031128e-07,0.0,0.0,5.308538675308228e-07,-1.862645149230957e-09,-1.7695128917694092e-07,1.4393124729394913e-05,-4.516914486885071e-08,-1.587904989719391e-07,1.4393124729394913e-05,-4.516914486885071e-08,-1.587904989719391e-07,1.7508864402770996e-07,-1.862645149230957e-09,-1.7695128917694092e-07,0.0,0.0,0.0,1.4393124729394913e-05,-4.516914486885071e-08,-1.587904989719391e-07,0.0,0.0,0.0
+2,2,0.37499987985940486,560.7428558217362,-0.003098900429904461,-0.0026293257251381874,-0.003718023654073477,-0.001443756278604269,-0.0012123375199735165,-0.0037200921215116978,-0.0014432151801884174,-0.001211958471685648,-2.193264663219452e-06,-4.6566128730773926e-09,-1.685693860054016e-07,2.032145857810974e-06,-1.5087425708770752e-07,1.695007085800171e-07,2.2295862436294556e-06,-3.855675458908081e-07,-3.7997961044311523e-07,2.2295862436294556e-06,-3.855675458908081e-07,-3.7997961044311523e-07,-1.6111880540847778e-07,-1.555308699607849e-07,9.313225746154785e-10,0.0,0.0,0.0,1.6622710973024368e-05,-4.307366907596588e-07,-5.387701094150543e-07,0.0,0.0,0.0
+3,3,0.2812499146093721,560.739008476492,-0.004490140359848738,-0.0038015726022422314,-0.003847345244139433,-0.0013912399299442768,-0.001172246877104044,-0.0038698003627359867,-0.0013918033801019192,-0.001172670628875494,-3.6400742828845978e-06,4.698522388935089e-07,4.6798959374427795e-07,3.641471266746521e-06,-4.637986421585083e-07,-4.600733518600464e-07,2.245372161269188e-05,5.573965609073639e-07,4.1583552956581116e-07,2.245372161269188e-05,5.573965609073639e-07,4.1583552956581116e-07,1.3969838619232178e-09,6.05359673500061e-09,7.916241884231567e-09,0.0,0.0,0.0,3.907643258571625e-05,1.2665987014770508e-07,-1.2293457984924316e-07,0.0,0.0,0.0
+4,4,0.37499987985940486,560.7351214168593,-0.005752546712756157,-0.004868627525866032,-0.0038870596326887608,-0.0012624063529074192,-0.0010670549236238003,-0.003921949304640293,-0.0012635616585612297,-0.001068035140633583,-6.910879164934158e-06,3.1711533665657043e-07,3.9534643292427063e-07,6.800517439842224e-06,-2.6263296604156494e-07,-3.371387720108032e-07,3.50000336766243e-05,1.1008232831954956e-06,9.220093488693237e-07,3.50000336766243e-05,1.1008232831954956e-06,9.220093488693237e-07,-1.103617250919342e-07,5.448237061500549e-08,5.820766091346741e-08,0.0,0.0,0.0,7.407646626234055e-05,1.2274831533432007e-06,7.990747690200806e-07,0.0,0.0,0.0
+5,5,0.3749998295680158,560.7312193890102,-0.006873782258480787,-0.0058157010935246944,-0.0039020278491079807,-0.0011212355457246304,-0.0009470735676586628,-0.003936932887881994,-0.001121701207011938,-0.0009480114094913006,-7.287599146366119e-06,1.0672956705093384e-06,4.637986421585083e-07,7.417052984237671e-06,-1.0095536708831787e-06,-4.023313522338867e-07,3.477558493614197e-05,4.079192876815796e-07,8.763745427131653e-07,3.477558493614197e-05,4.079192876815796e-07,8.763745427131653e-07,1.2945383787155151e-07,5.774199962615967e-08,6.146728992462158e-08,0.0,0.0,0.0,0.00010885205119848251,1.6354024410247803e-06,1.6754493117332458e-06,0.0,0.0,0.0
+6,6,0.46874973195382685,560.7273077829741,-0.007863933686167002,-0.0066518173553049564,-0.003911606036126614,-0.0009901514276862144,-0.000836116261780262,-0.003938451875001192,-0.0009906026534736156,-0.0008363532833755016,-4.966277629137039e-06,1.1599622666835785e-06,1.234002411365509e-07,4.9192458391189575e-06,-1.2051314115524292e-06,-1.993030309677124e-07,2.6892870664596558e-05,4.9639493227005e-07,3.129243850708008e-07,2.6892870664596558e-05,4.9639493227005e-07,3.129243850708008e-07,-4.7031790018081665e-08,-4.516914486885071e-08,-7.59027898311615e-08,0.0,0.0,0.0,0.00013574492186307907,2.1317973732948303e-06,1.9883736968040466e-06,0.0,0.0,0.0
+7,7,0.4687521208060999,560.7233943245374,-0.008734654169529676,-0.0073870024643838406,-0.003913458436727524,-0.0008707204833626747,-0.0007351851090788841,-0.003936384338885546,-0.0008714343421161175,-0.0007349248044192791,1.7766840755939484e-05,1.440197229385376e-05,7.420778274536133e-06,-1.7741695046424866e-05,-1.4455989003181458e-05,-7.407739758491516e-06,2.290075644850731e-05,7.67875462770462e-07,-2.7334317564964294e-07,2.290075644850731e-05,7.67875462770462e-07,-2.7334317564964294e-07,2.514570951461792e-08,-5.4016709327697754e-08,1.30385160446167e-08,0.0,0.0,0.0,0.00015864567831158638,2.8996728360652924e-06,1.7150305211544037e-06,0.0,0.0,0.0
+8,8,0.4687808518052075,560.7194780893624,-0.009498408995568752,-0.008031456731259823,-0.00391623517498374,-0.0007637548260390759,-0.0006444542668759823,-0.003933582454919815,-0.0007642609998583794,-0.0006437832489609718,0.00016007013618946075,8.850079029798508e-05,5.473848432302475e-05,-0.00016002170741558075,-8.852966129779816e-05,-5.477108061313629e-05,1.7298851162195206e-05,5.350448191165924e-07,-6.384216248989105e-07,1.7298851162195206e-05,5.350448191165924e-07,-6.384216248989105e-07,4.842877388000488e-08,-2.8870999813079834e-08,-3.259629011154175e-08,0.0,0.0,0.0,0.00017594452947378159,3.4347176551818848e-06,1.0766088962554932e-06,0.0,0.0,0.0
+9,9,0.46888398548910104,560.7155580227263,-0.010167959611862898,-0.008595113176852465,-0.003920066636055708,-0.0006695506162941456,-0.0005636564455926418,-0.003930842503905296,-0.0006690975278615952,-0.0005629975348711014,0.0006066383793950081,0.0002762451767921448,0.00018928851932287216,-0.0006066281348466873,-0.0002762097865343094,-0.00018923543393611908,1.0765623301267624e-05,-4.884786903858185e-07,-7.119961082935333e-07,1.0765623301267624e-05,-4.884786903858185e-07,-7.119961082935333e-07,1.0244548320770264e-08,3.5390257835388184e-08,5.3085386753082275e-08,0.0,0.0,0.0,0.0001867101527750492,2.9462389647960663e-06,3.6461278796195984e-07,0.0,0.0,0.0
+10,10,0.46903176896324594,560.7116407523863,-0.01075396640226245,-0.009087595622986555,-0.003917270340025425,-0.0005860067903995514,-0.0004924824461340904,-0.0039285351522266865,-0.0005857185460627079,-0.0004924158565700054,0.001471752766519785,0.0005768421106040478,0.0004282691515982151,-0.0014717373996973038,-0.0005768109112977982,-0.0004282798618078232,1.1249445378780365e-05,-3.1944364309310913e-07,-5.587935447692871e-08,1.1249445378780365e-05,-3.1944364309310913e-07,-5.587935447692871e-08,1.5366822481155396e-08,3.119930624961853e-08,-1.0710209608078003e-08,0.0,0.0,0.0,0.00019795959815382957,2.626795321702957e-06,3.0873343348503113e-07,0.0,0.0,0.0
+11,11,0.4691126134417028,560.7077189418487,-0.011267102789133787,-0.009519137907773256,-0.003921810537576675,-0.0005131363868713379,-0.0004315422847867012,-0.003926586825400591,-0.0005133007653057575,-0.0004316861741244793,0.0026394762098789215,0.0009217467159032822,0.0007308274507522583,-0.0026394501328468323,-0.0009217597544193268,-0.0007308013737201691,4.750210791826248e-06,1.7741695046424866e-07,1.1781230568885803e-07,4.750210791826248e-06,1.7741695046424866e-07,1.1781230568885803e-07,2.60770320892334e-08,-1.30385160446167e-08,2.60770320892334e-08,0.0,0.0,0.0,0.00020270980894565582,2.804212272167206e-06,4.2654573917388916e-07,0.0,0.0,0.0
+12,12,0.46901560970475215,560.7038032673299,-0.011718058958649635,-0.009898302145302296,-0.003915674518793821,-0.00045095616951584816,-0.0003791642375290394,-0.0039251805283129215,-0.00045116664841771126,-0.00037938589230179787,0.003811669535934925,0.0012245913967490196,0.0010236278176307678,-0.0038117188960313797,-0.0012245867401361465,-0.001023637130856514,9.55536961555481e-06,2.0582228899002075e-07,2.3096799850463867e-07,9.55536961555481e-06,2.0582228899002075e-07,2.3096799850463867e-07,-4.936009645462036e-08,4.6566128730773926e-09,-9.313225746154785e-09,0.0,0.0,0.0,0.00021226517856121063,3.0100345611572266e-06,6.575137376785278e-07,0.0,0.0,0.0
+13,13,0.46940153309401067,560.6998843806796,-0.012116494122892618,-0.010233358014374971,-0.00391888665035367,-0.00039843516424298286,-0.0003350558690726757,-0.003924091346561909,-0.00039816368371248245,-0.00033517926931381226,0.004714041016995907,0.0014252373948693275,0.0012384280562400818,-0.004714064300060272,-0.0014252476394176483,-0.0012384429574012756,5.227979272603989e-06,-2.612359821796417e-07,1.3830140233039856e-07,5.227979272603989e-06,-2.612359821796417e-07,1.3830140233039856e-07,-2.3283064365386963e-08,-1.0244548320770264e-08,-1.4901161193847656e-08,0.0,0.0,0.0,0.00021749315783381462,2.748798578977585e-06,7.958151400089264e-07,0.0,0.0,0.0
+14,14,0.37547977019595935,560.695968686603,-0.012470003217458725,-0.010531187988817692,-0.003915694076567888,-0.0003535090945661068,-0.0002978299744427204,-0.00392324011772871,-0.0003537451848387718,-0.00029775500297546387,0.005242751911282539,0.0015017995610833168,0.0013365093618631363,-0.005242764949798584,-0.0015017539262771606,-0.0013365447521209717,7.559079676866531e-06,1.9045546650886536e-07,-3.958120942115784e-08,7.559079676866531e-06,1.9045546650886536e-07,-3.958120942115784e-08,-1.30385160446167e-08,4.563480615615845e-08,-3.5390257835388184e-08,0.0,0.0,0.0,0.00022505223751068115,2.93925404548645e-06,7.562339305877686e-07,0.0,0.0,0.0
+15,15,0.46931915536962354,560.6920553292148,-0.012786881532520056,-0.010797811206430197,-0.003913357388228178,-0.0003168783150613308,-0.00026662321761250496,-0.003922352101653814,-0.00031696120277047157,-0.0002668178640305996,0.005457909312099218,0.0014622039161622524,0.0013122227974236012,-0.00545794703066349,-0.0014622155576944351,-0.0013121794909238815,9.032431989908218e-06,9.452924132347107e-08,1.5133991837501526e-07,9.032431989908218e-06,9.452924132347107e-08,1.5133991837501526e-07,-3.771856427192688e-08,-1.1641532182693481e-08,4.330649971961975e-08,0.0,0.0,0.0,0.00023408466950058937,3.0337832868099213e-06,9.075738489627838e-07,0.0,0.0,0.0
+16,16,0.4688354158197654,560.6881414898671,-0.013073210138827562,-0.011039237957447767,-0.0039138393476605415,-0.00028632860630750656,-0.0002414267510175705,-0.00392143102362752,-0.00028690462931990623,-0.0002415659837424755,0.005488332826644182,0.0013348772190511227,0.0011904998682439327,-0.005488375201821327,-0.001334870234131813,-0.0011905189603567123,7.634051144123077e-06,5.690380930900574e-07,1.5832483768463135e-07,7.634051144123077e-06,5.690380930900574e-07,1.5832483768463135e-07,-4.237517714500427e-08,6.984919309616089e-09,-1.909211277961731e-08,0.0,0.0,0.0,0.00024171872064471245,3.6028213798999786e-06,1.0658986866474152e-06,0.0,0.0,0.0
+17,17,0.4688642199257324,560.6842309772037,-0.013335466850548983,-0.011260137427598238,-0.003910512663424015,-0.0002622567117214203,-0.00022089947015047073,-0.003920585848391056,-0.0002631489187479019,-0.0002216007560491562,0.005444665905088186,0.001153834629803896,0.0010090763680636883,-0.005444658920168877,-0.0011538397520780563,-0.0010091308504343033,1.00662000477314e-05,8.973293006420135e-07,7.557682693004608e-07,1.00662000477314e-05,8.973293006420135e-07,7.557682693004608e-07,6.984919309616089e-09,-5.122274160385132e-09,-5.448237061500549e-08,0.0,0.0,0.0,0.00025178492069244385,4.500150680541992e-06,1.821666955947876e-06,0.0,0.0,0.0
+18,18,0.46904972325243455,560.6803212598898,-0.013579126913100481,-0.01146557042375207,-0.003909717313945293,-0.0002436600625514984,-0.00020543299615383148,-0.003919912502169609,-0.0002440977841615677,-0.00020573288202285767,0.005378367379307747,0.0009484421461820602,0.0008058762177824974,-0.005378358066082001,-0.0009484663605690002,-0.0008058585226535797,1.0185874998569489e-05,4.6193599700927734e-07,2.8219074010849e-07,1.0185874998569489e-05,4.6193599700927734e-07,2.8219074010849e-07,9.313225746154785e-09,-2.421438694000244e-08,1.7695128917694092e-08,0.0,0.0,0.0,0.00026197079569101334,4.9620866775512695e-06,2.103857696056366e-06,0.0,0.0,0.0
+19,19,0.4690241690953882,560.6764128012583,-0.013806662522256374,-0.01165736373513937,-0.003908458631485701,-0.00022753560915589333,-0.0001917933113873005,-0.003919640555977821,-0.00022763200104236603,-0.00019236188381910324,0.005283908452838659,0.0007355022244155407,0.0006050593219697475,-0.005283920094370842,-0.0007355231791734695,-0.0006051156669855118,1.1193566024303436e-05,1.1734664440155029e-07,6.249174475669861e-07,1.1193566024303436e-05,1.1734664440155029e-07,6.249174475669861e-07,-1.1641532182693481e-08,-2.0954757928848267e-08,-5.634501576423645e-08,0.0,0.0,0.0,0.00027316436171531677,5.07943332195282e-06,2.728775143623352e-06,0.0,0.0,0.0
+20,20,0.4691149902535097,560.6725037032738,-0.014019680209457874,-0.01183774508535862,-0.003909097984433174,-0.00021301768720149994,-0.00018038135021924973,-0.003919586073607206,-0.00021268753334879875,-0.00018017226830124855,0.0051221540197730064,0.000519266352057457,0.0004148585721850395,-0.005122151225805283,-0.000519242137670517,-0.0004148446023464203,1.0485295206308365e-05,-3.543682396411896e-07,-2.230517566204071e-07,1.0485295206308365e-05,-3.543682396411896e-07,-2.230517566204071e-07,2.7939677238464355e-09,2.421438694000244e-08,1.3969838619232178e-08,0.0,0.0,0.0,0.00028364965692162514,4.72506508231163e-06,2.505723387002945e-06,0.0,0.0,0.0
+21,21,0.46903467995095127,560.6685956828296,-0.01421999093145132,-0.01200737152248621,-0.003908020444214344,-0.00020031072199344635,-0.00016962643712759018,-0.003919499460607767,-0.0001992243342101574,-0.00016904575750231743,0.0048424312844872475,0.0002950672060251236,0.00023025646805763245,-0.00484243780374527,-0.00029502809047698975,-0.0002302899956703186,1.1485535651445389e-05,-1.1255033314228058e-06,-5.471520125865936e-07,1.1485535651445389e-05,-1.1255033314228058e-06,-5.471520125865936e-07,-6.51925802230835e-09,3.91155481338501e-08,-3.3527612686157227e-08,0.0,0.0,0.0,0.0002951351925730705,3.5995617508888245e-06,1.9585713744163513e-06,0.0,0.0,0.0
+22,22,0.4690269226422474,560.6646860563196,-0.014409893658012152,-0.01216775132343173,-0.003909626509994268,-0.00018990272656083107,-0.0001603798009455204,-0.003919223323464394,-0.00018808525055646896,-0.00015935394912958145,0.004410987254232168,5.6739430874586105e-05,4.135677590966225e-05,-0.0044109877198934555,-5.675666034221649e-05,-4.13600355386734e-05,9.597279131412506e-06,-1.80024653673172e-06,-1.0225921869277954e-06,9.597279131412506e-06,-1.80024653673172e-06,-1.0225921869277954e-06,-4.656612873077393e-10,-1.7229467630386353e-08,-3.259629011154175e-09,0.0,0.0,0.0,0.00030473247170448303,1.7993152141571045e-06,9.359791874885559e-07,0.0,0.0,0.0
+23,23,0.46895167590501197,560.6607814244926,-0.014590884558856487,-0.012320364825427532,-0.0039046318270266056,-0.00018099090084433556,-0.00015261350199580193,-0.003918746951967478,-0.00017994502559304237,-0.00015195319429039955,0.0038275266997516155,-0.00019492162391543388,-0.00015757465735077858,-0.0038275402039289474,0.0001948866993188858,0.0001576002687215805,1.4128629118204117e-05,-1.010950654745102e-06,-6.859190762042999e-07,1.4128629118204117e-05,-1.010950654745102e-06,-6.859190762042999e-07,-1.3504177331924438e-08,-3.4924596548080444e-08,2.561137080192566e-08,0.0,0.0,0.0,0.00031886110082268715,7.883645594120026e-07,2.50060111284256e-07,0.0,0.0,0.0
+24,24,0.46890732263511536,560.6568783186376,-0.014766339212656021,-0.012467360123991966,-0.003903105854988098,-0.00017545465379953384,-0.00014699529856443405,-0.003918208181858063,-0.00017489027231931686,-0.00014702323824167252,0.0031356504186987877,-0.0004478944465517998,-0.00036316923797130585,-0.003135625272989273,0.00044789910316467285,0.00036318227648735046,1.5077181160449982e-05,-5.690380930900574e-07,1.4901161193847656e-08,1.5077181160449982e-05,-5.690380930900574e-07,1.4901161193847656e-08,2.514570951461792e-08,4.6566128730773926e-09,1.30385160446167e-08,0.0,0.0,0.0,0.00033393828198313713,2.193264663219452e-07,2.6496127247810364e-07,0.0,0.0,0.0

research/fine_surface_joint_20261014/suction_propagation.csv

@@ -0,0 +1,97 @@
+metric,time,signal,baseline,absolute,any_crossed,peak_crossed,x,y,q
+coarse_interface_u,1,0.0,0.0,0.0,False,False,3.5,3.5,
+coarse_interface_u,2,0.0,2.63417801721126e-09,2.63417801721126e-09,False,False,3.5,3.5,
+coarse_interface_u,3,0.0,2.63417801721126e-09,2.63417801721126e-09,False,False,3.5,3.5,
+coarse_interface_u,4,0.0,6.585443742795605e-08,6.585443742795605e-08,False,False,3.5,3.5,
+coarse_interface_u,5,0.0,1.2644051067663912e-07,1.2644051067663912e-07,False,False,3.5,3.5,
+coarse_interface_u,6,1.9186142054314123e-07,1.4528626697542904e-07,4.660334981743319e-08,False,False,20.5,12.5,
+coarse_interface_u,7,4.091979903802207e-06,2.0116559817931723e-07,3.8910894220610345e-06,True,True,20.5,13.5,
+coarse_interface_u,8,2.311182477441854e-05,1.5646213891164667e-07,2.2955448242208372e-05,True,True,20.5,13.5,
+coarse_interface_u,9,6.767647549251264e-05,1.5646213891164667e-07,6.752003656156048e-05,True,True,20.5,13.5,
+coarse_interface_u,10,0.0001337150378395613,9.750014426779573e-08,0.00013361820089187484,True,True,20.5,13.5,
+coarse_interface_u,11,0.00020218710417179174,1.1795114315203827e-07,0.00020207424859213912,True,True,20.5,13.5,
+coarse_interface_u,12,0.0002568344215192973,7.455233297611785e-08,0.00025676033381921514,True,True,20.5,14.5,
+coarse_interface_u,13,0.00028408902792915417,3.83541997932092e-08,0.00028405737088288245,True,True,20.5,14.5,
+coarse_interface_u,14,0.0002878189146376881,3.003423681142711e-08,0.0002878487673732557,True,True,20.5,15.5,
+coarse_interface_u,15,0.00027841070597653145,6.516592454722021e-08,0.0002784504724796873,True,True,20.5,16.5,
+coarse_interface_u,16,0.0002652060129478788,1.006517304071618e-07,0.00026516043242156813,True,True,20.5,17.5,
+coarse_interface_u,17,0.0002512614305767982,9.86322156278415e-08,0.00025121946497710793,True,True,20.5,18.5,
+coarse_interface_u,18,0.00023870047136388868,1.0286787296380317e-07,0.00023871152377663379,True,True,20.5,19.5,
+coarse_interface_u,19,0.00022600944747549703,7.783088195871973e-08,0.00022597593519089906,True,True,20.5,20.5,
+coarse_interface_u,20,0.00021431184774763036,8.503127640307697e-08,0.00021428571329826077,True,True,20.5,20.5,
+coarse_interface_u,21,0.00019575956040664123,7.893743237430962e-08,0.00019568735051647606,True,True,20.5,20.5,
+coarse_interface_u,22,0.00017544769865184928,5.2749351285234925e-08,0.00017539495458202247,True,True,20.5,20.5,
+coarse_interface_u,23,0.00016267972853265252,8.178685339035058e-08,0.00016263380071292468,True,True,20.5,14.5,
+coarse_interface_u,24,0.00015978262119523088,6.715860617082587e-08,0.00015974108955029212,True,True,20.5,14.5,
+coarse_bulk_u,1,0.0,0.0,0.0,False,False,0.5,0.5,
+coarse_bulk_u,2,0.0,0.0,0.0,False,False,0.5,0.5,
+coarse_bulk_u,3,0.0,0.0,0.0,False,False,0.5,0.5,
+coarse_bulk_u,4,0.0,0.0,0.0,False,False,0.5,0.5,
+coarse_bulk_u,5,0.0,0.0,0.0,False,False,0.5,0.5,
+coarse_bulk_u,6,0.0,0.0,0.0,False,False,0.5,0.5,
+coarse_bulk_u,7,7.82310665831233e-08,2.12341462371735e-07,1.341103957886117e-07,False,False,21.5,13.5,
+coarse_bulk_u,8,1.9454402095498935e-06,2.458690369633922e-07,1.6999616130940679e-06,True,False,21.5,13.5,
+coarse_bulk_u,9,1.177304052098705e-05,1.564621179284487e-07,1.1616666785920634e-05,True,True,21.5,13.5,
+coarse_bulk_u,10,3.768468268046806e-05,1.0327184058071679e-07,3.758247372213889e-05,True,True,21.5,13.5,
+coarse_bulk_u,11,8.249500148168606e-05,4.214683516511236e-08,8.24651319357052e-05,True,True,21.5,13.5,
+coarse_bulk_u,12,0.00013911632875122394,5.890198697622995e-09,0.00013911827376976638,True,True,21.5,13.5,
+coarse_bulk_u,13,0.0001940498057077554,4.806920811870088e-08,0.00019408186753519264,True,True,21.5,14.5,
+coarse_bulk_u,14,0.00023606781230746572,3.215422633434082e-08,0.0002360762872001673,True,True,21.5,14.5,
+coarse_bulk_u,15,0.0002548619441637075,3.434546877545681e-08,0.0002548861189892584,True,True,21.5,14.5,
+coarse_bulk_u,16,0.00025644070267233306,0.0,0.00025644070267233306,True,True,21.5,15.5,
+coarse_bulk_u,17,0.00024779621047094693,6.606481633104396e-08,0.00024773971117601724,True,True,21.5,16.5,
+coarse_bulk_u,18,0.00023605776538134437,6.929437569595666e-08,0.00023599681787995022,True,True,21.5,17.5,
+coarse_bulk_u,19,0.00022483643371073512,1.0390817551817351e-07,0.00022475474112598463,True,True,21.5,19.5,
+coarse_bulk_u,20,0.00021493179783986402,1.042082306083734e-07,0.0002148440172340466,True,True,22.5,18.5,
+coarse_bulk_u,21,0.00020607683833491475,9.442706670805767e-08,0.00020599766123702618,True,True,21.5,20.5,
+coarse_bulk_u,22,0.0001975946374450119,5.556802130737047e-08,0.0001975402371312418,True,True,22.5,20.5,
+coarse_bulk_u,23,0.00018932913257368715,4.4703464263670685e-08,0.00018936187038743642,True,True,22.5,21.5,
+coarse_bulk_u,24,0.000179693129058515,9.995996742145265e-08,0.00017978823062286703,True,True,22.5,22.5,
+fine_band_neq,1,0.0,3.000928300994632e-09,3.000928300994632e-09,False,False,4.25,4.25,
+fine_band_neq,2,0.0,4.501393077727123e-09,4.501393077727123e-09,False,False,4.25,4.25,
+fine_band_neq,3,0.0,2.069606169774474e-08,2.069606169774474e-08,False,False,4.25,4.25,
+fine_band_neq,4,0.0,4.1392115429639276e-09,4.1392115429639276e-09,False,False,4.25,4.25,
+fine_band_neq,5,0.0,4.1392115429639276e-09,4.1392115429639276e-09,False,False,4.25,4.25,
+fine_band_neq,6,3.733491271140643e-07,9.934099098884985e-09,3.832832262129493e-07,True,True,19.75,13.25,
+fine_band_neq,7,2.0319504568933056e-06,9.934099098884985e-09,2.0418845559921905e-06,True,True,19.75,13.25,
+fine_band_neq,8,5.038458095685261e-06,9.934099098884985e-09,5.048392194784146e-06,True,True,19.75,13.75,
+fine_band_neq,9,7.299560118911863e-06,1.1589783133203468e-08,7.3111499020450665e-06,True,True,19.75,14.25,
+fine_band_neq,10,7.386030289713297e-06,9.106256526614231e-09,7.395136546239911e-06,True,True,19.75,15.25,
+fine_band_neq,11,6.856089636353424e-06,5.794905943989903e-09,6.850294730409434e-06,True,True,19.75,17.25,
+fine_band_neq,12,6.198413803892855e-06,6.622735776451449e-09,6.201725167243044e-06,True,True,19.75,18.25,
+fine_band_neq,13,5.319780258750129e-06,4.139212333997833e-09,5.316468887739401e-06,True,True,19.75,19.25,
+fine_band_neq,14,5.283330124894459e-06,4.967056432825245e-09,5.278363068461633e-06,True,True,19.75,19.75,
+fine_band_neq,15,3.967651562297725e-06,4.553132745832578e-09,3.964340190287796e-06,True,True,19.75,19.75,
+fine_band_neq,16,3.7551803555024854e-06,6.622738135675377e-09,3.74855761736681e-06,True,True,19.75,16.75,
+fine_band_neq,17,3.5764174459163023e-06,6.622736969941201e-09,3.5755896076739013e-06,True,True,19.75,17.75,
+fine_band_neq,18,3.230913338148067e-06,1.7384672978959514e-08,3.2135286651691075e-06,True,True,19.75,18.75,
+fine_band_neq,19,3.160623228692927e-06,9.934106745546067e-09,3.1631067707871274e-06,True,True,19.75,19.75,
+fine_band_neq,20,3.2258282446351316e-06,8.278412177986638e-09,3.217549832457145e-06,True,True,19.75,19.75,
+fine_band_neq,21,2.8042083782819915e-06,1.1589792486832451e-08,2.8124868040602102e-06,True,True,19.75,19.75,
+fine_band_neq,22,2.2509872253939633e-06,1.241763983306221e-09,2.2509872265041864e-06,True,True,19.75,19.75,
+fine_band_neq,23,1.7420757160158118e-06,2.0696062086322797e-09,1.7412478748313198e-06,True,True,19.75,19.75,
+fine_band_neq,24,1.7765396425617475e-06,7.864502313270627e-09,1.7773674825805053e-06,True,True,4.25,8.25,
+transfer_neq,1,0.0,1.5004641487625925e-09,1.5004641487625925e-09,False,False,3.5,3.5,6
+transfer_neq,2,0.0,3.000928290586291e-09,3.000928290586291e-09,False,False,3.5,3.5,6
+transfer_neq,3,0.0,3.000928290586291e-09,3.000928290586291e-09,False,False,3.5,3.5,6
+transfer_neq,4,0.0,6.881438113781613e-09,6.881438113781613e-09,False,False,3.5,3.5,6
+transfer_neq,5,0.0,6.467520081987477e-09,6.467520081987477e-09,False,False,3.5,3.5,6
+transfer_neq,6,4.1392107713589255e-08,1.7384695072397705e-08,5.877680278598696e-08,False,False,20.5,12.5,1
+transfer_neq,7,1.0066612778220074e-06,1.4901174696935193e-08,1.0215624525189426e-06,True,True,20.5,13.5,1
+transfer_neq,8,5.309127742339492e-06,7.450589978308386e-09,5.316578332317801e-06,True,True,20.5,13.5,1
+transfer_neq,9,1.3828140735375194e-05,4.967061900673642e-09,1.3833107797275868e-05,True,True,20.5,13.5,1
+transfer_neq,10,2.2517463971680196e-05,7.0366557441969846e-09,2.2510427315936e-05,True,True,20.5,13.5,1
+transfer_neq,11,2.6241128339946074e-05,8.692339972804497e-09,2.623243599997327e-05,True,True,20.5,14.5,1
+transfer_neq,12,2.301816285713021e-05,1.0761948318616099e-08,2.3007400908811593e-05,True,True,20.5,14.5,1
+transfer_neq,13,1.7994855878653016e-05,6.6227364148296886e-09,1.7988233142238186e-05,True,True,16.5,20.5,3
+transfer_neq,14,1.325129952600701e-05,3.725288785783043e-09,1.3247574237221227e-05,True,True,17.5,20.5,3
+transfer_neq,15,1.102909472382868e-05,1.7074248230553035e-09,1.1030802148651736e-05,True,True,20.5,20.5,5
+transfer_neq,16,1.0516298765687881e-05,3.777030622292843e-09,1.0512521735065589e-05,True,True,20.5,20.5,5
+transfer_neq,17,7.773419831963446e-06,1.5522043823879006e-09,7.771867627581058e-06,True,True,20.5,20.5,5
+transfer_neq,18,6.4455684595787766e-06,2.4835230261199825e-09,6.4430849365526566e-06,True,True,16.5,3.5,4
+transfer_neq,19,6.882601883972939e-06,4.553130164564045e-09,6.8780487538083745e-06,True,True,16.5,3.5,4
+transfer_neq,20,8.06233390339417e-06,1.6556842147297246e-09,8.0639895876089e-06,True,True,3.5,15.5,2
+transfer_neq,21,9.1730277525931e-06,4.553133203799575e-09,9.1684746193893e-06,True,True,3.5,15.5,2
+transfer_neq,22,9.87202560678857e-06,1.241762831449833e-09,9.87078384395712e-06,True,True,3.5,15.5,2
+transfer_neq,23,9.794260003304078e-06,3.725291089495819e-09,9.790534712214582e-06,True,True,3.5,16.5,2
+transfer_neq,24,8.98628849999028e-06,6.208816516473092e-09,8.992497316506753e-06,True,True,3.5,17.5,2

research/fine_surface_joint_20261014/suction_summary.json

@@ -0,0 +1,170 @@
+{
+  "speed": -0.002,
+  "initial_leaf": [
+    560.7500041779131,
+    0.0,
+    0.0
+  ],
+  "final_leaf": [
+    560.6568783186376,
+    -0.014766339212656021,
+    -0.012467360123991966
+  ],
+  "raw_residual": [
+    0.00033393828198313713,
+    2.193264663219452e-07,
+    2.6496127247810364e-07
+  ],
+  "exact_average_residual": [
+    0.00033389730378985405,
+    1.0663643479347229e-07,
+    7.683411240577698e-08
+  ],
+  "cumulative": {
+    "boundary": [
+      -0.0934597565792501,
+      -0.014766445849090815,
+      -0.012467436958104372
+    ],
+    "fine_transfer": [
+      0.06703074648976326,
+      0.011895491741597652,
+      0.010098854079842567
+    ],
+    "coarse_transfer": [
+      -0.06703078746795654,
+      -0.011895604431629181,
+      -0.01009904220700264
+    ],
+    "rounding": [
+      0.00033393828198313713,
+      2.193264663219452e-07,
+      2.6496127247810364e-07
+    ],
+    "average": [
+      -4.0978193283081055e-08,
+      -1.126900315284729e-07,
+      -1.8812716007232666e-07
+    ]
+  },
+  "checks": {
+    "validity": true,
+    "geometry_unchanged": true,
+    "boundary_count": 48,
+    "collision_count": 72,
+    "local_collision": true,
+    "local_regime": true,
+    "bfl": true,
+    "transfer_rounding": true,
+    "interval_closure": true,
+    "cumulative_closure": true,
+    "propagation": true,
+    "drive_sign": true
+  },
+  "max_collision_ratio": 0.5285112236646456,
+  "max_collision_error": 1.6477090769573266e-07,
+  "max_bfl_error": 1.2498588997100768e-08,
+  "max_interval_closure": 0.0,
+  "drive_mass": -0.07426865905109248,
+  "propagation": {
+    "coarse_interface_u": {
+      "threshold": 1e-06,
+      "baseline_factor": 10,
+      "first_arrival": {
+        "time": 7,
+        "signal": 4.091979903802207e-06,
+        "baseline": 2.0116559817931723e-07,
+        "absolute": 3.8910894220610345e-06,
+        "x": 20.5,
+        "y": 13.5
+      },
+      "peak": {
+        "metric": "coarse_interface_u",
+        "time": 14,
+        "signal": 0.0002878189146376881,
+        "baseline": 3.003423681142711e-08,
+        "absolute": 0.0002878487673732557,
+        "any_crossed": true,
+        "peak_crossed": true,
+        "x": 20.5,
+        "y": 15.5
+      }
+    },
+    "coarse_bulk_u": {
+      "threshold": 1e-06,
+      "baseline_factor": 10,
+      "first_arrival": {
+        "time": 8,
+        "signal": 1.0179867624062477e-06,
+        "baseline": 1.005827957173589e-07,
+        "absolute": 9.175116276483961e-07,
+        "x": 13.5,
+        "y": 21.5
+      },
+      "peak": {
+        "metric": "coarse_bulk_u",
+        "time": 16,
+        "signal": 0.00025644070267233306,
+        "baseline": 0.0,
+        "absolute": 0.00025644070267233306,
+        "any_crossed": true,
+        "peak_crossed": true,
+        "x": 21.5,
+        "y": 15.5
+      }
+    },
+    "fine_band_neq": {
+      "threshold": 1e-07,
+      "baseline_factor": 10,
+      "first_arrival": {
+        "time": 6,
+        "signal": 3.733491271140643e-07,
+        "baseline": 9.934099098884985e-09,
+        "absolute": 3.832832262129493e-07,
+        "x": 19.75,
+        "y": 13.25
+      },
+      "peak": {
+        "metric": "fine_band_neq",
+        "time": 10,
+        "signal": 7.386030289713297e-06,
+        "baseline": 9.106256526614231e-09,
+        "absolute": 7.395136546239911e-06,
+        "any_crossed": true,
+        "peak_crossed": true,
+        "x": 19.75,
+        "y": 15.25
+      }
+    },
+    "transfer_neq": {
+      "threshold": 1e-07,
+      "baseline_factor": 10,
+      "first_arrival": {
+        "time": 7,
+        "signal": 1.0066612778220074e-06,
+        "baseline": 1.4901174696935193e-08,
+        "absolute": 1.0215624525189426e-06,
+        "q": 1,
+        "x": 20.5,
+        "y": 13.5
+      },
+      "peak": {
+        "metric": "transfer_neq",
+        "time": 11,
+        "signal": 2.6241128339946074e-05,
+        "baseline": 8.692339972804497e-09,
+        "absolute": 2.623243599997327e-05,
+        "any_crossed": true,
+        "peak_crossed": true,
+        "q": 1,
+        "x": 20.5,
+        "y": 14.5
+      }
+    }
+  },
+  "raw_minus_zero": [
+    0.0001048198901116848,
+    -5.686189979314804e-06,
+    -3.6512501537799835e-06
+  ]
+}

research/fine_surface_joint_20261014/validate.py

@@ -0,0 +1,347 @@
+"""Isolated, pre-registered 24-interval validation; never imported by pytest."""
+import csv
+import hashlib
+import importlib.util
+import json
+import struct
+from pathlib import Path
+from unittest.mock import patch
+
+import numpy as np
+
+ROOT = Path('/home/frank14f/CelerisLab')
+OUT = Path(__file__).resolve().parent
+spec = importlib.util.spec_from_file_location('accepted_hooks', ROOT/'tests/validation/multigrid/test_fine_surface_gpu.py')
+h = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(h)
+EPS = np.finfo(np.float32).eps
+M = h.MOMENTS
+
+
+def save(name, obj):
+    text = json.dumps(obj, indent=2, allow_nan=False)+'\n'
+    assert len(text) <= 40000, (name, len(text))
+    (OUT/name).write_text(text)
+
+
+def table(name, rows):
+    with (OUT/name).open('w') as file:
+        writer = csv.DictWriter(file, fieldnames=list(rows[0]))
+        writer.writeheader()
+        writer.writerows(rows)
+    assert (OUT/name).stat().st_size <= 40000
+
+
+def vec(row, prefix, values):
+    row.update({prefix+'_'+axis: float(value) for axis, value in zip(('m', 'px', 'py'), values)})
+
+
+def equilibrium(values):
+    a = values.astype(float)
+    rho = a.sum(axis=0)
+    u = M[1:]@a/rho
+    cu = h.CX[:, None]*u[0]+h.CY[:, None]*u[1]
+    eq = h.W[:, None]*rho*(1+3*cu+4.5*cu*cu-1.5*(u*u).sum(axis=0))
+    return eq, u, rho
+
+
+def pull(a):
+    return np.stack([np.roll(a[q], (h.CY[q], h.CX[q]), (0, 1)) for q in range(9)])
+
+
+def collision(incoming, output, omega, area):
+    """Local observed drift; no access to global initial/final states or ledger."""
+    a, b = incoming.astype(float), output.astype(float)
+    eq, u, rho = equilibrium(a)
+    ideal = (1-omega)*a+omega*eq
+    tolerance = 8*EPS*abs(a)
+    error = abs(b-ideal)
+    # Independent local FP64 oracle plus a measured (not inferred) drift.
+    return dict(drift=area*(M@(b-a).sum(axis=1)),
+                ideal_defect=area*(M@(ideal-a).sum(axis=1)),
+                measured_rounding=area*(M@(b-ideal).sum(axis=1)),
+                max_error=float(error.max()), max_ratio=float((error/tolerance).max()),
+                regime=bool(np.isfinite(b).all() and np.all(a>0) and np.all(b>0) and np.all((rho>.9)&(rho<1.1))
+                            and np.max(np.linalg.norm(u, axis=0))<.05))
+
+
+def coarse_arrivals(before, fine, active, p):
+    """Independent midpoint map; FP32 addition order checked against actual map."""
+    got = pull(before)
+    ideal = got.astype(float)
+    targets, sources = [], []
+    for y, x in np.argwhere(active):
+        for q in range(1, 9):
+            if 4 <= x+.5-h.CX[q]/2 <= 20 and 4 <= y+.5-h.CY[q]/2 <= 20:
+                a, b = 4+2*(x-4), 4+2*(y-4)
+                children = fine[q, b:b+2, a:a+2].ravel()
+                assert len(children) == 4 and np.isfinite(children).all()
+                got[q, y, x] = np.float32(.25)*(((children[0]+children[1])+children[2])+children[3])
+                ideal[q, y, x] = children.astype(float).sum()/4
+                targets.append(q*576+y*24+x)
+                sources.append([q*1600+(b+dy)*40+a+dx for dy in (0, 1) for dx in (0, 1)])
+    order = np.argsort(targets)
+    porder = np.argsort(p.coalesce_coarse)
+    np.testing.assert_array_equal(np.array(targets)[order], p.coalesce_coarse[porder])
+    np.testing.assert_array_equal(np.array(sources)[order], p.coalesce_fine[porder])
+    assert np.isfinite(got[:, active]).all()
+    flux = (got[:, active].astype(float)-before[:, active]).sum(axis=1)
+    rounding = (got[:, active].astype(float)-ideal[:, active]).sum(axis=1)
+    children = fine.ravel()[p.coalesce_fine]
+    bound = 3*(EPS/2)/(1-3*(EPS/2))*np.abs(children.astype(float)).sum(axis=1)/4
+    differences = abs(got.ravel()[p.coalesce_coarse]-ideal.ravel()[p.coalesce_coarse])
+    return got, M@flux, M@rounding, float(np.max(differences/bound))
+
+
+def observation(values, mask):
+    eq, u, _ = equilibrium(values[:, mask])
+    return u, values[:, mask].astype(float)-eq
+
+
+def run(speed, label):
+    cfg = h.LBMConfig(nx=24, ny=24, viscosity=.05, velocity=0, rho=1)
+    cmask = np.ones((24, 24), bool)
+    cmask[4:20, 4:20] = False
+    source = h.object_spec(speed)
+    state = vars(source.state).copy()
+    ledger_rows, collision_rows, boundary_rows = [], [], []
+    trace = []
+    with h.CudaContext(0) as context:
+        with h.implementation.FixedPatchStepper(cfg, h.BOUNDS, context=context, fine_objects=[source]) as backend, context.activate():
+            c, f = backend._levels
+            cl, p = backend._fine_curved, backend.patch
+            geometry = {name: getattr(cl, name).copy() for name in h.GEOMETRY}
+            flags = backend.fine_boundary.flags.copy().reshape(40, 40)
+            solid = (flags & h.SOLID) != 0
+            active = backend._fine_leaf.copy()
+            fine_mesh = p.fine_kind == 0
+            band = active & np.logical_or.reduce([~np.roll(fine_mesh, (cy, cx), (0, 1))
+                                                  for cx, cy in zip(h.CX[1:], h.CY[1:])])
+            interface = np.zeros(576, bool)
+            interface[p.coalesce_coarse % 576] = True
+            interface = interface.reshape(24, 24)
+            bulk = cmask & ~interface
+            if speed == 0:
+                def coords(mask, dx, origin):
+                    yx = np.argwhere(mask)
+                    return ((yx[:, ::-1]+.5)*dx+np.array(origin)).tolist()
+                save('regions.json', dict(coarse_interface=coords(interface, 1, (0, 0)),
+                     coarse_bulk=coords(bulk, 1, (0, 0)), fine_band=coords(band, .5, (2, 2)),
+                     transfer_slots=[dict(q=int(slot//576), x=float(slot%24+.5),
+                     y=float((slot%576)//24+.5)) for slot in p.coalesce_coarse]))
+            backend.initialize(h.rest((24, 24)), h.rest((40, 40)))
+            initial = backend.download()
+            initial_m = M@(initial[0][:, cmask].sum(axis=1, dtype=float)
+                           +.25*initial[1][:, active].sum(axis=1, dtype=float))
+            previous = initial_m.copy()
+            totals = {name: np.zeros(3) for name in ('boundary', 'fine_transfer', 'coarse_transfer', 'rounding', 'average')}
+            interval = None
+            orig_b, orig_f, orig_c = backend._curved, f.kernel, c.kernel
+            omegas = []
+            for level, tau in ((c, p.tau_coarse), (f, p.tau_fine)):
+                pointer, size = level.module.get_global('d_params')
+                assert size == 20
+                omega, fx, fy, fz, count = struct.unpack('=ffffI', h.read(pointer, (size,), np.uint8).tobytes())
+                assert omega == float(np.float32(1/tau)) and (fx, fy, fz) == (0., 0., 0.)
+                omegas.append(omega)
+            omega_c, omega_f = omegas
+
+            def curved(*args, **kwargs):
+                backend._stream.synchronize()
+                before = h.read(args[0], f.shape)
+                expected = h.reflection_oracle(before, cl, speed)
+                passive = h.reflection_oracle(before, cl, None, verify_projection=False)
+                orig_b(*args, **kwargs)
+                backend._stream.synchronize()
+                staged = h.read(args[0], f.shape)
+                d, k = cl.dir.astype(int), cl.fluid_idx.astype(int)
+                values = staged.reshape(9, -1)[h.OPP[d], k+h.CX[d]+40*h.CY[d]]
+                np.testing.assert_array_equal(staged[:, active], before[:, active])
+                b, tr, _ = h.fine_flux(before, staged, active, solid)
+                exchange = h.read(cl.link_exchange_gpu, (cl.count, 3)).astype(float).sum(axis=0)
+                row = dict(step=interval['step'], substep=len(interval['boundary'])+1,
+                           time=interval['step']-1+.5*(len(interval['boundary'])+1),
+                           bfl_error=float(abs(values-expected).max()),
+                           drive_mass=.25*float((values-passive).sum()),
+                           latest_body_impulse_x=float(.25*exchange[0]), latest_body_impulse_y=float(.25*exchange[1]),
+                           latest_body_angular_impulse=float(.125*exchange[2]))
+                vec(row, 'boundary', .25*(M@b))
+                vec(row, 'fine_transfer', .25*(M@tr))
+                interval['boundary'].append(.25*(M@b))
+                interval['fine_transfer'].append(.25*(M@tr))
+                boundary_rows.append(row)
+
+            def fine(*args, **kwargs):
+                backend._stream.synchronize()
+                staged = h.read(args[0], f.shape)
+                incoming = pull(staged)[:, active]
+                orig_f(*args, **kwargs)
+                backend._stream.synchronize()
+                after = h.read(args[1], f.shape)
+                assert np.isfinite(after[:, active]).all() and np.isnan(after[:, solid]).all()
+                outer = np.ones((40, 40), bool)
+                outer[2:-2, 2:-2] = False
+                assert np.isnan(after[:, outer]).all()
+                # Inner ghost is stream-only: compare including legitimate NaNs.
+                ghost = ~fine_mesh & ~outer
+                np.testing.assert_array_equal(after[:, ghost], pull(staged)[:, ghost])
+                stat = collision(incoming, after[:, active], omega_f, .25)
+                interval['collision'].append(stat)
+                row = dict(step=interval['step'], level='fine', substep=len(interval['collision']),
+                           max_error=stat['max_error'], max_ratio=stat['max_ratio'], regime=stat['regime'])
+                for key in ('drift', 'ideal_defect', 'measured_rounding'):
+                    vec(row, key, stat[key])
+                collision_rows.append(row)
+
+            def coarse(*args, **kwargs):
+                backend._stream.synchronize()
+                before, fine = h.read(args[0], c.shape), h.read(args[2], f.shape)
+                incoming, flux, avg, ratio = coarse_arrivals(before, fine, cmask, p)
+                interval['coarse_transfer'], interval['average'] = flux, avg
+                interval['average_ratio'] = ratio
+                eq, _, _ = equilibrium(incoming[:, cmask])
+                neq = np.full(c.shape, np.nan)
+                neq[:, cmask] = incoming[:, cmask].astype(float)-eq
+                interval['transfer_neq'] = neq.ravel()[p.coalesce_coarse].copy()
+                orig_c(*args, **kwargs)
+                backend._stream.synchronize()
+                after = h.read(args[1], c.shape)
+                assert np.isfinite(after[:, cmask]).all() and np.isnan(after[:, ~cmask]).all()
+                stat = collision(incoming[:, cmask], after[:, cmask], omega_c, 1.)
+                interval['collision'].append(stat)
+                row = dict(step=interval['step'], level='coarse', substep=1,
+                           max_error=stat['max_error'], max_ratio=stat['max_ratio'], regime=stat['regime'])
+                for key in ('drift', 'ideal_defect', 'measured_rounding'):
+                    vec(row, key, stat[key])
+                collision_rows.append(row)
+
+            with patch.object(backend, '_curved', curved), patch.object(f, 'kernel', fine), patch.object(c, 'kernel', coarse):
+                for n in range(1, 25):
+                    interval = dict(step=n, boundary=[], fine_transfer=[], collision=[])
+                    backend.step(1)
+                    coarse_g, fine_g = backend.download()
+                    assert np.isfinite(coarse_g[:, cmask]).all() and np.isnan(coarse_g[:, ~cmask]).all()
+                    assert np.isfinite(fine_g[:, active]).all() and np.isnan(fine_g[:, ~active]).all()
+                    assert len(interval['boundary']) == 2 and len(interval['collision']) == 3
+                    current = M@(coarse_g[:, cmask].sum(axis=1, dtype=float)
+                                 +.25*fine_g[:, active].sum(axis=1, dtype=float))
+                    b = sum(interval['boundary'])
+                    ft = sum(interval['fine_transfer'])
+                    ct = interval['coarse_transfer']
+                    drift = sum(s['drift'] for s in interval['collision'])
+                    raw = current-previous-b-ft-ct
+                    row = dict(step=n, time=n, average_bound_ratio=interval['average_ratio'])
+                    for key, value in (('leaf', current), ('delta', current-previous), ('boundary', b),
+                                       ('fine_transfer', ft), ('coarse_transfer', ct), ('raw', raw),
+                                       ('collision_drift', drift), ('average_rounding', interval['average']),
+                                       ('closure', raw-drift)):
+                        vec(row, key, value)
+                    for key, val in (('boundary', b), ('fine_transfer', ft), ('coarse_transfer', ct),
+                                     ('rounding', drift), ('average', interval['average'])):
+                        totals[key] += val
+                    cumulative = current-initial_m-totals['boundary']-totals['fine_transfer']-totals['coarse_transfer']
+                    vec(row, 'cumulative_raw', cumulative)
+                    vec(row, 'cumulative_closure', cumulative-totals['rounding'])
+                    ledger_rows.append(row)
+                    iu, ine = observation(coarse_g, interface)
+                    bu, _ = observation(coarse_g, bulk)
+                    fu, fne = observation(fine_g, band)
+                    trace.append(dict(coarse_interface_u=iu, coarse_bulk_u=bu,
+                                      fine_band_neq=fne, transfer_neq=interval['transfer_neq']))
+                    previous = current
+                    print(label, n, 'raw', raw.tolist(), 'cumulative_raw', cumulative.tolist(), flush=True)
+            assert backend.step_count == 24 and len(boundary_rows) == 48 and len(collision_rows) == 72
+            for name, val in geometry.items():
+                np.testing.assert_array_equal(getattr(cl, name), val)
+            np.testing.assert_array_equal(flags.ravel(), backend.fine_boundary.flags)
+            assert vars(source.state) == state and source.geometry.center == source.center
+    table(label+'_ledger.csv', ledger_rows)
+    table(label+'_collisions.csv', collision_rows)
+    table(label+'_boundary.csv', boundary_rows)
+    # Small compressed diagnostic arrays, not full-field population snapshots.
+    np.savez_compressed(OUT/(label+'_signals.npz'), **{key: np.stack([t[key] for t in trace]) for key in trace[0]})
+    final = ledger_rows[-1]
+    checks = dict(validity=True, geometry_unchanged=True, boundary_count=len(boundary_rows),
+                  collision_count=len(collision_rows),
+                  local_collision=max(r['max_ratio'] for r in collision_rows)<=1,
+                  local_regime=all(r['regime'] for r in collision_rows),
+                  bfl=max(r['bfl_error'] for r in boundary_rows)<=1e-7,
+                  transfer_rounding=max(r['average_bound_ratio'] for r in ledger_rows)<=1,
+                  interval_closure=max(abs(r['closure_'+k]) for r in ledger_rows for k in ('m','px','py'))<=1e-10,
+                  cumulative_closure=max(abs(r['cumulative_closure_'+k]) for r in ledger_rows for k in ('m','px','py'))<=1e-9)
+    return trace, dict(speed=speed, initial_leaf=initial_m.tolist(), final_leaf=previous.tolist(),
+                      raw_residual=[final['cumulative_raw_'+k] for k in ('m','px','py')],
+                      exact_average_residual=(np.array([final['cumulative_raw_'+k] for k in ('m','px','py')])+totals['average']).tolist(),
+                      cumulative={k: v.tolist() for k,v in totals.items()}, checks=checks,
+                      max_collision_ratio=max(r['max_ratio'] for r in collision_rows),
+                      max_collision_error=max(r['max_error'] for r in collision_rows),
+                      max_bfl_error=max(r['bfl_error'] for r in boundary_rows),
+                      max_interval_closure=max(abs(r['closure_'+k]) for r in ledger_rows for k in ('m','px','py')),
+                      drive_mass=sum(r['drive_mass'] for r in boundary_rows))
+
+
+def compare(driven, zero, label):
+    regions = json.loads((OUT/'regions.json').read_text())
+    summaries, rows = {}, []
+    for key in driven[0]:
+        velocity = key.endswith('_u')
+        floor = 1e-6 if velocity else 1e-7
+        first, peak = None, None
+        for n, (d, z) in enumerate(zip(driven, zero), 1):
+            difference = d[key]-z[key]
+            if velocity:
+                signal = np.linalg.norm(difference, axis=0)
+                base = np.linalg.norm(z[key], axis=0)
+                absolute = np.linalg.norm(d[key], axis=0)
+            elif difference.ndim == 2:
+                signal, base, absolute = abs(difference).max(axis=0), abs(z[key]).max(axis=0), abs(d[key]).max(axis=0)
+            else:
+                signal, base, absolute = abs(difference), abs(z[key]), abs(d[key])
+            eligible = (signal>floor)&(signal>10*base)
+            idx = int(np.argmax(signal))
+            def location(i):
+                region = key.removesuffix('_u').removesuffix('_neq')
+                if key == 'transfer_neq':
+                    return regions['transfer_slots'][i]
+                return dict(zip(('x','y'), regions[region][i]))
+            record = dict(metric=key, time=n, signal=float(signal[idx]), baseline=float(base[idx]),
+                          absolute=float(absolute[idx]), any_crossed=bool(eligible.any()), peak_crossed=bool(eligible[idx]), **location(idx))
+            rows.append(record)
+            if peak is None or record['signal']>peak['signal']:
+                peak = record.copy()
+            if first is None and eligible.any():
+                i = int(np.argmax(np.where(eligible, signal, -1)))
+                first = dict(time=n, signal=float(signal[i]), baseline=float(base[i]), absolute=float(absolute[i]), **location(i))
+        summaries[key] = dict(threshold=floor, baseline_factor=10, first_arrival=first, peak=peak)
+    # q is present only for transfer populations; normalize CSV columns.
+    for row in rows:
+        row.setdefault('q', '')
+    table(label+'_propagation.csv', rows)
+    return summaries
+
+
+def main():
+    assert Path(h.CelerisLab.__file__).resolve() == ROOT/'src/CelerisLab/__init__.py'
+    assert Path(h.compiler._KERNEL_DIR).resolve() == ROOT/'src/CelerisLab/lbm/kernels'
+    frozen = json.loads((OUT/'frozen.json').read_text())
+    for path, digest in frozen['hashes'].items():
+        assert hashlib.sha256((ROOT/path).read_bytes()).hexdigest() == digest, path
+    print('SOURCE', h.CelerisLab.__file__, 'CRITERIA', frozen['frozen_utc'], flush=True)
+    traces, summaries = {}, {}
+    for label, speed in (('zero', 0.), ('blow', .002), ('suction', -.002)):
+        traces[label], summaries[label] = run(speed, label)
+        save(label+'_summary.json', summaries[label])
+    for label in ('blow','suction'):
+        summaries[label]['propagation'] = compare(traces[label], traces['zero'], label)
+        summaries[label]['raw_minus_zero'] = (np.array(summaries[label]['raw_residual'])-summaries['zero']['raw_residual']).tolist()
+        summaries[label]['checks']['propagation'] = all(s['first_arrival'] is not None for s in summaries[label]['propagation'].values())
+        summaries[label]['checks']['drive_sign'] = summaries[label]['speed']*summaries[label]['drive_mass']>0
+        save(label+'_summary.json', summaries[label])
+    passed = all(all(v for k,v in s['checks'].items() if k not in ('boundary_count','collision_count')) for s in summaries.values())
+    save('result.json', dict(passed=passed, runs=summaries))
+    print('RESULT', json.dumps(dict(passed=passed, summaries=summaries)), flush=True)
+    raise SystemExit(0 if passed else 1)
+
+
+if __name__ == '__main__':
+    main()

research/fine_surface_joint_20261014/zero_boundary.csv

@@ -0,0 +1,49 @@
+step,substep,time,bfl_error,drive_mass,latest_body_impulse_x,latest_body_impulse_y,latest_body_angular_impulse,boundary_m,boundary_px,boundary_py,fine_transfer_m,fine_transfer_px,fine_transfer_py
+1,1,0.5,1.862645149230957e-09,-3.725290298461914e-09,0.0,0.0,0.0,-3.725290298461914e-09,0.0,0.0,0.0,0.0,0.0
+1,2,1.0,7.450580596923828e-09,1.4901161193847656e-08,0.0,0.0,0.0,1.4901161193847656e-08,0.0,0.0,-3.557652235031128e-07,0.0,0.0
+2,1,1.5,7.450580596923828e-09,1.4901161193847656e-08,0.0,0.0,0.0,1.4901161193847656e-08,0.0,0.0,-8.530914783477783e-07,-7.450580596923828e-09,-1.6763806343078613e-07
+2,2,2.0,7.450580596923828e-09,1.4901161193847656e-08,0.0,0.0,0.0,1.4901161193847656e-08,0.0,0.0,-1.3401731848716736e-06,2.7939677238464355e-09,-9.313225746154785e-10
+3,1,2.5,7.450580596923828e-09,1.4901161193847656e-08,0.0,0.0,0.0,1.4901161193847656e-08,0.0,0.0,-1.6577541828155518e-06,1.5832483768463135e-07,1.5832483768463135e-07
+3,2,3.0,7.450580596923828e-09,1.4901161193847656e-08,0.0,0.0,0.0,1.4901161193847656e-08,0.0,0.0,-1.982320100069046e-06,3.1152740120887756e-07,3.096647560596466e-07
+4,1,3.5,7.450580596923828e-09,1.4901161193847656e-08,0.0,0.0,0.0,1.4901161193847656e-08,0.0,0.0,-3.2121315598487854e-06,3.5297125577926636e-07,3.762543201446533e-07
+4,2,4.0,7.450580596923828e-09,1.4901161193847656e-08,0.0,0.0,0.0,1.4901161193847656e-08,0.0,0.0,-3.698747605085373e-06,-3.585591912269592e-08,1.909211277961731e-08
+5,1,4.5,7.450580596923828e-09,1.4901161193847656e-08,0.0,0.0,0.0,1.4901161193847656e-08,0.0,0.0,-3.6563724279403687e-06,5.550682544708252e-07,2.4121254682540894e-07
+5,2,5.0,7.450580596923828e-09,1.4901161193847656e-08,0.0,0.0,0.0,1.4901161193847656e-08,0.0,0.0,-3.6312267184257507e-06,5.122274160385132e-07,2.2258609533309937e-07
+6,1,5.5,7.450580596923828e-09,1.4901161193847656e-08,0.0,0.0,0.0,1.4901161193847656e-08,0.0,0.0,-2.8940849006175995e-06,5.164183676242828e-07,3.213062882423401e-08
+6,2,6.0,7.450580596923828e-09,1.4901161193847656e-08,0.0,0.0,0.0,1.4901161193847656e-08,0.0,0.0,-2.759043127298355e-06,1.4202669262886047e-07,-9.173527359962463e-08
+7,1,6.5,7.450580596923828e-09,1.2056459275378018e-08,2.60770320892334e-08,2.60770320892334e-08,0.0,2.2351741790771484e-08,-2.9802322387695312e-08,-2.9802322387695312e-08,-2.505723387002945e-06,1.41095370054245e-07,1.909211277961731e-08
+7,2,7.0,3.3177493669045433e-09,8.59302214106794e-09,6.146728992462158e-08,3.5390257835388184e-08,0.0,5.634501576423645e-08,-6.565824151039124e-08,-3.119930624961853e-08,-2.1560117602348328e-06,9.872019290924072e-08,-7.171183824539185e-08
+8,1,7.5,3.3720288783456454e-09,5.322996345785702e-09,-1.1175870895385742e-08,-3.725290298461914e-09,-1.3969838619232178e-09,7.031485438346863e-08,1.1641532182693481e-08,1.0710209608078003e-08,-2.4740584194660187e-06,2.6496127247810364e-07,1.103617250919342e-07
+8,2,8.0,5.7645661577510054e-09,9.257705106853475e-09,8.568167686462402e-08,6.891787052154541e-08,5.587935447692871e-09,6.658956408500671e-08,-8.242204785346985e-08,-6.100162863731384e-08,-2.444721758365631e-06,1.7601996660232544e-07,1.5832483768463135e-08
+9,1,8.5,5.7645661577510054e-09,1.0978071169134851e-08,1.1548399925231934e-07,1.043081283569336e-07,2.3094196555106805e-09,3.166496753692627e-08,-1.1082738637924194e-07,-1.0710209608078003e-07,-2.629123628139496e-06,1.7415732145309448e-07,-9.313225746154785e-08
+9,2,9.0,6.9608347974536855e-09,7.898425626214067e-09,1.3131648302078247e-07,1.648440957069397e-07,6.947145747560057e-09,3.119930624961853e-08,-1.19674950838089e-07,-1.578591763973236e-07,-2.517830580472946e-06,1.7741695046424866e-07,-1.0477378964424133e-07
+10,1,9.5,8.157103437156366e-09,1.1035995113421737e-08,9.592622518539429e-08,1.387670636177063e-07,-4.134291242685606e-09,-5.3085386753082275e-08,-9.499490261077881e-08,-1.4062970876693726e-07,-2.5741755962371826e-06,4.377216100692749e-08,-2.1420419216156006e-08
+10,2,10.0,9.843117876329188e-09,-2.3864622283528703e-09,-5.587935447692871e-09,1.601874828338623e-07,-2.2389515352827516e-08,-5.820766091346741e-08,4.656612873077393e-10,-1.5692785382270813e-07,-2.477318048477173e-06,1.1362135410308838e-07,-4.6566128730773926e-08
+11,1,10.5,5.7645661577510054e-09,8.417366170396234e-09,3.073364496231079e-08,1.4062970876693726e-07,5.2116290616410765e-08,-5.541369318962097e-08,-2.2817403078079224e-08,-1.4295801520347595e-07,-2.542976289987564e-06,-1.0943040251731873e-07,-1.3923272490501404e-07
+11,2,11.0,8.646849236626508e-09,4.201981729581861e-09,2.0489096641540527e-08,6.51925802230835e-08,2.9745662044611265e-08,-1.3969838619232178e-08,-2.0489096641540527e-08,-7.264316082000732e-08,-2.610962837934494e-06,2.561137080192566e-08,-1.2153759598731995e-07
+12,1,11.5,7.450580596923828e-09,6.251696621321912e-09,-2.3283064365386963e-08,2.514570951461792e-08,-8.029562570399662e-09,-2.9802322387695312e-08,2.7939677238464355e-08,-2.7939677238464355e-08,-2.630986273288727e-06,-2.60770320892334e-08,-1.0337680578231812e-07
+12,2,12.0,5.7645661577510054e-09,2.728442157970412e-09,1.3969838619232178e-08,4.377216100692749e-08,3.1274215439580644e-09,-6.51925802230835e-09,-1.1175870895385742e-08,-4.377216100692749e-08,-2.6319175958633423e-06,1.4901161193847656e-08,-1.4528632164001465e-07
+13,1,12.5,5.7645661577510054e-09,-9.308885346587248e-11,-1.5832483768463135e-08,-1.3969838619232178e-08,-5.176395001527112e-08,-2.1420419216156006e-08,2.2351741790771484e-08,7.450580596923828e-09,-2.5229528546333313e-06,-1.30385160446167e-07,-1.94646418094635e-07
+13,2,13.0,5.7645661577510054e-09,2.221090411418103e-09,-8.381903171539307e-09,6.51925802230835e-09,-8.495223857707401e-09,-1.862645149230957e-09,8.381903171539307e-09,-1.3969838619232178e-08,-2.4405308067798615e-06,-7.12461769580841e-08,-1.8673017621040344e-07
+14,1,13.5,5.7645661577510054e-09,2.3050655134637665e-09,-1.0244548320770264e-08,1.7695128917694092e-08,-5.172617645321509e-08,-1.4435499906539917e-08,7.916241884231567e-09,-1.4435499906539917e-08,-2.2603198885917664e-06,-1.4062970876693726e-07,-2.561137080192566e-07
+14,2,14.0,5.7645661577510054e-09,-1.3810677766332158e-09,4.6566128730773926e-09,1.955777406692505e-08,-2.4717821789366212e-08,-1.5832483768463135e-08,-9.313225746154785e-09,-1.955777406692505e-08,-2.158805727958679e-06,-5.587935447692871e-08,-2.654269337654114e-07
+15,1,14.5,5.7645661577510054e-09,3.710991161934296e-09,-2.514570951461792e-08,1.955777406692505e-08,-3.6359353972059694e-08,-2.3748725652694702e-08,2.7474015951156616e-08,-1.3504177331924438e-08,-2.0223669707775116e-06,-1.7834827303886414e-07,-2.752058207988739e-07
+15,2,15.0,5.7645661577510054e-09,5.327543748170904e-09,1.3969838619232178e-08,1.5832483768463135e-08,1.7229467630386353e-08,1.0710209608078003e-08,-1.257285475730896e-08,-1.7229467630386353e-08,-1.909211277961731e-06,-5.8673322200775146e-08,-2.812594175338745e-07
+16,1,15.5,5.7645661577510054e-09,4.6057723086800895e-10,-2.7008354663848877e-08,-2.1420419216156006e-08,-3.447782204180072e-08,-2.2351741790771484e-08,2.7939677238464355e-08,2.7008354663848877e-08,-1.9264407455921173e-06,-1.3737007975578308e-07,-4.237517714500427e-08
+16,2,16.0,6.254311957221148e-09,5.437245712697214e-09,-9.313225746154785e-10,-1.3969838619232178e-08,1.6260371493714842e-08,4.190951585769653e-09,3.259629011154175e-09,1.3504177331924438e-08,-1.8654391169548035e-06,-1.0617077350616455e-07,-1.7136335372924805e-07
+17,1,16.5,9.13659503609665e-09,3.3756476485596876e-09,-4.0046870708465576e-08,-3.632158041000366e-08,-2.366079998594728e-09,-1.0710209608078003e-08,3.864988684654236e-08,4.0512531995773315e-08,-1.7364509403705597e-06,-2.062879502773285e-07,-3.864988684654236e-08
+17,2,17.0,6.254311957221148e-09,-1.3075458155445419e-09,-2.7939677238464355e-09,-5.681067705154419e-08,-2.5630257582953675e-08,-1.1641532182693481e-08,5.122274160385132e-09,4.7963112592697144e-08,-1.6386620700359344e-06,-1.2153759598731995e-07,-9.73232090473175e-08
+18,1,17.5,6.254311957221148e-09,6.7173146229421166e-09,1.862645149230957e-09,-1.862645149230957e-08,2.366079998594728e-09,-1.1641532182693481e-08,-5.122274160385132e-09,2.3748725652694702e-08,-1.4598481357097626e-06,-5.2619725465774536e-08,5.541369318962097e-08
+18,2,18.0,7.94032639639397e-09,6.865774111568246e-09,8.754432201385498e-08,-1.30385160446167e-08,-1.534793570012738e-08,7.450580596923828e-09,-8.754432201385498e-08,8.381903171539307e-09,-1.3792887330055237e-06,-5.587935447692871e-08,-2.0489096641540527e-08
+19,1,18.5,9.13659503609665e-09,1.0526447616343582e-08,7.636845111846924e-08,-5.587935447692871e-09,1.5908030892575198e-08,-6.51925802230835e-09,-7.82310962677002e-08,3.725290298461914e-09,-1.307111233472824e-06,1.909211277961731e-08,5.122274160385132e-09
+19,2,19.0,6.254311957221148e-09,9.55982605143485e-09,1.2479722499847412e-07,-1.1175870895385742e-08,-3.2520742987429685e-08,0.0,-1.2200325727462769e-07,9.313225746154785e-09,-1.2475065886974335e-06,-3.213062882423401e-08,-3.119930624961853e-08
+20,1,19.5,7.450580596923828e-09,8.078089798642385e-09,9.499490261077881e-08,-1.4901161193847656e-08,2.2911836983219303e-08,-9.778887033462524e-09,-9.639188647270203e-08,1.7229467630386353e-08,-1.2731179594993591e-06,8.568167686462402e-08,5.4016709327697754e-08
+20,2,20.0,9.13659503609665e-09,6.598118141264153e-09,8.288770914077759e-08,-4.563480615615845e-08,2.065907767079267e-08,4.656612873077393e-10,-8.800998330116272e-08,4.6100467443466187e-08,-1.1995434761047363e-06,8.195638656616211e-08,-2.60770320892334e-08
+21,1,20.5,9.13659503609665e-09,3.7482895407295325e-09,7.729977369308472e-08,-4.7497451305389404e-08,-1.2497307633196897e-08,-1.5832483768463135e-08,-7.729977369308472e-08,4.0046870708465576e-08,-1.3262033462524414e-06,1.471489667892456e-07,-4.563480615615845e-08
+21,2,21.0,9.13659503609665e-09,9.180836884128962e-09,9.313225746154785e-08,-3.91155481338501e-08,-1.5700276301267024e-08,1.6298145055770874e-08,-8.987262845039368e-08,3.585591912269592e-08,-1.3378448784351349e-06,1.1781230568885803e-07,-7.310882210731506e-08
+22,1,21.5,9.13659503609665e-09,5.584703916330924e-09,1.0058283805847168e-07,-2.7939677238464355e-08,-3.1589420412814206e-08,-1.1175870895385742e-08,-1.0244548320770264e-07,2.60770320892334e-08,-1.443084329366684e-06,1.317821443080902e-07,-1.7276033759117126e-07
+22,2,22.0,9.13659503609665e-09,1.0796289612313714e-08,9.592622518539429e-08,-5.3085386753082275e-08,-1.7493244630628624e-09,1.1641532182693481e-08,-9.266659617424011e-08,5.541369318962097e-08,-1.4277175068855286e-06,1.1641532182693481e-07,-1.6298145055770874e-07
+23,1,22.5,9.13659503609665e-09,5.392017251963643e-09,1.0803341865539551e-07,-3.5390257835388184e-08,-2.3635404966526607e-08,6.05359673500061e-09,-1.1315569281578064e-07,3.585591912269592e-08,-1.3522803783416748e-06,4.6566128730773926e-08,-1.1920928955078125e-07
+23,2,23.0,1.0332863675799331e-08,9.153846265187726e-09,1.1175870895385742e-07,-4.470348358154297e-08,-2.7845243333324277e-08,1.30385160446167e-08,-1.1082738637924194e-07,4.7497451305389404e-08,-1.2884847819805145e-06,3.026798367500305e-08,-7.310882210731506e-08
+24,1,23.5,7.450580596923828e-09,3.828949286105443e-09,5.3085386753082275e-08,-3.632158041000366e-08,-3.0305757237059083e-08,4.190951585769653e-09,-5.820766091346741e-08,3.958120942115784e-08,-1.028645783662796e-06,6.193295121192932e-08,-4.7031790018081665e-08
+24,2,24.0,7.450580596923828e-09,1.2711602917839238e-08,5.8673322200775146e-08,-6.612390279769897e-08,-6.552603404319512e-08,1.257285475730896e-08,-7.217749953269958e-08,6.100162863731384e-08,-9.830109775066376e-07,1.257285475730896e-08,-1.5366822481155396e-08

research/fine_surface_joint_20261014/zero_collisions.csv

@@ -0,0 +1,73 @@
+step,level,substep,max_error,max_ratio,regime,drift_m,drift_px,drift_py,ideal_defect_m,ideal_defect_px,ideal_defect_py,measured_rounding_m,measured_rounding_px,measured_rounding_py
+1,fine,1,3.083712529772242e-08,0.08007812434516381,True,1.6147270798683167e-05,0.0,0.0,-8.326672684688674e-17,0.0,0.0,1.6147270798766433e-05,0.0,0.0
+1,fine,2,1.1382831566209006e-08,0.09960937460709829,True,-3.4831464290618896e-07,0.0,0.0,-5.169475958410885e-15,0.0,0.0,-3.48314637736713e-07,0.0,0.0
+1,coarse,1,1.1080350609260492e-08,0.10456730670501622,True,-1.5292316675186157e-06,-1.30385160446167e-08,-1.5832483768463135e-07,-4.288236432614667e-15,-5.551115123125783e-17,1.3877787807814457e-17,-1.5292316632303793e-06,-1.3038515989105548e-08,-1.5832483769850914e-07
+2,fine,1,3.2078889655728915e-08,0.1679687748837782,True,8.158385753631592e-07,-1.30385160446167e-08,-1.7508864402770996e-07,-4.496403249731884e-15,-1.734723475976807e-17,2.740863092043355e-16,8.158385798595624e-07,-1.3038516027269464e-08,-1.7508864430179627e-07
+2,fine,2,6.788307005400895e-08,0.19140625209547577,True,2.376735210418701e-06,-1.1175870895385742e-08,1.2665987014770508e-07,-1.0479464518375892e-14,-4.336808689942018e-17,2.7582103268031233e-16,2.3767352208981657e-06,-1.1175870852017655e-08,1.2665986987188405e-07
+2,coarse,1,1.6365805183271576e-08,0.1544470929589978,True,-1.426786184310913e-06,-3.0919909477233887e-07,-3.0919909477233887e-07,-6.286637876939949e-15,-8.326672684688674e-17,-8.326672684688674e-17,-1.4267861780242752e-06,-3.0919909468907214e-07,-3.0919909468907214e-07
+3,fine,1,8.23703105723439e-08,0.31152334896616624,True,4.382804036140442e-06,1.6111880540847778e-07,1.3690441846847534e-07,-1.0234868508263162e-14,6.245004513516506e-17,3.2612801348363973e-16,4.38280404637531e-06,1.6111880534602774e-07,1.3690441814234733e-07
+3,fine,2,7.843806204554937e-08,0.3828123813437159,True,7.607974112033844e-06,5.029141902923584e-08,2.2351741790771484e-08,-1.5149340115705456e-14,1.5612511283791264e-17,2.654126918244515e-16,7.607974127183184e-06,5.029141901362333e-08,2.2351741525358793e-08
+3,coarse,1,1.0010523732173482e-07,0.2854567053212911,True,9.115785360336304e-06,3.3155083656311035e-07,3.203749656677246e-07,-3.837208328860697e-15,1.5334955527634975e-15,1.2420620087993939e-15,9.115785364173512e-06,3.315508350296148e-07,3.203749644256626e-07
+4,fine,1,9.437402781475868e-08,0.3632811360585352,True,1.0219402611255646e-05,3.771856427192688e-07,3.67872416973114e-07,-1.84297022087776e-14,4.371503159461554e-16,5.238864897449957e-16,1.0219402629685348e-05,3.771856422821185e-07,3.678724164492275e-07
+4,fine,2,9.851323801157719e-08,0.3388670872446077,True,1.0103452950716019e-05,2.975575625896454e-07,1.9976869225502014e-07,-1.6042722705833512e-14,-1.7694179454963432e-16,6.938893903907228e-18,1.0103452966758741e-05,2.975575627665872e-07,1.9976869224808125e-07
+4,coarse,1,1.2150177930436712e-07,0.37139422446265463,True,1.3064593076705933e-05,5.997717380523682e-07,5.62518835067749e-07,-1.2559397966072083e-14,-5.967448757360216e-16,-2.498001805406602e-16,1.306459308926533e-05,5.99771738649113e-07,5.625188353175492e-07
+5,fine,1,9.851323801157719e-08,0.3144530263816977,True,1.0738149285316467e-05,-4.190951585769653e-08,-1.1548399925231934e-07,-1.6018436577169837e-14,4.891920202254596e-16,5.30825383648903e-16,1.0738149301334904e-05,-4.1909516346888553e-08,-1.1548399978314472e-07
+5,fine,2,9.540882917047355e-08,0.32177729440809383,True,9.94466245174408e-06,0.0,1.7695128917694092e-07,-1.7361112547575885e-14,4.198030811863873e-16,1.0477729794899915e-15,9.944662469105192e-06,-4.198030811863873e-16,1.7695128812916794e-07
+5,coarse,1,1.2532259030528792e-07,0.38942307019337585,True,1.49458646774292e-05,9.723007678985596e-07,1.2628734111785889e-06,-1.6535384173010925e-14,1.5959455978986625e-16,6.175615574477433e-16,1.4945864693964583e-05,9.72300767738965e-07,1.2628734105610273e-06
+6,fine,1,9.023481550851642e-08,0.2998045916974925,True,9.546522051095963e-06,1.0104849934577942e-07,-6.007030606269836e-08,-1.5754758608821362e-14,-1.3530843112619095e-16,3.469446951953614e-16,9.546522066850721e-06,1.0104849948108785e-07,-6.007030640964306e-08
+6,fine,2,9.023481550851642e-08,0.29199211258675606,True,8.22870060801506e-06,8.614733815193176e-08,-1.6065314412117004e-07,-1.482668154917377e-14,1.3010426069826053e-16,-8.847089727481716e-17,8.228700622841742e-06,8.61473380218275e-08,-1.6065314403269915e-07
+6,coarse,1,1.0239773140519048e-07,0.43028837580529966,True,1.3286247849464417e-05,4.898756742477417e-07,3.818422555923462e-07,-1.9283186158958188e-14,-3.469446951953614e-17,8.673617379884035e-16,1.3286247868747603e-05,4.898756742824362e-07,3.8184225472498445e-07
+7,fine,1,9.023481550851642e-08,0.29199211258675606,True,8.461065590381622e-06,9.96515154838562e-08,1.862645149230957e-08,-1.6153745008296028e-14,4.649058915617843e-16,-1.97758476261356e-16,8.461065606535367e-06,9.965151501895031e-08,1.8626451690068047e-08
+7,fine,2,9.023481550851642e-08,0.29199211258675606,True,7.561873644590378e-06,7.497146725654602e-08,4.237517714500427e-08,-1.456647302777725e-14,8.153200337090993e-17,5.741934705483231e-16,7.561873659156851e-06,7.497146717501402e-08,4.23751765708108e-08
+7,coarse,1,1.0902046165828239e-07,0.38161058826685446,True,1.3303011655807495e-05,9.387731552124023e-07,-2.5331974029541016e-07,-2.4202861936828413e-14,-8.326672684688674e-17,-2.3592239273284576e-16,1.3303011680010357e-05,9.387731552956691e-07,-2.5331974005948776e-07
+8,fine,1,9.023481550851642e-08,0.29199211258675606,True,6.217043846845627e-06,7.12461769580841e-08,1.5040859580039978e-07,-1.42785089307651e-14,6.765421556309548e-17,1.9081958235744878e-17,6.217043861124136e-06,7.124617689042989e-08,1.5040859578131782e-07
+8,fine,2,9.023481550851642e-08,0.31249989522621113,True,6.183981895446777e-06,1.5832483768463135e-08,1.210719347000122e-08,-1.374594882364022e-14,2.914335439641036e-16,-2.0816681711721685e-17,6.183981909192726e-06,1.583248347702959e-08,1.2107193490817902e-08
+8,coarse,1,1.265961931951054e-07,0.38341345468786764,True,7.713213562965393e-06,5.718320608139038e-07,-6.761401891708374e-07,-2.1399548799649892e-14,-1.4432899320127035e-15,3.885780586188048e-16,7.713213584364942e-06,5.718320622571937e-07,-6.761401895594155e-07
+9,fine,1,7.678237223807116e-08,0.32031244446989565,True,5.04031777381897e-06,9.685754776000977e-08,-1.434236764907837e-07,-1.3928094788617784e-14,-1.0581813203458523e-16,2.6020852139652106e-17,5.0403177877470645e-06,9.68575478658279e-08,-1.4342367651680454e-07
+9,fine,2,7.823108461035844e-08,0.2934569717253952,True,4.06801700592041e-06,3.5390257835388184e-08,-1.7695128917694092e-08,-1.4047790708460184e-14,-9.367506770274758e-17,1.9081958235744878e-16,4.068017019968201e-06,3.539025792906325e-08,-1.7695129108513674e-08
+9,coarse,1,1.0774685821335339e-07,0.3876201969620664,True,1.385807991027832e-06,-2.7567148208618164e-07,-4.470348358154297e-07,-2.468858451010192e-14,1.249000902703301e-16,-5.967448757360216e-16,1.3858080157164165e-06,-2.7567148221108173e-07,-4.470348352186848e-07
+10,fine,1,7.885198249901748e-08,0.3164059705161431,True,3.97535040974617e-06,2.0954757928848267e-08,3.306195139884949e-08,-1.408248517797972e-14,1.0408340855860843e-17,1.3183898417423734e-16,3.975350423828655e-06,2.0954757918439926e-08,3.30619512670105e-08
+10,fine,2,6.684825892833146e-08,0.33007805480156616,True,3.22144478559494e-06,2.7939677238464355e-09,1.3969838619232178e-08,-1.3690437672408962e-14,2.220446049250313e-16,1.942890293094024e-16,3.221444799285378e-06,2.7939675018018306e-09,1.3969838424943148e-08
+10,coarse,1,9.857692329084955e-08,0.4038458162128909,True,2.164393663406372e-06,-4.470348358154297e-07,3.203749656677246e-07,-2.49592013723543e-14,-3.5388358909926865e-16,8.257283745649602e-16,2.1643936883655734e-06,-4.470348354615461e-07,3.2037496484199623e-07
+11,fine,1,7.202226570690584e-08,0.2885741439022296,True,2.462416887283325e-06,7.264316082000732e-08,3.259629011154175e-08,-1.4660148095479997e-14,-2.0990154059319366e-16,-2.203098814490545e-16,2.4624169019434733e-06,7.264316102990886e-08,3.259629033185163e-08
+11,fine,2,7.864501860854745e-08,0.26904281257170715,True,2.048444002866745e-06,2.3283064365386963e-09,6.938353180885315e-08,-1.4498818812214154e-14,-1.5265566588595902e-16,-4.198030811863873e-16,2.048444017365564e-06,2.328306589194362e-09,6.938353222865623e-08
+11,coarse,1,1.2914339875269576e-07,0.3858170203504229,True,-3.026798367500305e-06,-2.6635825634002686e-07,3.4831464290618896e-07,-1.938033067361289e-14,-2.0816681711721685e-17,-2.2898349882893854e-16,-3.0267983481199745e-06,-2.663582563192102e-07,3.4831464313517246e-07
+12,fine,1,6.72621854880262e-08,0.2617186813731729,True,2.3399479687213898e-06,3.771856427192688e-08,4.7031790018081665e-08,-1.3525638942191165e-14,-4.683753385137379e-17,3.9898639947466563e-17,2.3399479822470287e-06,3.7718564318764414e-08,4.7031789978183025e-08
+12,fine,2,6.829698973032095e-08,0.310546814493141,True,1.689419150352478e-06,8.847564458847046e-08,1.1082738637924194e-07,-1.4262896419481308e-14,-6.938893903907228e-18,-1.491862189340054e-16,1.6894191646153744e-06,8.847564459540935e-08,1.1082738652842816e-07
+12,coarse,1,1.0137883943439618e-07,0.3215142032133043,True,-2.1997839212417603e-06,-4.4889748096466064e-07,1.2479722499847412e-07,-2.423061751244404e-14,-1.5265566588595902e-16,-3.0531133177191805e-16,-2.1997838970111427e-06,-4.48897480812005e-07,1.2479722530378545e-07
+13,fine,1,7.243620325780853e-08,0.2641600946299196,True,2.107582986354828e-06,1.1827796697616577e-07,1.685693860054016e-07,-1.5241280459932227e-14,3.8163916471489756e-17,-7.979727989493313e-17,2.1075830015961083e-06,1.1827796693800186e-07,1.685693860851989e-07
+13,fine,2,6.581346223555329e-08,0.3027343282446967,True,2.037733793258667e-06,1.387670636177063e-07,7.171183824539185e-08,-1.5482407023093003e-14,-6.418476861114186e-17,2.2724877535296173e-16,2.037733808741074e-06,1.3876706368189107e-07,7.171183801814307e-08
+13,coarse,1,8.762392122996232e-08,0.40144193790160176,True,-4.213303327560425e-06,-1.1920928955078125e-07,4.0978193283081055e-08,-2.413347299778934e-14,1.249000902703301e-16,-4.718447854656915e-16,-4.213303303426952e-06,-1.1920928967568134e-07,4.097819375492584e-08
+14,fine,1,6.41577777571456e-08,0.3027343237918107,True,2.5937333703041077e-06,2.3562461137771606e-07,1.5087425708770752e-07,-1.5074747006238454e-14,3.469446951953614e-17,-2.7755575615628914e-17,2.5937333853788547e-06,2.356246113430216e-07,1.508742571154631e-07
+14,fine,2,8.133550555289304e-08,0.27001943973665604,True,2.884306013584137e-06,1.3597309589385986e-07,1.3690441846847534e-07,-1.4148404670066839e-14,-1.8388068845354155e-16,-1.3530843112619095e-16,2.8843060277325416e-06,1.3597309607774055e-07,1.3690441860378377e-07
+14,coarse,1,9.602967243615979e-08,0.3371390787341595,True,-2.9336661100387573e-06,1.5087425708770752e-07,1.2479722499847412e-07,-2.4147350785597155e-14,7.494005416219807e-16,-1.942890293094024e-16,-2.9336660858914065e-06,1.5087425633830698e-07,1.2479722519276315e-07
+15,fine,1,6.68482650345581e-08,0.3076171427746889,True,2.0759180188179016e-06,3.3527612686157227e-08,3.3527612686157227e-08,-1.462545362596046e-14,2.654126918244515e-16,-3.694961003830599e-16,2.0759180334433552e-06,3.3527612420744535e-08,3.352761305565333e-08
+15,fine,2,7.512668886988649e-08,0.28124994080281324,True,2.1229498088359833e-06,1.2246891856193542e-07,1.4388933777809143e-07,-1.3600232051658168e-14,-2.6020852139652106e-16,-4.0245584642661925e-16,2.1229498224362153e-06,1.2246891882214395e-07,1.4388933818054728e-07
+15,coarse,1,1.0723740850870911e-07,0.41406218567886527,True,-3.604218363761902e-06,2.514570951461792e-07,2.8870999813079834e-07,-2.2641610808449286e-14,2.2898349882893854e-16,-2.8449465006019636e-16,-3.604218341120291e-06,2.514570949171957e-07,2.88709998415293e-07
+16,fine,1,7.098747656364424e-08,0.32714839408436125,True,2.566725015640259e-06,9.033828973770142e-08,6.426125764846802e-08,-1.4136261605735001e-14,5.724587470723463e-17,3.7296554733501353e-16,2.5667250297765204e-06,9.033828968045554e-08,6.426125727550247e-08
+16,fine,2,6.767610849500727e-08,0.28320307876856565,True,2.248678356409073e-06,1.969747245311737e-07,2.3748725652694702e-08,-1.4096362965787534e-14,-1.7694179454963432e-16,-2.6020852139652106e-16,2.248678370505436e-06,1.969747247081155e-07,2.3748725912903224e-08
+16,coarse,1,1.1131294752608767e-07,0.344951775990682,True,-8.195638656616211e-07,2.5704503059387207e-07,3.7997961044311523e-07,-2.4764912343044898e-14,-8.673617379884035e-16,7.632783294297951e-17,-8.195638408967088e-07,2.570450314612338e-07,3.799796103667874e-07
+17,fine,1,6.063944912870767e-08,0.2998044890847571,True,2.319924533367157e-06,9.406358003616333e-08,6.798654794692993e-08,-1.590221010427939e-14,1.1622647289044608e-16,-2.237793284010081e-16,2.319924549269367e-06,9.406357991993686e-08,6.798654817070926e-08
+17,fine,2,8.506079685055568e-08,0.3017577892533187,True,2.0246952772140503e-06,1.4808028936386108e-07,4.190951585769653e-08,-1.4058199049316045e-14,-9.367506770274758e-17,-2.463307335887066e-16,2.0246952912722493e-06,1.4808028945753615e-07,4.190951610402727e-08
+17,coarse,1,8.329367096049367e-08,0.37439878535241283,True,-2.942979335784912e-07,1.2665987014770508e-07,2.5331974029541016e-07,-2.1892210266827306e-14,4.926614671774132e-16,9.020562075079397e-17,-2.9429791168628094e-07,1.266598696550436e-07,2.5331974020520454e-07
+18,fine,1,6.995265811049478e-08,0.2617189776211021,True,1.6298145055770874e-06,5.494803190231323e-08,-3.5390257835388184e-08,-1.580506558962469e-14,-1.8561541192951836e-16,5.204170427930421e-18,1.629814521382153e-06,5.4948032087928644e-08,-3.5390257840592354e-08
+18,fine,2,6.477865954757078e-08,0.30517565195263086,True,1.5725381672382355e-06,4.423782229423523e-08,-3.771856427192688e-08,-1.470698562933137e-14,1.5612511283791264e-16,-1.7694179454963432e-16,1.572538181945221e-06,4.4237822138110117e-08,-3.7718564094985085e-08
+18,coarse,1,1.1793568432949542e-07,0.4212736354253594,True,-1.5087425708770752e-06,-1.043081283569336e-07,3.3527612686157227e-07,-2.4147350785597155e-14,2.0816681711721685e-16,3.608224830031759e-16,-1.5087425467297244e-06,-1.0430812856510041e-07,3.352761265007498e-07
+19,fine,1,6.871091096094517e-08,0.31933573148866196,True,1.2880191206932068e-06,1.7043203115463257e-07,-9.12696123123169e-08,-1.4236875567341656e-14,2.0990154059319366e-16,2.8622937353617317e-16,1.2880191349300824e-06,1.7043203094473103e-07,-9.126961259854627e-08
+19,fine,2,7.491972742190711e-08,0.24023424324702233,True,1.1730007827281952e-06,-2.468004822731018e-08,-1.327134668827057e-07,-1.3513495877859327e-14,-1.0061396160665481e-16,-8.673617379884035e-17,1.173000796241691e-06,-2.468004812669622e-08,-1.3271346679596951e-07
+19,coarse,1,9.475610251996613e-08,0.35516793189978335,True,-1.5124678611755371e-06,8.940696716308594e-08,1.7136335372924805e-07,-2.3293866835416566e-14,1.3183898417423734e-16,7.147060721024445e-16,-1.5124678378816703e-06,8.940696703124695e-08,1.7136335301454197e-07
+20,fine,1,7.098746790390464e-08,0.2802732595156336,True,1.6228295862674713e-06,4.423782229423523e-08,-2.277083694934845e-07,-1.5477202852665073e-14,1.8735013540549517e-16,2.7755575615628914e-17,1.6228296017446742e-06,4.4237822106885094e-08,-2.2770836952124007e-07
+20,fine,2,8.112854432695826e-08,0.32421854647703796,True,1.5408731997013092e-06,6.05359673500061e-09,-2.2863969206809998e-07,-1.490300938211675e-14,3.2439329000766293e-16,-1.0234868508263162e-16,1.5408732146043186e-06,6.05359641060732e-09,-2.286396919657513e-07
+20,coarse,1,9.781275722708926e-08,0.4218746642002769,True,-6.798654794692993e-07,-1.8812716007232666e-07,6.146728992462158e-08,-2.1871393585115584e-14,-1.1102230246251565e-16,9.43689570931383e-16,-6.798654575979057e-07,-1.8812715996130436e-07,6.146728898093201e-08
+21,fine,1,7.30570710594236e-08,0.2949216850976223,True,1.6815029084682465e-06,4.237517714500427e-08,-1.2712553143501282e-07,-1.4618514732056553e-14,8.500145032286355e-17,3.625572064791527e-16,1.6815029230867612e-06,4.237517706000282e-08,-1.2712553179757002e-07
+21,fine,2,6.68482604826437e-08,0.2656249015126583,True,1.530628651380539e-06,6.472691893577576e-08,-1.0104849934577942e-07,-1.4838824613505608e-14,-3.2612801348363973e-16,4.85722573273506e-17,1.5306286662193636e-06,6.472691926190377e-08,-1.0104849939435168e-07
+21,coarse,1,1.1487904549856154e-07,0.3810092874429201,True,-8.23289155960083e-07,-2.5704503059387207e-07,3.0174851417541504e-07,-2.7519653222896068e-14,-1.3877787807814457e-16,-8.326672684688674e-16,-8.232891284404298e-07,-2.570450304550942e-07,3.017485150080823e-07
+22,fine,1,6.788306161631397e-08,0.30419906371761746,True,1.2782402336597443e-06,1.816079020500183e-08,-2.416782081127167e-07,-1.4958520533348008e-14,-1.1275702593849246e-16,-8.153200337090993e-17,1.2782402486182648e-06,1.8160790317758857e-08,-2.4167820803118467e-07
+22,fine,2,7.098746757083774e-08,0.3193357487763267,True,1.34296715259552e-06,4.190951585769653e-08,-1.3690441846847534e-07,-1.436524510456394e-14,2.2551405187698492e-17,-4.0419056990259605e-16,1.3429671669607651e-06,4.190951583514513e-08,-1.3690441806428477e-07
+22,coarse,1,9.781274745712665e-08,0.4098554174530562,True,-2.427026629447937e-06,-2.1047890186309814e-07,-5.4016709327697754e-08,-2.54379850517239e-14,4.0245584642661925e-16,4.3021142204224816e-16,-2.427026604009952e-06,-2.10478902265554e-07,-5.4016709757909176e-08
+23,fine,1,8.754431335411539e-08,0.26367162956761353,True,1.911073923110962e-06,9.96515154838562e-08,-1.434236764907837e-07,-1.4030443473700416e-14,-3.3306690738754696e-16,-3.434752482434078e-16,1.9110739371414054e-06,9.965151581692311e-08,-1.4342367614730844e-07
+23,fine,2,7.491972731088481e-08,0.29589836062223757,True,9.583309292793274e-07,1.4808028936386108e-07,-8.381903171539307e-08,-1.40391170910803e-14,-1.5439038936193583e-16,3.2959746043559335e-17,9.583309433184445e-07,1.4808028951825147e-07,-8.381903174835281e-08
+23,coarse,1,9.883161822266118e-08,0.46394191845799526,True,-4.954636096954346e-07,-6.332993507385254e-08,1.2665987014770508e-07,-2.6922908347160046e-14,2.220446049250313e-16,1.942890293094024e-16,-4.954635827725262e-07,-6.332993529589714e-08,1.2665986995341605e-07
+24,fine,1,7.098748533440613e-08,0.34619121759181026,True,1.4575198292732239e-06,1.043081283569336e-07,-1.0058283805847168e-07,-1.4247283908197517e-14,8.153200337090993e-17,1.474514954580286e-16,1.4575198435205078e-06,1.0430812827540159e-07,-1.0058283820592318e-07
+24,fine,2,7.823108527649225e-08,0.30419908362462666,True,6.756745278835297e-07,2.0256265997886658e-07,-4.7031790018081665e-08,-1.4353102040232102e-14,-2.8449465006019636e-16,-1.8041124150158794e-16,6.756745422366317e-07,2.0256266026336123e-07,-4.7031789837670424e-08
+24,coarse,1,1.0749213752436759e-07,0.3774035044304019,True,-4.043802618980408e-06,-1.2852251529693604e-07,3.520399332046509e-07,-2.2246093855926574e-14,4.85722573273506e-16,1.3877787807814457e-17,-4.043802596734314e-06,-1.285225157826586e-07,3.520399331907731e-07

research/fine_surface_joint_20261014/zero_ledger.csv

@@ -0,0 +1,25 @@
+step,time,average_bound_ratio,leaf_m,leaf_px,leaf_py,delta_m,delta_px,delta_py,boundary_m,boundary_px,boundary_py,fine_transfer_m,fine_transfer_px,fine_transfer_py,coarse_transfer_m,coarse_transfer_px,coarse_transfer_py,raw_m,raw_px,raw_py,collision_drift_m,collision_drift_px,collision_drift_py,average_rounding_m,average_rounding_px,average_rounding_py,closure_m,closure_px,closure_py,cumulative_raw_m,cumulative_raw_px,cumulative_raw_py,cumulative_closure_m,cumulative_closure_px,cumulative_closure_py
+1,1,0.28124994289828603,560.7500186339021,-1.4901161193847656e-08,-3.3527612686157227e-07,1.4455989003181458e-05,-1.4901161193847656e-08,-3.3527612686157227e-07,1.1175870895385742e-08,0.0,0.0,-3.557652235031128e-07,0.0,0.0,5.308538675308228e-07,-1.862645149230957e-09,-1.7695128917694092e-07,1.4269724488258362e-05,-1.30385160446167e-08,-1.5832483768463135e-07,1.4269724488258362e-05,-1.30385160446167e-08,-1.5832483768463135e-07,1.7508864402770996e-07,-1.862645149230957e-09,-1.7695128917694092e-07,0.0,0.0,0.0,1.4269724488258362e-05,-1.30385160446167e-08,-1.5832483768463135e-07,0.0,0.0,0.0
+2,2,0.37499987985940486,560.7500202683732,-5.038455128669739e-07,-6.919726729393005e-07,1.6344711184501648e-06,-4.889443516731262e-07,-3.5669654607772827e-07,2.9802322387695312e-08,0.0,0.0,-2.193264663219452e-06,-4.6566128730773926e-09,-1.685693860054016e-07,2.032145857810974e-06,-1.5087425708770752e-07,1.695007085800171e-07,1.7657876014709473e-06,-3.334134817123413e-07,-3.5762786865234375e-07,1.7657876014709473e-06,-3.334134817123413e-07,-3.5762786865234375e-07,-1.6111880540847778e-07,-1.555308699607849e-07,9.313225746154785e-10,0.0,0.0,0.0,1.603551208972931e-05,-3.46451997756958e-07,-5.159527063369751e-07,0.0,0.0,0.0
+3,3,0.2812499146093721,560.750041406136,4.516914486885071e-08,-2.0442530512809753e-07,2.1137762814760208e-05,5.490146577358246e-07,4.87547367811203e-07,2.9802322387695312e-08,0.0,0.0,-3.6400742828845978e-06,4.698522388935089e-07,4.6798959374427795e-07,3.641471266746521e-06,-4.637986421585083e-07,-4.600733518600464e-07,2.110656350851059e-05,5.42961061000824e-07,4.796311259269714e-07,2.110656350851059e-05,5.42961061000824e-07,4.796311259269714e-07,1.3969838619232178e-09,6.05359673500061e-09,7.916241884231567e-09,0.0,0.0,0.0,3.71420755982399e-05,1.9650906324386597e-07,-3.632158041000366e-08,0.0,0.0,0.0
+4,4,0.37499987985940486,560.7500747130252,1.3741664588451385e-06,9.83942300081253e-07,3.330688923597336e-05,1.3289973139762878e-06,1.1883676052093506e-06,2.9802322387695312e-08,0.0,0.0,-6.910879164934158e-06,3.1711533665657043e-07,3.9534643292427063e-07,6.800517439842224e-06,-2.6263296604156494e-07,-3.371387720108032e-07,3.33874486386776e-05,1.2745149433612823e-06,1.1301599442958832e-06,3.33874486386776e-05,1.2745149433612823e-06,1.1301599442958832e-06,-1.103617250919342e-07,5.448237061500549e-08,5.820766091346741e-08,0.0,0.0,0.0,7.05295242369175e-05,1.4710240066051483e-06,1.0938383638858795e-06,0.0,0.0,0.0
+5,5,0.3749998295680158,560.7501105009578,2.3622997105121613e-06,2.369750291109085e-06,3.578793257474899e-05,9.881332516670227e-07,1.385807991027832e-06,2.9802322387695312e-08,0.0,0.0,-7.287599146366119e-06,1.0672956705093384e-06,4.637986421585083e-07,7.417052984237671e-06,-1.0095536708831787e-06,-4.023313522338867e-07,3.5628676414489746e-05,9.30391252040863e-07,1.3243407011032104e-06,3.5628676414489746e-05,9.30391252040863e-07,1.3243407011032104e-06,1.2945383787155151e-07,5.774199962615967e-08,6.146728992462158e-08,0.0,0.0,0.0,0.00010615820065140724,2.4014152586460114e-06,2.41817906498909e-06,0.0,0.0,0.0
+6,6,0.46874973195382685,560.7501414637081,2.941582351922989e-06,2.4265609681606293e-06,3.09627503156662e-05,5.792826414108276e-07,5.681067705154419e-08,2.9802322387695312e-08,0.0,0.0,-5.653128027915955e-06,6.584450602531433e-07,-5.960464477539063e-08,5.5246055126190186e-06,-7.562339305877686e-07,-4.470348358154297e-08,3.106147050857544e-05,6.770715117454529e-07,1.6111880540847778e-07,3.106147050857544e-05,6.770715117454529e-07,1.6111880540847778e-07,-1.2852251529693604e-07,-9.778887033462524e-08,-1.043081283569336e-07,0.0,0.0,0.0,0.00013721967115998268,3.0784867703914642e-06,2.5792978703975677e-06,0.0,0.0,0.0
+7,7,0.4687496533735736,560.7501708613709,3.914348781108856e-06,2.1560117602348328e-06,2.9397662729024887e-05,9.727664291858673e-07,-2.705492079257965e-07,7.869675755500793e-08,-9.546056389808655e-08,-6.100162863731384e-08,-4.661735147237778e-06,2.398155629634857e-07,-5.2619725465774536e-08,4.654750227928162e-06,-2.849847078323364e-07,3.5390257835388184e-08,2.9325950890779495e-05,1.1133961379528046e-06,-1.9231811165809631e-07,2.9325950890779495e-05,1.1133961379528046e-06,-1.9231811165809631e-07,-6.984919309616089e-09,-4.516914486885071e-08,-1.7229467630386353e-08,0.0,0.0,0.0,0.00016654562205076218,4.191882908344269e-06,2.3869797587394714e-06,0.0,0.0,0.0
+8,8,0.4687496533735736,560.7501910906285,4.438683390617371e-06,1.5152618288993835e-06,2.022925764322281e-05,5.243346095085144e-07,-6.407499313354492e-07,1.3690441846847534e-07,-7.078051567077637e-08,-5.029141902923584e-08,-4.91878017783165e-06,4.409812390804291e-07,1.2619420886039734e-07,4.896894097328186e-06,-5.047768354415894e-07,-2.0302832126617432e-07,2.0114239305257797e-05,6.58910721540451e-07,-5.136243999004364e-07,2.0114239305257797e-05,6.58910721540451e-07,-5.136243999004364e-07,-2.1886080503463745e-08,-6.379559636116028e-08,-7.683411240577698e-08,0.0,0.0,0.0,0.00018665986135601997,4.85079362988472e-06,1.873355358839035e-06,0.0,0.0,0.0
+9,9,0.37499998044222344,560.7502015968785,4.073604941368103e-06,6.379559636116028e-07,1.0506249964237213e-05,-3.650784492492676e-07,-8.773058652877808e-07,6.28642737865448e-08,-2.3050233721733093e-07,-2.6496127247810364e-07,-5.146954208612442e-06,3.5157427191734314e-07,-1.9790604710578918e-07,5.0961971282958984e-06,-3.427267074584961e-07,1.9371509552001953e-07,1.0494142770767212e-05,-1.434236764907837e-07,-6.081536412239075e-07,1.0494142770767212e-05,-1.434236764907837e-07,-6.081536412239075e-07,-5.075708031654358e-08,8.847564458847046e-09,-4.190951585769653e-09,0.0,0.0,0.0,0.00019715400412678719,4.707369953393936e-06,1.2652017176151276e-06,0.0,0.0,0.0
+10,10,0.4687496533735736,560.7502107927576,3.5660341382026672e-06,6.789341568946838e-07,9.195879101753235e-06,-5.075708031654358e-07,4.0978193283081055e-08,-1.1129304766654968e-07,-9.452924132347107e-08,-2.975575625896454e-07,-5.0514936447143555e-06,1.5739351511001587e-07,-6.798654794692993e-08,4.997476935386658e-06,-1.471489667892456e-07,3.91155481338501e-08,9.361188858747482e-06,-4.23286110162735e-07,3.674067556858063e-07,9.361188858747482e-06,-4.23286110162735e-07,3.674067556858063e-07,-5.4016709327697754e-08,1.0244548320770264e-08,-2.8870999813079834e-08,0.0,0.0,0.0,0.00020651519298553467,4.284083843231201e-06,1.6326084733009338e-06,0.0,0.0,0.0
+11,11,0.37499977927664024,560.7502121757716,3.314577043056488e-06,8.987262845039368e-07,1.3830140233039856e-06,-2.514570951461792e-07,2.1979212760925293e-07,-6.938353180885315e-08,-4.330649971961975e-08,-2.1560117602348328e-07,-5.153939127922058e-06,-8.381903171539307e-08,-2.60770320892334e-07,5.122274160385132e-06,6.705522537231445e-08,2.4586915969848633e-07,1.484062522649765e-06,-1.9138678908348083e-07,4.5029446482658386e-07,1.484062522649765e-06,-1.9138678908348083e-07,4.5029446482658386e-07,-3.166496753692627e-08,-1.6763806343078613e-08,-1.4901161193847656e-08,0.0,0.0,0.0,0.00020799925550818443,4.09269705414772e-06,2.0829029381275177e-06,0.0,0.0,0.0
+12,12,0.4687496533735736,560.750213930849,3.0328519642353058e-06,1.119915395975113e-06,1.7550773918628693e-06,-2.8172507882118225e-07,2.2118911147117615e-07,-3.632158041000366e-08,1.6763806343078613e-08,-7.171183824539185e-08,-5.262903869152069e-06,-1.1175870895385742e-08,-2.4866312742233276e-07,5.2247196435928345e-06,3.5390257835388184e-08,2.5890767574310303e-07,1.8295831978321075e-06,-3.227032721042633e-07,2.8265640139579773e-07,1.8295831978321075e-06,-3.227032721042633e-07,2.8265640139579773e-07,-3.818422555923462e-08,2.421438694000244e-08,1.0244548320770264e-08,0.0,0.0,0.0,0.00020982883870601654,3.769993782043457e-06,2.3655593395233154e-06,0.0,0.0,0.0
+13,13,0.37499977927664024,560.7502138046548,3.2046809792518616e-06,1.4081597328186035e-06,-1.2619420886039734e-07,1.7182901501655579e-07,2.882443368434906e-07,-2.3283064365386963e-08,3.073364496231079e-08,-6.51925802230835e-09,-4.963483661413193e-06,-2.016313374042511e-07,-3.8137659430503845e-07,4.928559064865112e-06,2.0489096641540527e-07,3.948807716369629e-07,-6.798654794692993e-08,1.3783574104309082e-07,2.812594175338745e-07,-6.798654794692993e-08,1.3783574104309082e-07,2.812594175338745e-07,-3.4924596548080444e-08,3.259629011154175e-09,1.3504177331924438e-08,0.0,0.0,0.0,0.0002097608521580696,3.907829523086548e-06,2.64681875705719e-06,0.0,0.0,0.0
+14,14,0.46874959050938997,560.7502162489109,3.7285499274730682e-06,1.762527972459793e-06,2.4442560970783234e-06,5.238689482212067e-07,3.543682396411896e-07,-3.026798367500305e-08,-1.3969838619232178e-09,-3.3993273973464966e-08,-4.4191256165504456e-06,-1.9650906324386597e-07,-5.21540641784668e-07,4.349276423454285e-06,1.993030309677124e-07,4.973262548446655e-07,2.5443732738494873e-06,5.224719643592834e-07,4.12575900554657e-07,2.5443732738494873e-06,5.224719643592834e-07,4.12575900554657e-07,-6.984919309616089e-08,2.7939677238464355e-09,-2.421438694000244e-08,0.0,0.0,0.0,0.0002123052254319191,4.430301487445831e-06,3.059394657611847e-06,0.0,0.0,0.0
+15,15,0.4687496533735736,560.7502168049105,4.124362021684647e-06,2.1760351955890656e-06,5.559995770454407e-07,3.9581209421157837e-07,4.1350722312927246e-07,-1.30385160446167e-08,1.4901161193847656e-08,-3.073364496231079e-08,-3.9315782487392426e-06,-2.3702159523963928e-07,-5.564652383327484e-07,3.905966877937317e-06,2.1047890186309814e-07,5.345791578292847e-07,5.94649463891983e-07,4.0745362639427185e-07,4.66126948595047e-07,5.94649463891983e-07,4.0745362639427185e-07,4.66126948595047e-07,-2.561137080192566e-08,-2.6542693376541138e-08,-2.1886080503463745e-08,0.0,0.0,0.0,0.00021289987489581108,4.837755113840103e-06,3.525521606206894e-06,0.0,0.0,0.0
+16,16,0.46874959050938997,560.7502207290381,4.730187356472015e-06,2.6812776923179626e-06,3.924127668142319e-06,6.058253347873688e-07,5.052424967288971e-07,-1.816079020500183e-08,3.119930624961853e-08,4.0512531995773315e-08,-3.7918798625469208e-06,-2.4354085326194763e-07,-2.1373853087425232e-07,3.7383288145065308e-06,2.738088369369507e-07,2.1047890186309814e-07,3.9958395063877106e-06,5.443580448627472e-07,4.6798959374427795e-07,3.9958395063877106e-06,5.443580448627472e-07,4.6798959374427795e-07,-5.3551048040390015e-08,3.026798367500305e-08,-3.259629011154175e-09,0.0,0.0,0.0,0.0002168957144021988,5.38211315870285e-06,3.993511199951172e-06,0.0,0.0,0.0
+17,17,0.4687496533735736,560.7502247327939,5.152076482772827e-06,3.11434268951416e-06,4.003755748271942e-06,4.2188912630081177e-07,4.330649971961975e-07,-2.2351741790771484e-08,4.377216100692749e-08,8.847564458847046e-08,-3.375113010406494e-06,-3.2782554626464844e-07,-1.3597309589385986e-07,3.3508986234664917e-06,3.371387720108032e-07,1.1734664440155029e-07,4.050321877002716e-06,3.688037395477295e-07,3.632158041000366e-07,4.050321877002716e-06,3.688037395477295e-07,3.632158041000366e-07,-2.421438694000244e-08,9.313225746154785e-09,-1.862645149230957e-08,0.0,0.0,0.0,0.0002209460362792015,5.75091689825058e-06,4.3567270040512085e-06,0.0,0.0,0.0
+18,18,0.37499977927664024,560.7502263993956,5.057547241449356e-06,3.395136445760727e-06,1.6666017472743988e-06,-9.452924132347107e-08,2.8079375624656677e-07,-4.190951585769653e-09,-9.266659617424011e-08,3.213062882423401e-08,-2.8391368687152863e-06,-1.0849907994270325e-07,3.4924596548080444e-08,2.816319465637207e-06,1.1175870895385742e-07,-4.842877388000488e-08,1.6936101019382477e-06,-5.122274160385132e-09,2.621673047542572e-07,1.6936101019382477e-06,-5.122274160385132e-09,2.621673047542572e-07,-2.2817403078079224e-08,3.259629011154175e-09,-1.3504177331924438e-08,0.0,0.0,0.0,0.00022263964638113976,5.745794624090195e-06,4.618894308805466e-06,0.0,0.0,0.0
+19,19,0.4687496533735736,560.7502272753045,5.105510354042053e-06,3.3779069781303406e-06,8.759088814258575e-07,4.7963112592697144e-08,-1.7229467630386353e-08,-6.51925802230835e-09,-2.0023435354232788e-07,1.30385160446167e-08,-2.5546178221702576e-06,-1.30385160446167e-08,-2.60770320892334e-08,2.4884939193725586e-06,2.60770320892334e-08,4.842877388000488e-08,9.485520422458649e-07,2.3515895009040833e-07,-5.2619725465774536e-08,9.485520422458649e-07,2.3515895009040833e-07,-5.2619725465774536e-08,-6.612390279769897e-08,1.30385160446167e-08,2.2351741790771484e-08,0.0,0.0,0.0,0.00022358819842338562,5.980953574180603e-06,4.566274583339691e-06,0.0,0.0,0.0
+20,20,0.37499977927664024,560.7502297507599,4.798173904418945e-06,3.063119947910309e-06,2.475455403327942e-06,-3.073364496231079e-07,-3.1478703022003174e-07,-9.313225746154785e-09,-1.8440186977386475e-07,6.332993507385254e-08,-2.4726614356040955e-06,1.6763806343078613e-07,2.7939677238464355e-08,2.473592758178711e-06,-1.5273690223693848e-07,-1.1175870895385742e-08,2.483837306499481e-06,-1.3783574104309082e-07,-3.948807716369629e-07,2.483837306499481e-06,-1.3783574104309082e-07,-3.948807716369629e-07,9.313225746154785e-10,1.4901161193847656e-08,1.6763806343078613e-08,0.0,0.0,0.0,0.0002260720357298851,5.843117833137512e-06,4.171393811702728e-06,0.0,0.0,0.0
+21,21,0.46874973195382685,560.7502321340144,4.494562745094299e-06,3.1962990760803223e-06,2.3832544684410095e-06,-3.03611159324646e-07,1.3317912817001343e-07,4.656612873077393e-10,-1.671724021434784e-07,7.59027898311615e-08,-2.6640482246875763e-06,2.6496127247810364e-07,-1.1874362826347351e-07,2.6579946279525757e-06,-2.514570951461792e-07,1.0244548320770264e-07,2.3888424038887024e-06,-1.4994293451309204e-07,7.35744833946228e-08,2.3888424038887024e-06,-1.4994293451309204e-07,7.35744833946228e-08,-6.05359673500061e-09,1.3504177331924438e-08,-1.6298145055770874e-08,0.0,0.0,0.0,0.0002284608781337738,5.69317489862442e-06,4.244968295097351e-06,0.0,0.0,0.0
+22,22,0.37499977927664024,560.7502323002554,4.1215680539608e-06,2.848450094461441e-06,1.6624107956886292e-07,-3.7299469113349915e-07,-3.478489816188812e-07,4.656612873077393e-10,-1.9511207938194275e-07,8.149072527885437e-08,-2.8708018362522125e-06,2.48197466135025e-07,-3.3574178814888e-07,2.8423964977264404e-06,-2.7567148208618164e-07,3.390014171600342e-07,1.9418075680732727e-07,-1.5040859580039978e-07,-4.3259933590888977e-07,1.9418075680732727e-07,-1.5040859580039978e-07,-4.3259933590888977e-07,-2.8405338525772095e-08,-2.7474015951156616e-08,3.259629011154175e-09,0.0,0.0,0.0,0.00022865505889058113,5.54276630282402e-06,3.8123689591884613e-06,0.0,0.0,0.0
+23,23,0.46874973195382685,560.7502347086556,4.095491021871567e-06,2.866145223379135e-06,2.4084001779556274e-06,-2.60770320892334e-08,1.7695128917694092e-08,1.909211277961731e-08,-2.2398307919502258e-07,8.335337042808533e-08,-2.6407651603221893e-06,7.683411240577698e-08,-1.9231811165809631e-07,2.6561319828033447e-06,-6.332993507385254e-08,2.2724270820617676e-07,2.3739412426948547e-06,1.8440186977386475e-07,-1.0058283805847168e-07,2.3739412426948547e-06,1.8440186977386475e-07,-1.0058283805847168e-07,1.5366822481155396e-08,1.3504177331924438e-08,3.4924596548080444e-08,0.0,0.0,0.0,0.00023102900013327599,5.727168172597885e-06,3.7117861211299896e-06,0.0,0.0,0.0
+24,24,0.46874973195382685,560.7502328557894,4.124827682971954e-06,3.1795352697372437e-06,-1.8528662621974945e-06,2.9336661100387573e-08,3.133900463581085e-07,1.6763806343078613e-08,-1.30385160446167e-07,1.0058283805847168e-07,-2.0116567611694336e-06,7.450580596923828e-08,-6.239861249923706e-08,2.0526349544525146e-06,-9.313225746154785e-08,7.078051567077637e-08,-1.910608261823654e-06,1.7834827303886414e-07,2.0442530512809753e-07,-1.910608261823654e-06,1.7834827303886414e-07,2.0442530512809753e-07,4.0978193283081055e-08,-1.862645149230957e-08,8.381903171539307e-09,0.0,0.0,0.0,0.00022911839187145233,5.905516445636749e-06,3.916211426258087e-06,0.0,0.0,0.0

research/fine_surface_joint_20261014/zero_summary.json

@@ -0,0 +1,67 @@
+{
+  "speed": 0.0,
+  "initial_leaf": [
+    560.7500041779131,
+    0.0,
+    0.0
+  ],
+  "final_leaf": [
+    560.7502328557894,
+    4.124827682971954e-06,
+    3.1795352697372437e-06
+  ],
+  "raw_residual": [
+    0.00022911839187145233,
+    5.905516445636749e-06,
+    3.916211426258087e-06
+  ],
+  "exact_average_residual": [
+    0.00022854655981063843,
+    5.717389285564423e-06,
+    3.6330893635749817e-06
+  ],
+  "cumulative": {
+    "boundary": [
+      1.3131648302078247e-07,
+      -1.5925616025924683e-06,
+      -4.5355409383773804e-07
+    ],
+    "fine_transfer": [
+      -9.47713851928711e-05,
+      3.1068921089172363e-06,
+      -2.084299921989441e-06
+    ],
+    "coarse_transfer": [
+      9.419955313205719e-05,
+      -3.295019268989563e-06,
+      1.8011778593063354e-06
+    ],
+    "rounding": [
+      0.00022911839187145233,
+      5.905516445636749e-06,
+      3.916211426258087e-06
+    ],
+    "average": [
+      -5.718320608139038e-07,
+      -1.8812716007232666e-07,
+      -2.8312206268310547e-07
+    ]
+  },
+  "checks": {
+    "validity": true,
+    "geometry_unchanged": true,
+    "boundary_count": 48,
+    "collision_count": 72,
+    "local_collision": true,
+    "local_regime": true,
+    "bfl": true,
+    "transfer_rounding": true,
+    "interval_closure": true,
+    "cumulative_closure": true
+  },
+  "max_collision_ratio": 0.46394191845799526,
+  "max_collision_error": 1.2914339875269576e-07,
+  "max_bfl_error": 1.0332863675799331e-08,
+  "max_interval_closure": 0.0,
+  "drive_mass": 3.733417470608985e-07
+}

research/fixed_patch_jet_20261013/baseline.json

@@ -0,0 +1,536 @@
+{
+  "hashes": {
+    "src/CelerisLab.egg-info/PKG-INFO": "0b9a8a4e8d60bc531473688723ddef0aab02c7ccc4997e31c9b6a6c35011ca77",
+    "src/CelerisLab.egg-info/top_level.txt": "cd51958ca03afabbaa9618c60b8280e486f8cc0b0359b839e10f886e7c3948f8",
+    "src/CelerisLab.egg-info/dependency_links.txt": "01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b",
+    "src/CelerisLab.egg-info/requires.txt": "36e1404178e5ea590b2fc04e8ba4d748ec9a82e7693136ccf0dfd204fe265c04",
+    "src/CelerisLab.egg-info/SOURCES.txt": "f36b29c1b34c4bd6b2acc3ccdd21c24ee5077df7e2a20a652d9fae77eedb8e21",
+    "src/CelerisLab/simulation.py": "34d69e71844f553790c5a2bed0f8fbfb912a9498e95b500d1ef2ad41cae3b424",
+    "src/CelerisLab/config.py": "2f1bba7515f5bc08cb3a8d140bcafe7fa0689e01b3b06494697bb2956a71530e",
+    "src/CelerisLab/__init__.py": "21cc469bd6e970a1f9ff5970c8eea4602065e41fc881854759ee565ee55c10c6",
+    "src/CelerisLab/cuda/compiler_v2.py": "c4cc3ec4445c8d75e6a253dd87963877117a722bc73b9d4811806fc6045d08c1",
+    "src/CelerisLab/cuda/obs_layout.py": "5ffb2c3aeeaaaaeb64f2cd8febfbcf4ad9919e5414020ad753cfade0683b21c2",
+    "src/CelerisLab/cuda/context.py": "013dd4ec6d01d2fbd11afdfb103eac6a273bd9f798d663d761b851eeb27885e9",
+    "src/CelerisLab/cuda/__init__.py": "0d01dff9f0399c8baba822aab5ca0122a135f011008ed8a499ebd9f7e5b06aea",
+    "src/CelerisLab/lbm/refinement_stepper.py": "ad57a6a3887b007488b4954b24ff06cd8cde2b12674bdafb97bfda1961ae1da4",
+    "src/CelerisLab/lbm/field.py": "0e727eacc3706add4d8d15c418e9b631050871f831698d3ac689dd5f2c701b9b",
+    "src/CelerisLab/lbm/equilibrium.py": "2fb2f2bb7ff326d23abce80fc2a4c0907b17740ea3e29fe6ae079c5044783826",
+    "src/CelerisLab/lbm/descriptors.py": "c9f025dfc14da43b989047b84cc22bd05d5cc92c9ec695c1da68fdfb788e3f2b",
+    "src/CelerisLab/lbm/initializers.py": "dacf9586963e862d6d0a98ef1a066036be6f91e9d423720661d8ef2c1fb2df6a",
+    "src/CelerisLab/lbm/curved_links.py": "587f3f4638688c09c0850bef2f314780d03f06c9211abc5fd773fbeecabc3326",
+    "src/CelerisLab/lbm/stepper.py": "e9e51e3a902fbda086d4707c0487e7b1dea6246fab290a24d82bd52d4296410e",
+    "src/CelerisLab/lbm/__init__.py": "7f60fb3aaae81501b510d08c2fedff44fcb05657260eb10b6f5cc91e7204306b",
+    "src/CelerisLab/lbm/refinement.py": "554735c5613129eb29f339c6aeeb4f3a3bbc5aba67558be51fbf7c2fb6ac442a",
+    "src/CelerisLab/lbm/kernels/kernel_v2.cu": "c7bd3fb705b77261ba2441c52a24a7e6a7865c165cba088a1b75201c4d29c408",
+    "src/CelerisLab/lbm/kernels/refinement.cu": "025c59dc9c207a831e78e1635cb3f14fe60b64c021004a0d66e5d01fda8554b5",
+    "src/CelerisLab/lbm/kernels/config.h": "7d1124125e0b354558297934460e64c760fb68cdd7bf6d01a1238bb2eaab8c37",
+    "src/CelerisLab/lbm/kernels/kernel_v2.ptx": "a599ee30ae66800f4d4220eb79dfed35ff32991661260f01ea58023ef780f0ca",
+    "src/CelerisLab/lbm/kernels/operators/turbulence_smag.cuh": "ff7f000297ee0817e255ad9fcb6a13b647e3ddd5b206518d35f38d2895a9f501",
+    "src/CelerisLab/lbm/kernels/operators/collision_mrt.cuh": "aee444eb60c47a3fd518dca975d1af05425a0818a0ec6c3fb3f6150f60c2cb44",
+    "src/CelerisLab/lbm/kernels/operators/collision_trt.cuh": "9725b9840b9ad8b4ec7be61ff5d06d3151e86d1a87585c13f2fbf934d0d2c5f6",
+    "src/CelerisLab/lbm/kernels/operators/collision_srt.cuh": "6b7ff842f392c8f853d2d1a97cc69bfe50f21283f73e659404da07cf6c95f5e1",
+    "src/CelerisLab/lbm/kernels/operators/forcing_guo.cuh": "969a430c1af03f32e3bd0df95d805e64f56334717c44dd4ba208ba503062a24b",
+    "src/CelerisLab/lbm/kernels/operators/macro.cuh": "e27c1c410dc857be98da4596568e405eeaf88701d291ac0e398aa9cd23dee740",
+    "src/CelerisLab/lbm/kernels/operators/helpers.cuh": "0b3a4d95d7d19f5fec09e5423b8f4cc99f8a226b541967425967330da5a051ec",
+    "src/CelerisLab/lbm/kernels/core/precision.cuh": "849df14b4cce50af52399e4b8f3e997196f3ae5f1163f68e28df3e6b2507a8c4",
+    "src/CelerisLab/lbm/kernels/core/descriptors.cuh": "8440bc14857da9007982650f828a23608eec9f7cc4bf772e8c8dc1239cb45356",
+    "src/CelerisLab/lbm/kernels/core/obs.cuh": "b742b77c9f61e1f020fe9922c3838ae9d855e17b381154958b58f10a22938922",
+    "src/CelerisLab/lbm/kernels/core/params.cuh": "6e18bf730d936d940e3d85452f0714a2eaae31bf41002f9fd520ec5b372878dd",
+    "src/CelerisLab/lbm/kernels/core/flags.cuh": "0025705f24710330d9d9195f713879bfb650a85a3449baef0e196b831af104ab",
+    "src/CelerisLab/lbm/kernels/core/layout.cuh": "1fbd820021c89ac3efcde24145996cb0147769e607e498e61f308ed3e0b13706",
+    "src/CelerisLab/lbm/kernels/boundary/ibm_kernels.cuh": "e6909b547dc8d64cdd8a76a90660243a8f5fee535caa161b52b4dd8b7c29934b",
+    "src/CelerisLab/lbm/kernels/boundary/planar_velocity.cuh": "0b2f9e0bd483c199637e5672dc0ffc460bc383dd1804805befbeb4c5d8c708d1",
+    "src/CelerisLab/lbm/kernels/boundary/inlet_outlet.cuh": "de8b213a6da42c2e5e9f8966199fc66ea4541b85144a90f3f5dbad3c6ab63b97",
+    "src/CelerisLab/lbm/kernels/boundary/curved_boundary.cuh": "4bd761e81b32f4bb3238fbb1f6ea890cde0cc987cd8bbeb54e9df8b0e1b57914",
+    "src/CelerisLab/lbm/kernels/boundary/bounce_back.cuh": "aba3748c564ed91b161d268ef8b737b7c7be96a823063d201f3da684dd845233",
+    "src/CelerisLab/lbm/kernels/boundary/esopull_curved_helpers.cuh": "b9b474bc4edaff05681c5443235472d04072d0d775fc0eb9c5967faef52b0258",
+    "src/CelerisLab/lbm/kernels/boundary/inlet/equilibrium.cuh": "f0964c811b2c41a5aaa1c6d99c490b06e850c634eb8749f1f05ef61f93c2de1d",
+    "src/CelerisLab/lbm/kernels/boundary/inlet/channel_stabilized.cuh": "efe077afcbb6b731256a987c2fd79a1dbc470c902f87070d60421ea6cb13d4e2",
+    "src/CelerisLab/lbm/kernels/boundary/inlet/common.cuh": "f3cec54c8873c65b3dca4375605d2c89a8727765884d3954c235242fdff9c6ba",
+    "src/CelerisLab/lbm/kernels/boundary/inlet/zou_he_local.cuh": "e73e66b853b1e4e0e30d8f4185d832aa414ce670a1813ce2b5459f2887f71f89",
+    "src/CelerisLab/lbm/kernels/boundary/inlet/regularized.cuh": "943d4a571818bacb89c70bccfaac202691121e3e385803ce6309123a0a03ddaf",
+    "src/CelerisLab/lbm/kernels/boundary/outlet/pressure_neq.cuh": "c8b2adc66d12fe602076ddc9693c5c208711fcaddb58aa9a31401a269f51c4c4",
+    "src/CelerisLab/lbm/kernels/streaming/esopull_single_buffer.cuh": "77ed4ab9a0ebc5ff62a91a7c39066ef395391ae36e9040a69fb2bd8b1626dc79",
+    "src/CelerisLab/lbm/kernels/streaming/pull_double_buffer.cuh": "b65d741ed78b7b62f99531ba0c0ce1936663d8dc9640e7d7d16c707f1baf6549",
+    "src/CelerisLab/lbm/kernels/streaming/esopull_semantic_helpers.cuh": "dd5a9091628b079efd97e53fd49e52d09dcee88529235db77a5648e02937af6e",
+    "src/CelerisLab/lbm/kernels/step/esopull_sync.cu": "c0ff3e72900c3ab89a05dd03684e96d3b740cf1672d565727fc2af165933d087",
+    "src/CelerisLab/lbm/kernels/step/init_flow.cu": "305be3bb12fc0d039acec1701baabcf0e8a35e683c49c34f2af8ca9867d2b29c",
+    "src/CelerisLab/lbm/kernels/step/esopull_macro.cu": "c73116020ca217ede1e4de27c8269c31f9d91e33433ac8252a21e9b14187c50f",
+    "src/CelerisLab/lbm/kernels/step/aux_kernels.cu": "bb7f07d898f0d5151e5bd0f45e6bd819c5e83a345a265b73204906ac3cc29db4",
+    "src/CelerisLab/lbm/kernels/step/one_step_esopull.cu": "aa223b2744ae6c9125673df311a96ce588032c1ba58bebb11fd33ecb990f8ed4",
+    "src/CelerisLab/lbm/kernels/step/one_step_double.cu": "f9f8242b38e8e0cf8425b75e2b0215bc15363c62eaa0fb43c761b8e0931bfdc9",
+    "src/CelerisLab/lbm/kernels/config/config_physics.h": "26df33c2960ba36f3283e19b55b4ea92e50e4efda705f9ebfbf3f875a4092c59",
+    "src/CelerisLab/lbm/kernels/config/config_method.h": "3db4e16ef2c6b22349d04e6aa8ab04bdfe0eb784f9f3a98277e15dbed1835d81",
+    "src/CelerisLab/lbm/kernels/config/config_grid.h": "8be3a7cf74ba30d7fd3074fed79e63dbda7311c4d03b454ea641bf298ffeaa8d",
+    "src/CelerisLab/lbm/kernels/config/config_objects.h": "dbb93c063586da278c15d95e23f84c12e728f4f5f1bbc3980fe9cedaa6fff90e",
+    "src/CelerisLab/lbm/kernels/config/config_obs.h": "c11e2249359145b5c4cbaaf0487506fa77c1f4b82c7c169ddc574aa0babcd727",
+    "src/CelerisLab/common/checkpoint.py": "5b7caf3896167a3f37c539b58837de6eb3f8085fa7bf5f821a09666cc16d43a4",
+    "src/CelerisLab/common/_types.py": "aad2ff1a9033d4fd68783ad7123afb47201ddc58785cb6dc0246947037072a5f",
+    "src/CelerisLab/common/pathline.py": "a1b6efcc0a076d0f1dc8d49a595779426d7d5626b00072a59bac710ff02ad046",
+    "src/CelerisLab/common/__init__.py": "d4dbde78bc97fccc9eabac9abae8f0f15c112c10ff8e9b45bd9401d4723df1ef",
+    "src/CelerisLab/common/preprocess.py": "7fc78a08857cf8e98519500b094a1d896af189b6b15658ff9b388ed51bed4515",
+    "src/CelerisLab/common/render.py": "0e055476257eb2bcd11e733766e52195de02f8fad228f570a3511a7c831bdc29",
+    "src/CelerisLab/common/streakline/_render.py": "236cd637414ee318c4d66f9aed32110d8dc42a100d65fde06172f7cd0ba62c65",
+    "src/CelerisLab/common/streakline/_integrate.py": "3fbd4368b2c8d0e7fda40dc65aac5df02b085008b4c68acd83cb7ae45d33a13b",
+    "src/CelerisLab/common/streakline/_streakline.py": "1a3e08daa706b5f83cdeb337e9a945a36ddf7583c40af1d0bb9d825ac954df37",
+    "src/CelerisLab/common/streakline/__init__.py": "13ff1cfa416fdd721a08a659e76b5a5a99b8d3201add10a83b7b0bc654bc1eec",
+    "src/CelerisLab/common/streakline/_config.py": "a9185ef68e9c7b5d5a1dc0b04a28341e2ad91d13c145a7c106636a878cf0a605",
+    "src/CelerisLab/configs/config_lbm.json": "17e4311f1f250c6ece59177a8b6ff856b69a016c7c10267e774b030a0a390865",
+    "src/CelerisLab/configs/CONFIG.md": "41cafdbe525366c08aa9d0416ea026ccf0026ba7123b8a9b65f968a80d928e3a",
+    "src/CelerisLab/configs/config_lbm_three_cylinder_triangle.json": "eeb8e7149dbe4aa6b3a9562802735aa950750dfbe2d972a0727e788573afa817",
+    "src/CelerisLab/configs/config_lbm_flume_trt_regularized.json": "f4bba8e6a4339fc3c4eb14f6e2f57c4b22993c73703c773d853edfbe34736e56",
+    "src/CelerisLab/configs/config_body.json": "055f261f0828ca1d4f2bb694bd15b72bbcabe31d552326208f28e37f761adab1",
+    "src/CelerisLab/configs/config_lbm_flume_mrt_zouhe.json": "8f593321db05a563a42931603a228d61cbcba06dfbe113262d5cd0ad93c0fe79",
+    "src/CelerisLab/body/objects.py": "71692d098ebb5ab2d0e614cb9b7854f048b8b33fbe6707e61fd0e8ac35745017",
+    "src/CelerisLab/body/action_smoother.py": "b1a23ee6bbd4850b172cb8738c5c3546ee465a54189e6af9d8044f023d4687dc",
+    "src/CelerisLab/body/registry.py": "fbb7327780adbdc6da15ebdb799980daf32df22ee974af0893d7409f177bbb68",
+    "src/CelerisLab/body/manager.py": "eac22c9ac92c26e89c10bb089fb3c4156e4eb7bd0c1b1f6fe6dd32e2940a020e",
+    "src/CelerisLab/body/ddf_patch.py": "60fcfb7441e73bf290bcff41ca3a83da3e7ddad765d7247464e8f02e3043b4e2",
+    "src/CelerisLab/body/sync_plan.py": "a73ac9ee361b2120d0b7bbebeaa2ccbf924ba27bd95d4dd4b383c10a39b2a409",
+    "src/CelerisLab/body/__init__.py": "d6ec221d51eaf7b1da11ef320b399599cf5b9422e5bc271a7264a273033e6928",
+    "src/CelerisLab/body/preprocess/flag_overlay.py": "831fc9e9736b758847759a085ff133eb49ec91318ace4fda76f85960138ee300",
+    "src/CelerisLab/body/preprocess/__init__.py": "dfd9d58bc07f626ab23a70053e31b88a6d9165d2e4c76a4e9f48abe674d3d2ec",
+    "src/CelerisLab/body/geometry/base.py": "cceca14361ca2f34d34a3e43730e1a79b8ca81be00f0dd62e884db32b479419f",
+    "src/CelerisLab/body/geometry/__init__.py": "ada88980ab672959aca9aa3a4c4aade3219524b2ab68110cd2a2f41e3e0ca90a",
+    "src/CelerisLab/body/geometry/circle.py": "7605ca7c21103f1d801ac73ab8dd18dffbdac425b2dee7b8858b283628a9e436",
+    "src/CelerisLab/body/coupling/soa_packer.py": "8ec26fd55ef74801bbd5ab6bd3d0a7dabc750cbd498aaac2ca4c61a0108ad3c9",
+    "src/CelerisLab/body/coupling/__init__.py": "c931f7eb318d48408c3e2febcc6917c88c8dcc1697cbf4329b1f340d94c35763",
+    "tests/conftest.py": "fa0ec26667872c9c1011d608310d2551fd24719b5d216f06d923ff4c74c73237",
+    "tests/specs/exp_ctrl_matrix.md": "5d9dd2e703582572eb68afe3a7096ea43ec82aa03418d20ed283c5365031e433",
+    "tests/specs/Sah04_validation.md": "1d122d29e281b7f50801b148f3314a0e35fdc27ee7d757c0a661243aa6185fb0",
+    "tests/specs/sah04.md": "33dbe5e0fd63738abd055c4aa403c191b6de04e6efdbc568f1942c6d23c7459f",
+    "tests/specs/Kan99b_validation.md": "0d8bf74f2361f863809af1979bf8807adaa423f98321e1104a3d86d8c7a863cf",
+    "tests/specs/kan99b.md": "b7e0669f0a6b677d902204f3427d1b3ac254bfe70c37d9cf995fb3e8f1fedfb1",
+    "tests/specs/streakline_notes.md": "cd342d214c07eb608ac2e5b8697322c44c31dbf4d27dfdb5409de46ef474df4b",
+    "tests/validation/run_perf_baseline.py": "93dde2eb1132f45ea69e1e285ff421dc97a83651a22c79571f299c1909650721",
+    "tests/validation/run_j1.py": "51b758a271ff358f931b3140a80082294a67e66c2fec0f8c19319e37f92aadc4",
+    "tests/validation/run_kan99b_rotating_cylinder.py": "323186429a100f36b41ab9b81ade2da6a47e93be3ccb7034a3a6b97f4ee8eb00",
+    "tests/validation/run_j2_slot.py": "b7d2d3aa06fcafc3ac62ed4a50892afbdb7f86e5720ce75a39ce317b6f571dad",
+    "tests/validation/run_j3_coverage.py": "329869519b7078e854d96241a7aad8ef93f35ac9be83f0be502c3a93523c3b13",
+    "tests/validation/run_sah04_st_matrix.py": "9b9c0ce063e07a316846635ee769b837ed26be6bf039f78f4219c10b516f8006",
+    "tests/validation/analyze_j3_saved_frames.py": "438f67dac682b94c4950626f8de4fdcde48c3a4e9ecf8fdf1b0ada4b6e0e781a",
+    "tests/validation/diagnose_j3_lags.py": "286fcd65b3261667a847b9b26e213d0af92cf459faa6bbd774f78c8479ce31d7",
+    "tests/validation/run_j3_reservoir.py": "47535bc3569ce68c888d38978bc4f9077fd763a17829c20c081be52bb18a2903",
+    "tests/validation/run_poiseuille.py": "e529288e2ffa8e00d281a9006723954d60a96ae4d025e8f28656c09287d4ff46",
+    "tests/validation/test_sensor_accuracy.py": "c6038a9e7a597a1738814bd15e6ecf357cfd271cdc2a132d47943c5280ac0ef9",
+    "tests/validation/multigrid/test_cpu_reference.py": "ade5d4827f971aed7174b59d83769e7aa542338e625a9fc8db1e8b1805cb74ca",
+    "tests/validation/multigrid/cpu_reference.py": "bba2a06a9f6517b32079ffff15e4060d8c3b7ed35f16ca134e1877226c9e4e1e",
+    "tests/validation/multigrid/cpu_reference_v0.2.py": "b6adbad7da625ef6a6b97958ea9625030ed92676d0cada48e061c87bcf7ca8c9",
+    "tests/validation/multigrid/test_open_corner_negative_control.py": "59a6f8ca80cdd63cb7827fbebf9b4b555c3793f19dd6bca801544ec10b5cbe1b",
+    "tests/validation/multigrid/test_refinement_followup.py": "6643e26cd877bf0d0f030e974f00a1d1c0f0350cc76d1c8affed3e8ba2f4393b",
+    "tests/validation/multigrid/local_stress_observable_v1.py": "0e2777990359a7cf2bb29884173b7b01de37c49bcf49e1f29fc59fe83d62b456",
+    "tests/validation/multigrid/test_refinement_gpu.py": "0021a39b3a131347196845cff6507c90c387b46b772fe1319d634178c5e13354",
+    "tests/validation/multigrid/shear_diagnostic_v0_2.py": "a8b1cf2f7abd00efc4d068bbd27bb2317144a6ca4c545d9b2e0dcf421eadebc6",
+    "tests/validation/multigrid/test_tron_additions.py": "8e7a6a90b85e64c7326719e7b8bca2f6d34fb4c80690f0685f7e291ab93bd2a4",
+    "tests/validation/multigrid/MULTIGRID_VERIFICATION_STRATEGY.md": "d4f3473da44abee6031a0e1bd4d0ca589077a18f15d2461836e4d2ebb98e458a",
+    "tests/validation/multigrid/shear_v0_2_evidence/stdout_horsea.txt": "0577df5b3f5cb3c7b6e1ef2de71344f8fd3e6d959117487a06cbaf7f2afa3dea",
+    "tests/validation/multigrid/shear_v0_2_evidence/stdout_grok.txt": "28ddd1267ca91a772f5a6bfc65d949c9a4ea7dac5c9ba3a0bdb168492810b670",
+    "tests/validation/multigrid/shear_v0_2_evidence/run_once.py": "6698a2e040c56be949b809387d4518eb0ba82d34cc9d99640da4f8bf3c35c23f",
+    "tests/validation/multigrid/shear_v0_2_evidence/source_manifest.json": "56fbd0259ff3d4dbd14ace52f64e249a435e9df91732b0e4027def2c344c2e6a",
+    "tests/validation/multigrid/shear_v0_2_evidence/results_horsea.json": "c2d7ce8d16a0f47baff0788a153353dcf67088da974d9cd3d521b04ecd91ee05",
+    "tests/validation/multigrid/shear_v0_2_evidence/comparison.json": "41c00372099dd04b6d323785e9eaf4fec09da1753d3d150ffa230800f904142f",
+    "tests/validation/multigrid/shear_v0_2_evidence/baseline.json": "98a7853341ea732762c7506694e3a867a7259bf110e9e461ea84f741fd9ab829",
+    "tests/validation/multigrid/shear_v0_2_evidence/manifest.json": "e42aa19e91608164698bea42da88fbbfab8b0f87cc37b27c5baf165453a4fdb0",
+    "tests/validation/multigrid/shear_v0_2_evidence/README.txt": "4306a34b6896bd6e7a5c2ca71d68e18450359239d0c7ad7a67a4e83e7155959a",
+    "tests/validation/multigrid/shear_v0_2_evidence/joint_report.md": "1860b8082108c8b8a87998af90cd0b81dce1c04e9f6c67b41e0912f9fef6cc9c",
+    "tests/validation/multigrid/local_stress_v1_evidence/stdout_horsea.txt": "882f2cfb1dbdf82cce63c011397e7c2e6307bbcfec42a3510648d328cd6ddcfe",
+    "tests/validation/multigrid/local_stress_v1_evidence/run_once.py": "e629800291ef65ffea8555f66ec80bf15200552540b2a493a677bfb53d0830b3",
+    "tests/validation/multigrid/local_stress_v1_evidence/source_manifest.json": "d2cf90b73458f493c665c9a281d06aef0c190cf0d143639fb77ab838c78f020c",
+    "tests/validation/multigrid/local_stress_v1_evidence/results_horsea.json": "f17b4644d19eb75d55deb7021ab679cb9e7922a2b46f1cacf8b6da6bfb9a2690",
+    "tests/validation/multigrid/local_stress_v1_evidence/comparison.json": "be236671a501c31c06f7e266f6e0c0c2a89aede321a483452050ff37bf84c84a",
+    "tests/validation/multigrid/local_stress_v1_evidence/baseline.json": "64f6541447afbd15b1b15d802ad6f1b5042aaf84e7d4d2414e4ed4c52cf70507",
+    "tests/validation/multigrid/local_stress_v1_evidence/manifest.json": "3a9fa8c7d691c1b8c24f05940eb724d30b890dd8ed636551068d2633d7db2f70",
+    "tests/validation/multigrid/local_stress_v1_evidence/README.txt": "4f62314876047ee437bb9ecbf84798d2a9f6e85f6a3aef260277b85bcdb35fae",
+    "tests/validation/multigrid/local_stress_v1_evidence/stdout_local_stress_observable_v1.txt": "6a826e5ad729ce45af6879a07a1c659d8b4a21403fde5b9c6d9696cc6a5b09d4",
+    "tests/validation/multigrid/local_stress_v1_evidence/TABLE_local_stress_observable_v1.md": "d8ff0568d9c473a4bb09396a8948ddc8dc5af2f0f3a23ac84d238814fc779501",
+    "tests/validation/multigrid/cpuref_0_3_evidence/stdout_horsea.txt": "457f1d2173496554c87ca6e61df518c0b8f1e0a28cdfd94b94ebbb61bc459d70",
+    "tests/validation/multigrid/cpuref_0_3_evidence/stdout_grok.txt": "73e4ef01138842981daaa534390f1463839e63833c11f4e8872f94f8eaadc717",
+    "tests/validation/multigrid/cpuref_0_3_evidence/results_horsea.json": "914389afc39752bcd4132aa21fc8d5cbcf0ca75b1efd6a49becab15c2fa3361b",
+    "tests/validation/multigrid/cpuref_0_3_evidence/baseline.json": "0daaccee41cabeb17a00e2405e2c7fd0b80d36f2d01778eb39c9fd22b13d2d47",
+    "tests/validation/multigrid/cpuref_0_3_evidence/manifest.json": "2850ecaf2e19d010ba35eb54162371d82cc1a092831e08a03b6adf75a614988b",
+    "tests/validation/multigrid/cpuref_0_3_evidence/README.txt": "1947ee0232b88b3cc2c506d0b0af5ba051ecc94aa8f7f09228ef3939cc95919b",
+    "tests/validation/multigrid/cpuref_0_3_evidence/README_grok.md": "065947e15b2242bce7d3eb05a3acdbb59939c621dcd5d31540ad4a1bd4416818",
+    "tests/audit/\u5ba1\u8ba1\u62a5\u544a_kernel_layer.md": "89893c98ed7c2699157bf728ec0e79b0dd6aff4008ee5c7b77eb052de24033f1",
+    "tests/audit/body\u91cd\u6784\u7b14\u8bb0.md": "8f978d7b01c9f49dca9eeaff0d163cec6da085e2f99ee5a5e803d72306e7a72f",
+    "tests/audit/\u517c\u5bb9\u6027\u6d4b\u8bd5.md": "9c1721a33b381b9c3810545772b022913da06617711b5ba13a3c2c991b81a7f7",
+    "tests/audit/Force_region.md": "3092080afe4a30665fe1b721803621ba9d0dd5d20ad17826984d94efc160fdac",
+    "tests/audit/\u5ba1\u8ba1.md": "0f14ad073a0725134e6391f961c324fd0013c7791fd410713e94ed1ad40b7385",
+    "tests/audit/Force_region_validation.md": "279a4484d1bfca0fd67aed4de3282d547aa048f89389420d8e5f2fd86db54fc2",
+    "tests/audit/body\u5220\u51cf\u529f\u80fd.md": "e9f308a8cd0f0e7df5441c32a15f84c0bae50bc0e56b8728f6c6f2cf78596673",
+    "tests/unit/test_initializers.py": "8b4e3358d925614984265ae73c142006b48fd1c3918cf84901f18afd9fe68c3a",
+    "tests/unit/test_simulation_lifecycle.py": "77abdc33218c35e9c8b62dbd99ceddbaccd8417e7f0b539ea8859ea0175c663a",
+    "tests/unit/test_numerical_operators.py": "6d1d560ef553a2af7adac7db3e325d96d7fe39073d5fe3e0e982439537385b27",
+    "tests/unit/test_sync_plan.py": "983313ef783143231fa5a392f85f3bac011184773ccaf5d946504c206cabb721",
+    "tests/unit/test_state_regressions.py": "0f69cfeb83428192f95688c76abcae7e5b9cf5f27c52bca4ac20c7f320044374",
+    "tests/unit/test_equilibrium.py": "1ecbcc4547b1c846b75320463d828d6a36b6aae73208084fae476b1001c1bb50",
+    "tests/unit/__init__.py": "17f57920d9c1ff46096ceb2af008eb38c4b98dc81ffa3c3d310e758e80ca1cd4",
+    "tests/unit/test_pending_edits.py": "905a0dff23b123e8e38aaf364984c810fe51c39acd64aa271e343a4701d3d024",
+    "tests/unit/test_planar_velocity.py": "b656da0880b4234b1db805544edbe0d2473cbcc7c2c869c71d8251337f62a982",
+    "tests/unit/test_body_flags.py": "ac6409157924e15a13a3d2cc2f1a09014b8b0198ba17c824f412ff20b19e2aac",
+    "tests/unit/test_build_contracts.py": "7bb237425e8bb481f312fa4841c484e280731e13c7cbb9a53dad3e7f98984ac3",
+    "tests/unit/test_context_ownership.py": "299fed30dd0f9bd4dadd8b27f50df2a6367bdb0ab2ca3f391f215fde7241f35a",
+    "tests/unit/test_reservoir.py": "e718c78a53c3941aba7feb8ae4e8bb0b1726c1145de84febf91220c1917991c9",
+    "tests/unit/test_refinement.py": "90751142f920f1c5e988577a45afa94871a6617009cdc78323a87fc7795f4634",
+    "tests/unit/test_slot_velocity.py": "6a9494de9a32c350389ccbed58af48951f6b25a21a258537d2e8b73eb67cb11d",
+    "tests/unit/cpp/semantic_regression.cpp": "99dba074c0c0a32ea76026e7d54fc60af8e6d3dc5315c8900c470b4518878f39",
+    "tests/unit/cpp/reservoir.cpp": "c3eacaf0271400eb45ad559b571a8f7faa2a809d5f1857ffeb5592addce2cd0c",
+    "tests/unit/cpp/collision_regression.cpp": "f17acdff74ab82a62dc5402b42e3f6a149c262e89b140494164d6ebd630f5e14",
+    "tests/unit/cpp/slot_profile.cpp": "31ac58ccab175bf79fa59fc46d4c0842df18ab0a5e5916be84760d9da2b75788",
+    "tests/unit/cpp/planar_velocity.cpp": "8dea266984edc69d4e0e68007e038d7a587e99f84e33478d6656a66a56680933",
+    "tests/integration/test_body_sync_e2e.py": "d29f01771f3512a4b3ad06fae4ee952327d7fd9f0476942402fe92e9e327fcec",
+    "tests/integration/test_sync_bodies_skeleton.py": "65f55a0980659b49ae0027f0642a27e2ebaead226ef083f233e878150884b07c",
+    "tests/integration/test_numerical_gpu.py": "002a6745929bd5ee86a9491ea9bc3f97602fb825ea17262ea190c9311881100e",
+    "tests/integration/test_ddf_patch.py": "dda2abba32ca13e17098232f2831a0b1b66439c35f8931d9997a0257250c1281",
+    "tests/integration/_cases.py": "ab76ca1096d2d10fb05b3539aa8ed3c7e549619bae6900ac98723f6c3c908f2d",
+    "tests/integration/__init__.py": "c354e43ba09b55a8013a2df2069438740b5f48b5917d855e52e33ab5d7da5a6c",
+    "tests/integration/test_state_gpu.py": "dde0948941e8abbc5ea10a3acb3a35abbaea576f36ecee0f1120fbcf7454d60b",
+    "tests/integration/test_runtime_contracts_gpu.py": "775e578e2e8072af32fc740b2698abbb79454235a0f3ee929ac4c75d747f8db5",
+    "tests/integration/test_unified_obs.py": "4a681536099741d92bdc258525fe3374cbdbeba0d49996e53808381a1b6a13fa",
+    "tests/output/exp_ctrl_matrix_streak_ny300/summary_C4_deceit_f1p5.json": "11dab8440d8c4f385061d2536403f4313c6f026b4e0b7672681327a9f4f37ebb",
+    "tests/output/exp_ctrl_matrix_streak_ny300/summary_C6_deceit_f2.json": "e0c4e8bcc55da5dc8de1e2fe88029aa3e67453734faa44451f5a6dfa9131557f",
+    "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C6_deceit_f2.png": "e0a66708ce2a29c4c6b854d2596b3ffca181dc6e35d99cc94e08af3e2d8c024e",
+    "tests/output/exp_ctrl_matrix_streak_ny300/summary_C3_deceit_multi.json": "24c8e433aab6d207dab67546c4079868c4244c2948c32c94cd08e4f331991807",
+    "tests/output/exp_ctrl_matrix_streak_ny300/summary_C0_no_ctrl.json": "cf3af733a08f081cc5f879e8da79d7c60104099f4452af5b2a4a96c0e6bd5889",
+    "tests/output/exp_ctrl_matrix_streak_ny300/summary_C5_deceit_multi_f1p5.json": "a4cb4ff4481b39b9ee61b1d7209416237a7fe86b22c5068d713ccec9c3f7afe4",
+    "tests/output/exp_ctrl_matrix_streak_ny300/manifest.json": "d8a20dacc92321d98354684976f771a9ca8989fc63ddcd78e15c7768c6617671",
+    "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C3_deceit_multi.png": "c6fed617cc6ffe6677157a9b58811d5f4613725eb98a5aec830fd07dc1aac38e",
+    "tests/output/exp_ctrl_matrix_streak_ny300/summary_C2_deceit.json": "7526a6b20a158461b85b1a64070b46c2b21be1e01c5ee025e6746fcf47ea3397",
+    "tests/output/exp_ctrl_matrix_streak_ny300/summary_C1_stealth.json": "63d34a0ab33e9fa8fe7311363efbd1b2875691f5b4958bb645b8c7ac38f1ad6b",
+    "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C0_no_ctrl.png": "0cfd7ce8f9d743bf22a7a694b4e5a3616557cb8f1db2f4ddf49cc4bef96efef2",
+    "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C4_deceit_f1p5.png": "4dcfc186928dcb83d28e9eb4cb2ecb4b163eb6f121d57036b4c05ab162be0951",
+    "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C1_stealth.png": "5e3cbbefda06fcef243d7d06d74a473972350cfa4ae88bdfdb349dce13943151",
+    "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C2_deceit.png": "22f1db77499bdbd1b3cd35f5b58b1a884dd94a86fdcfef07abd4157e6aaf8d19",
+    "tests/output/exp_ctrl_matrix_streak_ny300/streakline_C5_deceit_multi_f1p5.png": "823e475cc901af3d6f4d0c56eb07822b3e73a2b9d0aa23e20e3741023fe90092",
+    "tests/output/kan99b_validation_esopull/summary_runs.json": "fe3294a953580204319fb1143434e15096d8455b6073100dfe0d5491b76af394",
+    "tests/output/kan99b_validation_esopull/summary_runs.csv": "1a44bb27ee0a7fe0270905248c37364834248cdc8710bd68142a6a79bbdad82b",
+    "tests/output/kan99b_validation_esopull/force_csv/k2_k2_inlet_control_domM_re100_a1p000_zou_he_local_mrt.csv": "9fbc7d507c129ed85c68a9a313e3eb3431470d091bd7723e63f8afd8a3d2b737",
+    "tests/output/kan99b_validation_esopull/force_csv/k2_baseline_domM_re100_a1p000_regularized_mrt.csv": "8faac43f42d6e0c70085c6e616bfff4df8de897e315fc0d2b4aa8bd635c3fa05",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C4_deceit_f1p5.json": "b613ae55fcfbd45a1a922d6d529e5274ba9d2987fdf5620fe866b889b931e48c",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C6_deceit_f2.json": "dbf54f9a183072547b22fa14334f0167e6eefb21c1208c4e8584bc196545a399",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C3_deceit_multi.json": "2100c6cc5c358a249804ce8f6f98531f3bc868e27af6d21a9d441b1b6a9e479e",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C0_no_ctrl.json": "a8b4697b7c0caeb958f80e282e32d673deac8c914008d64e6b38f7883eacc57e",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/state_C6_deceit_f2.h5": "8d0c28566d2230b422691b738cc453705496bd150be038a576c0c0fba218fc1f",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/state_C5_deceit_multi_f1p5.h5": "608767ca11d104fa4506b57204a0c8dbd739688224ebd924fe517ce9e21db823",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/state_C1_stealth.h5": "a83c988cc8b1173a7b2f13b132ed7243e98304dccab2965aa16cf4d32f8df007",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C5_deceit_multi_f1p5.json": "6f6b9300782178e0ac9308a677bd9cb1565a383a78dff4cd52dea0bd464db31d",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C6_deceit_f2.png": "21bbe2dac1ab06ca1b172ec62d00daa7bcd65d99adac0ed03c5e30bed59e871a",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C5_deceit_multi_f1p5.png": "602a6586277699968b4cb167b134c8c406577038af088aa70baff682691398c4",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C1_stealth.png": "c1e1d04f266deac5fb2815a8283da80f9139ffaccbec2219d98544296bf3152c",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C4_deceit_f1p5.png": "96dee924e89b90091192a8d7b43321f109a5491511b8a83da77cfc611ae0d93b",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/state_C2_deceit.h5": "aa5800a0cd594eeb7cf5449d6469d55e0c9033ced0ee0a3b5d59152e68c7e263",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/manifest.json": "5d28f0f5428d7f0341e20d5d1f19c17bbc6f0f9b2a441d3c95f5422f3f2b4bd4",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C2_deceit.png": "1dcb6fb959f944d7ad89c4abaaef4d1fd4a77db8901804530e86fb336b883eb5",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C2_deceit.json": "b88ff5049aef59876b349d105f1c3467c17c9ba9022a48a77a6984f20da34345",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/summary_C1_stealth.json": "515689cbfaa30a9e39d9907939ee194a4836b644a5e9124586e6b7221d2b394b",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C3_deceit_multi.png": "d69694a1a1b2f2ea0adc7b74b7526504e2ad0b5d6317bac9b3159b2e7e88cf90",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/state_C0_no_ctrl.h5": "3a858d6be0a946e1d26bbfa192c2f0ca3910c0f140b42575ec9d9529dd99155a",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/state_C4_deceit_f1p5.h5": "660e4619ea530dcd18c3afb2e7fa22cafd9cdba1be7888e31ab5b76a0902d2fc",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/vorticity_C0_no_ctrl.png": "6d4d3934f1c8b20c2a5c742ae080a7143f0c139741966adf009a227c27e9bb1f",
+    "tests/output/exp_ctrl_matrix_vort_nx1500/state_C3_deceit_multi.h5": "1e72126f11b2995437cecb8cc0eeffb8807efbfa43d8f346f28711fea98ddc90",
+    "tests/output/kan99b_validation_ref/summary_runs.json": "449316c30585a8de9997538dead5d4e35a59bf00a2ac22d01b101ab600a4bc06",
+    "tests/output/kan99b_validation_ref/summary_runs.csv": "e8b9620f3772e5e421026103e456e6e844a91292f40affb96174c9dbde9b6e4e",
+    "tests/output/kan99b_validation_ref/force_csv/k2_k2_inlet_control_domM_re100_a1p000_zou_he_local_mrt.csv": "4391f41d17ebeea1092f13b901923ced4ee2a1c5b346b79ef791d692847286b5",
+    "tests/output/kan99b_validation_ref/force_csv/k2_baseline_domM_re100_a1p000_regularized_mrt.csv": "105c6eb21f1943d9d935246eab1602ff2016c415a139e24fee2793e88e006ead",
+    "tests/output/exp_ctrl_matrix_vort_ny300/summary_C4_deceit_f1p5.json": "0085a679a423621003eea81d4ac83bfe2edef2879eed7809d2a3675a212f791a",
+    "tests/output/exp_ctrl_matrix_vort_ny300/summary_C6_deceit_f2.json": "e820cf73f0e90bf93c34b24416e7692a6c2e51352ccf490fa6714d0812331ca2",
+    "tests/output/exp_ctrl_matrix_vort_ny300/summary_C3_deceit_multi.json": "571370c74ad9af589f3dc214669bff3d857efe6fc4fa13815b5d793d12b53770",
+    "tests/output/exp_ctrl_matrix_vort_ny300/summary_C0_no_ctrl.json": "ec5b89961033d8ebe0d66ce1ec7940dc2faf98130c38319bc9984ef654e60b50",
+    "tests/output/exp_ctrl_matrix_vort_ny300/state_C6_deceit_f2.h5": "2792be74d8564fa29fd0636fc8493630fba2779c165b44330197095b3e296b18",
+    "tests/output/exp_ctrl_matrix_vort_ny300/state_C5_deceit_multi_f1p5.h5": "2c64ee6c7a4ea2c42ed8f3d274402bec62de0e02ea0340e16022f0cdc92af724",
+    "tests/output/exp_ctrl_matrix_vort_ny300/state_C1_stealth.h5": "100727d94fe6c2e46d7807eed0442555bdd1e26ec9b04b4c457171a2bbba3255",
+    "tests/output/exp_ctrl_matrix_vort_ny300/summary_C5_deceit_multi_f1p5.json": "f86166f121b4eeb6d74d8176c9265e7a3ccfe2540d040f554b6f96e6a6222c16",
+    "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C6_deceit_f2.png": "fef4de0e3ac8203742f35c16a02445b19c3f556b11f73abd5d8e3ca05ca33d78",
+    "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C5_deceit_multi_f1p5.png": "9136448e6d7565ca5af3666f9cf6e154342d8a3475076abfdbdd1ff9faec34f3",
+    "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C1_stealth.png": "544537a9c500a05937fd3be17c25e7d887461d9b83a15564f9ab7063208f40f6",
+    "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C4_deceit_f1p5.png": "51e7056db99dd653affbe913d52fa41df6ec0db921109384e3c679bda06b5a83",
+    "tests/output/exp_ctrl_matrix_vort_ny300/state_C2_deceit.h5": "39d6c162085acae1612650da37d2314757715931e83a854e08bb01407d0f8efc",
+    "tests/output/exp_ctrl_matrix_vort_ny300/manifest.json": "05fbc2e7bbad4267a38e1094bbdd6bee6ad270412bdb5e92b0dfc9fa56969517",
+    "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C2_deceit.png": "07fc5817eba30371272b87ee2e023c0a1144077d1bef77efb2fd5dc284badcb7",
+    "tests/output/exp_ctrl_matrix_vort_ny300/summary_C2_deceit.json": "b1fcf76039c91a9080b830352dee2e95316d754b968cc27a8f68c51527661e76",
+    "tests/output/exp_ctrl_matrix_vort_ny300/summary_C1_stealth.json": "b78851637b9b7b93070524a2933cae1dab6d682f8894579b2849c64921e6c29e",
+    "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C3_deceit_multi.png": "2658f0747ed7287f7912fe15cc58a086e01ba284277cb98689bac01ecb6ec12b",
+    "tests/output/exp_ctrl_matrix_vort_ny300/state_C0_no_ctrl.h5": "57f73f5f8dc4b32b156bc82300b1efd1e4eddadd9b8dc51cb7e6b41fa5c966bd",
+    "tests/output/exp_ctrl_matrix_vort_ny300/state_C4_deceit_f1p5.h5": "2864b9dd086709ee8b8c3f262118a5130b0d40c86838f3ca0deab5bb898dafa8",
+    "tests/output/exp_ctrl_matrix_vort_ny300/vorticity_C0_no_ctrl.png": "2c7f3a8be2ee540afdfb66299e43a65583434bee84bde590124524a82868c900",
+    "tests/output/exp_ctrl_matrix_vort_ny300/state_C3_deceit_multi.h5": "39e0d9b032dfff8cf057b410a98973729285e7d03e89f9a6a002aaf7de3d7519",
+    "tests/output/stealth_sweep_fix_check/summary_stealth_s150_w0.02709.json": "8b1032e13975bb05c6a810fde175c8da51bacdb3dc745fd11c1049ca63bbf136",
+    "tests/output/stealth_sweep_fix_check/summary_stealth_s050_w0.00903.json": "fa7da24d5dab9fd3a3c2dea6b50d0224c7a99cd9141796e137304a6040b1ac8a",
+    "tests/output/stealth_sweep_fix_check/streakline_stealth_s050_w0.00903.png": "640928f7eb159e7caea32036123f86c281723d083cca46839ba86bce8361ada7",
+    "tests/output/stealth_sweep_fix_check/state_stealth_s050_w0.00903.h5": "187ac365f9f7370c888c4c65570c47e42465b2fccd432056c176528d45cf0c2f",
+    "tests/output/stealth_sweep_fix_check/manifest.json": "83a3f12a942fb644e470bd07a72f24921f2147d7df429110268c5c96a9953d1a",
+    "tests/output/stealth_sweep_fix_check/state_stealth_s150_w0.02709.h5": "e057e9db26b2546c0704e2c959cc7d2aac91e6a49b4c7ee75a409597a5db8716",
+    "tests/output/stealth_sweep_fix_check/vorticity_stealth_s150_w0.02709.png": "d2d202088624cf30868228f9c913ee30e1b386aaa2c22b0ea89be43dedc0712d",
+    "tests/output/stealth_sweep_fix_check/streakline_stealth_s150_w0.02709.png": "0edc7caa9caaffb754490bf1f6ac7ad7180e45a991439a3f4f83ed949a082a1a",
+    "tests/output/stealth_sweep_fix_check/vorticity_stealth_s050_w0.00903.png": "4088359b17c46ed4d7c8401d244808fe67723273b1d16d0671b69f9478c68c1a",
+    "tests/output/final_validation_round/validation_summary_report.md": "881cb7052e5a555afc87168a37268ee66e8e3fba172533706e858d996fabc7b9",
+    "tests/output/final_validation_round/sah04_mixed/s2_d48.json": "83c6c01201d90aae5c49e73ebeca88d1c7ded6cc83c13f4892a9188e6289483f",
+    "tests/output/final_validation_round/sah04_mixed/s4_reg_d96.json": "b32f03e6b347fc709cea2ecd488df0f85849c733bf6a4b9cf65ea69401c93a1d",
+    "tests/output/final_validation_round/sah04_mixed/s1_d48.json": "120e8e878f5712dc89b7cf78c7f8d0e3368d34ad5ef7494977e083b188a54c18",
+    "tests/output/final_validation_round/sah04_mixed/s3_stablecfg.json": "b38a3d197a188e65c163d974113af18f332b3abed083e2654e998d9980f6be9f",
+    "tests/output/final_validation_round/sah04_mixed/vorticity/s3_mrt_laststep.png": "dc96fcd05d458684cfb40d4cb741172213083e2f2665e2bae7e1f0267bb3575d",
+    "tests/output/final_validation_round/sah04_mixed/vorticity/s1_mrt_laststep.png": "73a3580ba3c7fe6ffeee4676a9a51b5bf678d6fb523456a61e185598389ea1e1",
+    "tests/output/final_validation_round/sah04_mixed/vorticity/s4_mrt_laststep.png": "57f2a82761f2de1a9fc2b78ee86159ca542c966494b9c704deb451da857da778",
+    "tests/output/final_validation_round/sah04_mixed/vorticity/s2_mrt_laststep.png": "786f492b96ed932254b5452e2d06ff088727f2d88c7e7c7b47d386eddfe07862",
+    "tests/output/final_validation_round/kan99b/full_summary_runs.json": "8c4a11cbf555e08a66698439170b850c57d537d8e75e4dd75beb767bbf7e38cf",
+    "tests/output/final_validation_round/kan99b/summary_runs.csv": "3fa92fdd3114f0472de44bc03006af1d4b694dfc69b06704c1667cd3627b6dab",
+    "tests/output/final_validation_round/kan99b/force_csv/k5_baseline_domM_re160_a2p000_regularized_mrt.csv": "de05e9699146f2adffc9d7c9991f9e48396aacd142afc3c08b2b64727c83c69a",
+    "tests/output/final_validation_round/kan99b/force_csv/k3_baseline_domM_re60_a1p600_regularized_mrt.csv": "53cd0dc47328b7b370eced1130508655e6815a29b727bf1fe4e4e125e4918905",
+    "tests/output/final_validation_round/kan99b/force_csv/k2_k2_inlet_control_domM_re100_a1p000_zou_he_local_mrt.csv": "4cac1ccfdb7451de3e26d921a6406cc55d1d4630e10ec0d7ec9350a4abd49404",
+    "tests/output/final_validation_round/kan99b/force_csv/k4_baseline_domM_re100_a2p000_regularized_mrt.csv": "392c98de52011ddb344a5761c4520e870f4e49bbba3e144e5a02818ba2f9250b",
+    "tests/output/final_validation_round/kan99b/force_csv/k1_baseline_domM_re100_a0p500_regularized_mrt.csv": "9e83c5175aec644c0b97c081e610deefa731b87aef04da6297abf662a71c0702",
+    "tests/output/final_validation_round/kan99b/force_csv/k2_baseline_domM_re100_a1p000_regularized_mrt.csv": "55b071f278e153aa353aa2bef85f0bce35b910a7b08103032023fe3a28169b89",
+    "tests/output/final_validation_round/kan99b/vorticity/k2_k2_inlet_control_domM_re100_a1p000_zou_he_local_mrt.png": "b91b332e7deb787975d3f08fa3325facd4a972b536694fcda52e6c01943c42cb",
+    "tests/output/final_validation_round/kan99b/vorticity/k1_baseline_domM_re100_a0p500_regularized_mrt.png": "6e7c3f6567c0ff0d00d75da8373031f5ba2a17a624cb8c5d5d6ae4f8749c33c0",
+    "tests/output/final_validation_round/kan99b/vorticity/k5_baseline_domM_re160_a2p000_regularized_mrt.png": "c4d232df2e6f7466acca711191d976aa9411ec0ade81572b531463f42a7d633a",
+    "tests/output/final_validation_round/kan99b/vorticity/k3_baseline_domM_re60_a1p600_regularized_mrt.png": "b2314c60491d20933422e1697998555dec2436d39545c71f990e9906884685b2",
+    "tests/output/final_validation_round/kan99b/vorticity/k2_baseline_domM_re100_a1p000_regularized_mrt.png": "2b2797b8f53170d04d1a70d1cdf898f7e41b3a76b9f3c1f276dfec952520ab04",
+    "tests/output/final_validation_round/kan99b/vorticity/k4_baseline_domM_re100_a2p000_regularized_mrt.png": "8135f470404fe11ac97968fa580ee35232e90dcace3c6ad94de17ef7aace24d6",
+    "tests/output/kan99b_validation/summary_runs.json": "d7239aac64884202558741074f2d644ade9e2365d94d0b7556fba68dac94868d",
+    "tests/output/kan99b_validation/summary_runs.csv": "c44da69563d58b917291a9fd402d1f57055861bffab6f9e32d7db91297428d45",
+    "tests/output/kan99b_validation/force_csv/k5_baseline_domM_re160_a2p000_regularized_mrt.csv": "27b64460923d235d34b760f2a2371ad01611a70e38edb03d6fd6a2fe7a7de6e0",
+    "tests/output/kan99b_validation/force_csv/k3_baseline_domM_re60_a1p600_regularized_mrt.csv": "76ff52f4494b7ef7650c05968732a8caaba94d2b151234c02cf624f5b3a712ab",
+    "tests/output/kan99b_validation/force_csv/k2_k2_inlet_control_domM_re100_a1p000_zou_he_local_mrt.csv": "28a83436ca8bdad38865ba21ce1bda679562a5ae1cfc6ee8fc6e86ff760ec66d",
+    "tests/output/kan99b_validation/force_csv/k4_baseline_domM_re100_a2p000_regularized_mrt.csv": "823ae04870fd951879024a18169ac5cba8db4b3201726f6a00f320f1958d04c6",
+    "tests/output/kan99b_validation/force_csv/k1_baseline_domM_re100_a0p500_regularized_mrt.csv": "a591daf2cdecd6ac3689fa2a2aba917b23053ad26e3ef1f635c81aecc451475f",
+    "tests/output/kan99b_validation/force_csv/k0_baseline_domM_re100_a0p000_regularized_mrt.csv": "e95c27c646c0c9baf8f455f876c115c8dbdb23cef9d9d550f455098bf0c03b55",
+    "tests/output/kan99b_validation/force_csv/k2_baseline_domM_re100_a1p000_regularized_mrt.csv": "3c2ea79a0e27f561215febee2e165d24b3617a648bf908981c068ba59d549c51",
+    "tests/output/stealth_steady_sweep_nx1500/streakline_stealth_s125_w0.02257.png": "a892f18c74fe13efd839bfd5068097ca0ae07acebf6c06eed89e1b867e41fcb2",
+    "tests/output/stealth_steady_sweep_nx1500/summary_stealth_s125_w0.02257.json": "7e542f59746429022ce1794854c6fb36e8ac658dd0aea3bc1140a45e83a3f1c9",
+    "tests/output/stealth_steady_sweep_nx1500/summary_stealth_s100_w0.01806.json": "b76216e0fbee00ef754edbafe5790a99ce7d53638af629947ddd9615598e4c08",
+    "tests/output/stealth_steady_sweep_nx1500/summary_stealth_s150_w0.02709.json": "42cb241d9cfb01308ce28e129756b6cb3fe2a8e9679518da84bcb8b607fe92ac",
+    "tests/output/stealth_steady_sweep_nx1500/state_stealth_s075_w0.01354.h5": "558be308dbf334832bc1d29419ba5be142969117a11b124864f6b221c8fee509",
+    "tests/output/stealth_steady_sweep_nx1500/summary_stealth_s050_w0.00903.json": "53b579811a0b651ba7cc466c230c115b9f88486c6675e0465d0715d3377a75cd",
+    "tests/output/stealth_steady_sweep_nx1500/streakline_stealth_s075_w0.01354.png": "9f4a7d89b2471becaf31e84c14402441c5fd96fc7190cea5e8a9fdd06ee62002",
+    "tests/output/stealth_steady_sweep_nx1500/streakline_stealth_s050_w0.00903.png": "5f18f56b0ff2af3350216b65540a2bc664c569520624cfc6cc2439a3c5369560",
+    "tests/output/stealth_steady_sweep_nx1500/state_stealth_s100_w0.01806.h5": "30776f333959e0e9eb5ca96b269e6a8052c5b94941a4e3b36d8a6af8076920ce",
+    "tests/output/stealth_steady_sweep_nx1500/vorticity_stealth_s075_w0.01354.png": "b5393474d99191e88dafea4144b6a8eccfbdf75107125ce4b05383b17007d06a",
+    "tests/output/stealth_steady_sweep_nx1500/state_stealth_s125_w0.02257.h5": "4ed9d8587f75ad4625ec5501fa99fb733cde037180ac53f92a210ffbb08375de",
+    "tests/output/stealth_steady_sweep_nx1500/summary_stealth_s075_w0.01354.json": "ff1c1cc649e589b5425787493c2b0d04b6c39b43043b1968d65509cb0a426e82",
+    "tests/output/stealth_steady_sweep_nx1500/state_stealth_s050_w0.00903.h5": "4de51584b24095f8cf4480b8941593a5f913332f9396061ed077c9d49eb2ee11",
+    "tests/output/stealth_steady_sweep_nx1500/manifest.json": "0dfbb2c1b5bf9093fef169e4dc6319edb5c87a1e967e8d558613e2c64a2ca734",
+    "tests/output/stealth_steady_sweep_nx1500/vorticity_stealth_s100_w0.01806.png": "60824cbdf21170cb4ffd8af0a49e8522c2d79cb2694690ab67995ee973265efa",
+    "tests/output/stealth_steady_sweep_nx1500/state_stealth_s150_w0.02709.h5": "b22d54a05cbd3138a1fe585a825246989fcff7c00f51aa9312a4185d963db933",
+    "tests/output/stealth_steady_sweep_nx1500/vorticity_stealth_s125_w0.02257.png": "c1e1d04f266deac5fb2815a8283da80f9139ffaccbec2219d98544296bf3152c",
+    "tests/output/stealth_steady_sweep_nx1500/vorticity_stealth_s150_w0.02709.png": "bcf098083a73798dc3906807218058cc571435a010234a5a350b585ba9915c78",
+    "tests/output/stealth_steady_sweep_nx1500/streakline_stealth_s150_w0.02709.png": "3bac21cc75a01429399cec308d6bf5fc8918917def1bf5d7fec1cb6003390a41",
+    "tests/output/stealth_steady_sweep_nx1500/vorticity_stealth_s050_w0.00903.png": "a675f41df763f0a1ac0a06386315806b24f2571f5dabc8693fcd871a13ed22ba",
+    "tests/output/stealth_steady_sweep_nx1500/streakline_stealth_s100_w0.01806.png": "92515588596596cc1d691c643fa48cf828492c2eaed96355dcec58109de4b5aa",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C4_deceit_f1p5.json": "0393661f08b748428fc366eeecec3b34b9d9a013aa6b151a15b33c7e3c0e1818",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C5_deceit_multi_f1p5_step080000.png": "bffef412087e426b614d8c05e59bd7580ee49bb77319279ddc4c1bf825678c49",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C6_deceit_f2.json": "de067f01ef5c11249d67bbe5e02db6f2b4c5590214de02609bca115edf8dee64",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C6_deceit_f2.png": "846badbae81b75f765d89e5a7c4f88aeb5d57f2387511e4f2f84c72a192ea9f2",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C3_deceit_multi.json": "eb21d1c69e51f01c1a6be1ce59fe86763089ea5aa667b8872d0186af035b24b2",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C0_no_ctrl.json": "780a0d329cb86990a17a088f49084410abb1fad24f659255918e5ddda6b3dabd",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C3_deceit_multi_step080000.png": "ff7836b8229d9a5dd3900f499fe3e7f0c73a61c7109b6e6e79b11a0fb459bb63",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C0_no_ctrl_step040000.png": "f2b56a7e30bcc363ed69fc19705403181ac5de90800eef03039a389a65869e30",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C5_deceit_multi_f1p5.json": "261b698723f19526a447679a2be8666c8d0cbf6df81b0c9de6d051960d77308b",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C0_no_ctrl_step060000.png": "0697e0ae06a01154afdcf00330ba870bd8f36d21561a33846ad7ba63fb731179",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C1_stealth_step040000.png": "1de3d7f54e91c5d5850f4358d1872e16fefb36d32a1b6293facb54524e32315c",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C0_no_ctrl_step100000.png": "91f0bf6ed3e854f7f83623a3f19bb12c83b4aac239e3eaa849fbe50e7baddff5",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C0_no_ctrl_step080000.png": "303c1d2d4c49b4a7495365c8cb2bcbfe9bdda7cbc0a7c7dd1f01e8aa62b3573b",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C5_deceit_multi_f1p5_step040000.png": "dd5945458a35d81b31a0e2f3a693a5023d6960474263e7dc86c22367a56cc13c",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/manifest.json": "0d97efed02f775c25dd8a2d7439f310b715d142ff8d603c9da6ddab197570ce8",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C3_deceit_multi.png": "69022ef9175acf910374ec73848640548b85fc7beb7e6950843f52c10ed7d61b",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C4_deceit_f1p5_step060000.png": "16ba30b8cca0d49e6b76be0bb4f0d14bbf276ca6ec47ebf56907c7534e15c4e0",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C5_deceit_multi_f1p5_step100000.png": "8548b6dff635cf9c92e2baa119866277e3994366eb31aeb30641b03b3d80ee9f",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C2_deceit_step060000.png": "56100f169c3e378b84bfc89c5477d2c142ca043d9f28eaa70bc5448c49c7f4d5",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C2_deceit.json": "587cd42d81b1325bbc766d9ca6c1fd3d076bf5a772efd45d056c2c4e3db742b6",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C1_stealth_step060000.png": "e43e95e7126de8cb857154353f161914c225f8c9f17eb44b1ff744249368a4d5",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C6_deceit_f2_step080000.png": "676d21ffc7180d34a6725a8bf49503ce59f48d65500450c3975d01e65162899e",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/summary_C1_stealth.json": "73040aeb7ef07c538d4687b101c599210e660202eb1c2c3e0894dfbde682d137",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C4_deceit_f1p5_step100000.png": "e22171ef86979c4398c45ada9cd0f5e4c4e5b034f271df5fa8ac9a762a8554cd",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C2_deceit_step100000.png": "0d73042be73b0de8d0a591e56c01e3c802483aa22a97f27e0300cba82c708066",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C4_deceit_f1p5_step040000.png": "a6e95fd5c24052db20d5ece200edcfe5e261c00950ca964c89df9f7335579634",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C0_no_ctrl.png": "d74061347ac3505fad878e330f6cb04d23bdb13082bfa1afa2fda0872f80f388",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C4_deceit_f1p5.png": "3156400eb59fae0638556c2711345f12ca49d951ff09e6464a2271249409a6a7",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C1_stealth_step100000.png": "d69e34c82da98b28eef7f1af29f5d11f400e90f628049f6f5f4a3a419a4a4340",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C6_deceit_f2_step040000.png": "ce1f372b517dd52fc3f3eb066145e04ab6841e43b67cb0f6bfbdb42a6738eca6",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C3_deceit_multi_step100000.png": "07cce6c99dfa7b56dd4d3aa452873a676a5a00e9f046555fa9dda30f16dde488",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C1_stealth.png": "a892f18c74fe13efd839bfd5068097ca0ae07acebf6c06eed89e1b867e41fcb2",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C6_deceit_f2_step060000.png": "80b63bd309ef11a3ebb2f1ef301b49cd8f09bcc25562097d382f859306c9fe6d",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C2_deceit.png": "1edb30dc35e29ad991695353f4b84e0507792935ec75ae9a7904ebdc007a471a",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C5_deceit_multi_f1p5_step060000.png": "93ab8e09e58a64c5dd2eedfdafd27cf4dcfe4e8fae1af64ac71eac509e6ffdaf",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C3_deceit_multi_step060000.png": "f773bdef1c8d718d01b6d6d7735182c04564dd8b5692b359e1dd2f721c774b1a",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C4_deceit_f1p5_step080000.png": "5570fe6a25c92e5c6aa9a5129aa1797ba8ee7418170c7a351f9e35b931a366c7",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C1_stealth_step080000.png": "32d3e700286eb4b46b3bcf757669481affd6ff6b53792d730b5a21da92cc57d6",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C6_deceit_f2_step100000.png": "5acfe36694bb4e628309ff8ae1e839ca0a1f684607165bbc2883436b85208bf4",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C2_deceit_step040000.png": "2c6f2b8d61cc2aaa63631eb6c98d3de26dcef705fa6b66c823ce7b9eef50e00c",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C5_deceit_multi_f1p5.png": "adbefd0021e2c981d026718de8c63594b9c8e5971901d1dc40835cb69d95b93e",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C2_deceit_step080000.png": "ce8b18e4dd976ed590fcc44075f3fb058ca7b23e15a1624726c181c4dd0c11da",
+    "tests/output/exp_ctrl_matrix_streak_nx1500/streakline_C3_deceit_multi_step040000.png": "168d21ef24ae198fbfd642f8ca315faad4c7bff2e2c09e16ff7c97e7360ea883",
+    "tests/output/screening/screening_summary.csv": "3a23c4f2bd54ed5ee9bdb5b6dcdc58eed04519fcf1b4790e0abd1e6c5288fb96",
+    "tests/output/screening/screening_summary.json": "caf64530f152b6b8ccec82a3c7ba44fa0b3aeb0e0221ef6121857bf62c031ecd",
+    "tests/output/screening/B1/force_hist.csv": "854bfebe63fb2d140823fc5dbc434a70c317c6ab0bedbd5220cec45665b524c8",
+    "tests/output/screening/B1/summary.json": "35b4d958bc0fdd6ab6c9c0d1ed50e85d89b04f7be3e34632d6c3ea95b89acb47",
+    "tests/output/screening/custom/force_hist.csv": "06da0f67b564d5c114332ef3b39167b1ba222fc50045f95303c75c14755b51d5",
+    "tests/output/screening/custom/summary.json": "1701ed75e5e9ca16127f495ccff1d87de245d81df581e94114c8fca6fbbe77fd",
+    "tests/output/screening/MR1/force_hist.csv": "f70fbfa748fd0709e225523aaaa72b761db56df4f1d48f105384b94cbc44b31f",
+    "tests/output/screening/MR1/summary.json": "3d9a0fc19710820e3634ab2143b913b282beb159336567ab9ebf3de2092947bd",
+    "tests/output/screening/MR2/force_hist.csv": "c947b3c16b8e8f8f85a203cea8cd912bdfc07f96985c1c24a470b644170195ea",
+    "tests/output/screening/MR2/summary.json": "d2344e9e2517ec76c8b56bfbe3763dd465e24721856992401c57c414763481bb",
+    "tests/output/screening/MR3/force_hist.csv": "7df1536c83ee466b7195d9c521d3d3b1309acaf142f2855bba51fb279c7612e4",
+    "tests/output/screening/MR3/summary.json": "ad188eb1b271a6cd0fb4025b456eccac5450776f60db58466f804fc5a0e0ec61",
+    "tests/postproc/run_exp_ctrl_matrix_vorticity.py": "b7e0c4113111b9b677f321750c0055656ccfa4f45c25fe7846f3ed22f30d1467",
+    "tests/postproc/vorticity_triangle_clean.png": "f831b8143b50f038d5920a0658469622655f34176d30cf7216feff108aa2ecaf",
+    "tests/postproc/run_kan99b_streakline.py": "a2bbf3fc629ea170d2d4879317dbf2b81c43378a328100ac1f2ee8d9895666cb",
+    "tests/postproc/streakline_triangle_clean.png": "aa6669de7af6f82e98af25698a15f494e9cea20cb911ad9a30fe52597d33bb79",
+    "tests/postproc/experiment.ipynb": "c6b45db1c57200f0777213ef8d44cb4996c1aa7a5fb42b968b77e56f51b4fca4",
+    "tests/postproc/run_stealth_steady_sweep.py": "3c32c4dede7da77fd6cfbd3f7b1ff43bb11390aaba621883ec96c6c7fdad5af7",
+    "tests/postproc/run_exp_ctrl_matrix_streakline.py": "529d5f31a3862080f890c65177502b589710b2d960ddf131abaf7dc2f9e2a96f",
+    "tests/screening/run_config_sweep.py": "5030c99923815ed6ad39110cb56f748c579ff4c66c7c1a368ad1a6008017e2ff",
+    "examples/fixed_periodic_patch.py": "6732e440a47c237ea341703f2d80717903d34c68fd061bdc97189e5d877be46c",
+    "research/j3-lag-2026-10-12/host-check.log": "b2b6d262934b3abf9e0f0bdbde14b339cb977f7bffe391c17b51b5d067862dda",
+    "research/j3-lag-2026-10-12/REVIEW.md": "f388b64b0cc0413dc9865afda90ed24de666dda0d6cdb821b4363ce1b73631b3",
+    "research/j3-lag-2026-10-12/trajectory.h5": "2b51f8ec5e0cc8ca72c73ac1b51dd611158368e6d6de791d85150fa111ea1986",
+    "research/j3-lag-2026-10-12/baseline-status.txt": "e0b69879084f54afac1a3bc3701f1de9819068190c815ae84421f02f83cad9f7",
+    "research/j3-lag-2026-10-12/baseline.json": "5e9a920813fe3d775110af85af92970d5245a7040ace804445e432353b77e489",
+    "research/j3-lag-2026-10-12/gpu-diagnostic.log": "97956b517072b7c34e2e29e2a23f87eafb19b9eda786a4b8149e4a2eaed76ee9",
+    "research/j3-lag-2026-10-12/gpu-availability.log": "b227a519b8286849cfdf842573bd451803da048c6b27af9517f6b8964cd3aa39",
+    "research/j3-lag-2026-10-12/results.json": "00435ac7e402943e55e702fac1beb5af8cafe71967999658bcde2b29077b1fa8",
+    "research/j3-lag-2026-10-12/incremental.diff": "ebdf66c72daf17b926482f79a1a30bf0eb2d27fc930a7bb62e5449ebcf72fcc7",
+    "research/j3-lag-2026-10-12/end-21280.h5": "19a94e9e8db6dd9ac981effe06032c351992250b58768d9c090409193893d588",
+    "research/j3-lag-2026-10-12/start-20760.h5": "6c4cba5928c77566c2afc32231311a3986831c18fea766faadebb101243399e2",
+    "research/refinement_slot_20261013/incremental.patch": "2daca4c9751190df27e18ea79e46685a8fe3cbb6d42b34135b1219b8f53ea3fc",
+    "research/refinement_slot_20261013/baseline.json": "17b1a8cb7e8232979cd1fc9976cb6b78aa58a7005449526ec15cc0bfd45f8139",
+    "research/refinement_slot_20261013/manifest.json": "9f28f275533e8a1a761ec748152170b40845612058236ce331c47ae6c5d68713",
+    "research/refinement_slot_20261013/before.json": "482b02da26207ce32deb9368b6eb63f9de7b4ab670078c02f458f512fb182b53",
+    "research/refinement_slot_20261013/notes.txt": "8c70efe2acef9f179c453d297b27047b7632a2d55e0739fff4bccf74e0867511",
+    "research/refinement_slot_20261013/stdout.txt": "1cabbc8a87a2a237ffa649feac0b1b8e0ae8d769af8c298e600e249d2a525f58",
+    "research/refinement_slot_20261013/results.json": "6245de38106d7a7b0bfea0aa5100b9c9e393ab5436fc594ce0295b4526964b8f",
+    "research/refinement_slot_20261013/cpu_results.json": "2a891c1adcb3b25390ee7967e5171396aedb9cb4da5ae85f7444450d758671d5",
+    "research/refinement_slot_followup_20261013/planar_velocity.sha256": "326639a3e66b2b8dbd21ecd76b32a331f3194a82d1b5888219eee4a1782f6366",
+    "research/refinement_slot_followup_20261013/incremental.patch": "b734b4b540ece11a037a0f119a9846c39c09c8247d3cc89877880a27c3d082c4",
+    "research/refinement_slot_followup_20261013/planar_velocity.cuh": "0b2f9e0bd483c199637e5672dc0ffc460bc383dd1804805befbeb4c5d8c708d1",
+    "research/refinement_slot_followup_20261013/baseline.json": "7ee505b7371a5258db7cb197c999be8859d14641915e3085f1969deb465880a4",
+    "research/refinement_slot_followup_20261013/manifest.json": "b11c1fb42abccc4b5638b974d1ea00b0687d8fad72b492eab3c8435bf485fd13",
+    "research/refinement_slot_followup_20261013/before.json": "809c4a6f330d4a29e92415fd0eb820f34dec38484e3560a8b9287b09553c2d87",
+    "research/refinement_slot_followup_20261013/notes.txt": "c04644a287aa936c9c6de0ca9d8bd83cee2d80aab9544ca284c9f7c029bfeff9",
+    "research/refinement_slot_followup_20261013/stdout.txt": "acb72f2b14e1abfe750330d84a38afe9bbe944bf028dde9700a291d5edff4be4",
+    "research/refinement_slot_followup_20261013/results.json": "dc38c3f5f88fac2ebf49be11df84e9f3da9d25504d400b6a506240a91735e4e1",
+    "research/refinement_prepare_20261013/incremental.patch": "df01345b8e2c33ebf6cdcbbb5104f02c4d7c239a6e6cafab1833228791bfa9a7",
+    "research/refinement_prepare_20261013/baseline.json": "5cc3c35faac9bb43a0017d83ddfca330d7da93f1e6407391da56b2e9df3b28b6",
+    "research/refinement_prepare_20261013/manifest.json": "5d479557cd01d61d8b652a3cf456fa57665bf624ce3b4a42c747523b74dec548",
+    "research/refinement_prepare_20261013/README.txt": "eee46f01add6ed7a5da76da76c98da628e13b930cfc49785399d7afbedbfd95f",
+    "research/refinement_prepare_20261013/validation.json": "945f4c3604ae0eae91c29741a39588207cfff3e05646e03a12d074a299956c2f",
+    "research/refinement_prepare_20261013/validation.txt": "5b5a8e9d455d37064c6709dcfd14e89ba66f51f09a11a9863b5cab67ac651d42",
+    "research/refinement_followup_20261013/gpu_rectangle_before.json": "aeab9314117b7eaa0950566094d20ecb5a304cc55b85887b6281694d3a6b8660",
+    "research/refinement_followup_20261013/gpu_before.json": "236cc69740cb40640cf4cd96cd94ff80644c2cf07c471b276092303edd3003e1",
+    "research/refinement_followup_20261013/gpu_rectangle_before_no_launch_1791886104981638567.json": "831b08511b78e8e631a17a638212b1c511e6f3fdb86019d7a77cc0f44d4015d2",
+    "research/refinement_followup_20261013/gpu_stdout.txt": "3147d3ab0b58ac9aa67c495491979ebb455db0fc2e89e7004facbd8c55c67b4e",
+    "research/refinement_followup_20261013/cpu_results_attempt1.json": "a91976e3ff92f7fe458a4432dae31d6b751bee92450d9a07e1dd5ee1cf5e915a",
+    "research/refinement_followup_20261013/incremental.patch": "b638544a02cbf7dd7acfcad545fcac50dc9640e193a9672f27916275c134253f",
+    "research/refinement_followup_20261013/baseline.json": "77694a29bbea2e61eb69eb5fe37eca7a8d5e82114bd59c7ff23e89d3db53a019",
+    "research/refinement_followup_20261013/gpu_seed1_before.json": "4dc6de02770a8e985f62d902ab9067cf5910084e4506ece059979640adb5575f",
+    "research/refinement_followup_20261013/gpu_seed1_stdout.txt": "8453a1b7221085691b39439428e39aaf52215abbbe9b1f84fc54c4a695260a9e",
+    "research/refinement_followup_20261013/cleanup.json": "ce1fb34fcbf2fadf7786234a8dd5dd9d0e520d9353a08b5df4c6777a35beed88",
+    "research/refinement_followup_20261013/manifest.json": "5f4c3b56a9ff8dfb422c37e0777af90536e94585ae7573caa05410e3cea294f5",
+    "research/refinement_followup_20261013/README.txt": "c553e889c6d66bb81d17d2691150cadf6fecdaa336de941281e7c85a6ff1eb12",
+    "research/refinement_followup_20261013/cpu_stdout.txt": "f9bcee3a2b43599e99c2e3b3a250aa4d4f4db1a73d1bf7cf1db0ab1fa585c54b",
+    "research/refinement_followup_20261013/gpu_before_no_launch.json": "396664d587d2e7791e972def03c7199845f7a162ab4626733fae1e54e1262da5",
+    "research/refinement_followup_20261013/gpu_rectangle_results.json": "9a06af9ec07de80d049889f321b7ea5f03036f4e461af2a43cdfb76d02ee1d6a",
+    "research/refinement_followup_20261013/gpu_rectangle_stdout.txt": "fea29f48685d84966b51d41b33e59bc01bef7d9dbc5e75b3d7c316de761f5bd5",
+    "research/refinement_followup_20261013/gpu_seed1_results.json": "ac54f5071b6e6095437078d4f8ed1cbc851a4b727ce6336281c1f27472f3dbe4",
+    "research/refinement_followup_20261013/run_gpu.py": "16b1520adbfee1651539f04dd694f5f02e9dc8ae4f4fc55d374a0ac06b50b4b8",
+    "research/refinement_followup_20261013/cpu_results.json": "a1a57b35c0839a82a7b653a062e852edf693d2c318da77dc1cb79373661bc780",
+    "research/refinement_followup_20261013/gpu_results.json": "be369bb072139b3fbfac4cbb3ab5eade7d2fb1ab67549ae2e4e0d0f48f640dfc",
+    "research/refinement_followup_20261013/cpu_stdout_attempt1.txt": "6ac5f889a9f6b6ecfa8abb74e98b07deaadc71c7f5488112eca26e4ed255e7ba",
+    "research/refinement_step_20261013/gpu_failure_validation.txt": "d6ec00e0e8c69015565135a67fac6de47701e9eebc3cbacc379abf8166ac61be",
+    "research/refinement_step_20261013/cpu_validation.json": "cf7200fc4b763f5a2133d8affeea306578a247179bb82ce2f5ae0d8e244c576b",
+    "research/refinement_step_20261013/incremental.patch": "c3d2d813b64f8a2305f54153508d71b546d86af7be1005cff96e0ef8c91297bb",
+    "research/refinement_step_20261013/baseline.json": "68bd37982acb433bea235a94f211c907be483e905742f98166235929f79ba95d",
+    "research/refinement_step_20261013/manifest.json": "a60a40ffa9073a8047f3b9f5af3c1256179603641083c3a20dda6cfa6e050146",
+    "research/refinement_step_20261013/README.txt": "922d6fc6c742203f69e174a12cac6b19e8ae15be74257134c08d72990b16d517",
+    "research/refinement_step_20261013/gpu_validation.json": "2f0218854a2a307dd15a891a781fa3c2b7e865c201630a36ca180134b1ee6436",
+    "research/refinement_step_20261013/gpu_validation.txt": "1714ee85e6235528bf29dac85bca1298a673bdb9bf0c9c364961bf364a83f0d2",
+    "research/refinement_step_20261013/gpu_failure_validation.json": "5e7d58863659af3c29f10aac11ff43516fedd39a30a40e5ead62732ba80fcbd3",
+    "research/repair-2026-10-10/simplification-checks.log": "c9f15e870d02003480adf1a7f2fe4a9aca66c1934c4477619f05c8a4798ba85b",
+    "research/repair-2026-10-10/repair-state.md": "4d4aa1ec0c11a87d2c8380912e7ed74cf5c910ae42e5cc529effde36c9020969",
+    "research/repair-2026-10-10/TRON_HANDOFF.md": "f8aaa3d99cd133c2055d4adf396a0a57d14f6006aea19e87611bd1c2c1b53a88",
+    "research/repair-2026-10-10/final-gpu.log": "988bb97256d17b88c14f3793b15880d727ecb285abe62e7d2ae27a16729651c3",
+    "research/repair-2026-10-10/baseline-status.txt": "074088d793014e3b8154c58718058c7d300fb45595f5129fa957ef1e4cec38e2",
+    "research/repair-2026-10-10/repair-architecture.md": "49be42ff5c994017f3175e17efda14d84f0b68f8ecd239f66ccee38415b60c5a",
+    "research/repair-2026-10-10/classic-results.json": "a5d15305f516fd378b54cf9029102be58a83a55a7bad4b8e058fcfe0cc9898f4",
+    "research/repair-2026-10-10/checkpoint-domain-2026-10-12.diff": "292b4bafe7a62d4fbbf7c165eb99929336edfcaa16b15f34f72ab71fcd928391",
+    "research/repair-2026-10-10/repair-numerical.md": "0272ebfa8c519aad161c520542cf53156574661609b91fd5ccad7955fdf2bd7b",
+    "research/repair-2026-10-10/provenance.json": "a81b7e32ecf7182c9617df1b39bbb063a05ef89290ad501bac4573cd5e8a6832",
+    "research/repair-2026-10-10/classic-signals.npz": "820c9a0b0713d7455f0a5839ac2cd5ee706086d1a26461225dcdb095673421e2",
+    "research/repair-2026-10-10/baseline-hashes.json": "d6a7d5f9ec5bceb0e7927d55603d9c5e70105982cd945723454659b19ab476e6",
+    "research/repair-2026-10-10/final-unit.log": "a892a39ecf88125558538cadce2cb5dc46d106b993b164e03da4ebb0eee68cef",
+    "research/repair-2026-10-10/original-user-files/tests/postproc/experiment.ipynb": "c6b45db1c57200f0777213ef8d44cb4996c1aa7a5fb42b968b77e56f51b4fca4",
+    "research/repair-2026-10-10/original-user-files/src/CelerisLab/lbm/kernels/config/config_physics.h": "26df33c2960ba36f3283e19b55b4ea92e50e4efda705f9ebfbf3f875a4092c59",
+    "research/repair-2026-10-10/original-user-files/src/CelerisLab/lbm/kernels/config/config_method.h": "3db4e16ef2c6b22349d04e6aa8ab04bdfe0eb784f9f3a98277e15dbed1835d81",
+    "research/repair-2026-10-10/original-user-files/src/CelerisLab/lbm/kernels/config/config_grid.h": "8be3a7cf74ba30d7fd3074fed79e63dbda7311c4d03b454ea641bf298ffeaa8d",
+    "research/repair-2026-10-10/original-user-files/src/CelerisLab/lbm/kernels/config/config_objects.h": "dbb93c063586da278c15d95e23f84c12e728f4f5f1bbc3980fe9cedaa6fff90e",
+    "research/j1-2026-10-12/REVIEW.md": "13004a4f140acdcf59acb57e9e2dda1bb95763d30060f822a7c206c94b813a9f",
+    "research/j1-2026-10-12/gpu.log": "8659a78ea52bbf8eb923d46ea71636ce63cd322352d5c98a74f631e666dd8cfb",
+    "research/j1-2026-10-12/baseline-status.txt": "ac398360e05b746b89ae0c3acfe202b5122e650a3bb1ff234ab26f874a303e64",
+    "research/j1-2026-10-12/baseline.json": "ad7afdf7b3913d11c07343e971fe2f43c2d1a2b99e3d5904a6ba89e3bb0b24fb",
+    "research/j1-2026-10-12/checkpoint-gpu.log": "adfe3d77d2e6c6f6184dccc0267b4404b20a7709505d5ff5affed0ed4a618083",
+    "research/j1-2026-10-12/cpu.log": "60cac097f7c4f11401df2aacb43a248640555e7628d2829c4680c71db34e9640",
+    "research/j1-2026-10-12/gpu-validation.log": "d1e9f2aea17a85eddcd94b81c700738ce073214857b55c28abd1219ff1edbed7",
+    "research/j1-2026-10-12/results.json": "449f8a17dacac0fc6d2489c4b10bac330dbbbdb38fad3ce54f739ac8c6d48e85",
+    "research/j1-2026-10-12/incremental.diff": "a454c23da7b0011645949c0fbf64d0c41ecfdab5642b1b7c5119868005d3c721",
+    "research/j3-coverage-2026-10-12/restart-21280.h5": "3e89c12c16f91f76ca9acd909e0fa7d42df6fbb5e870b299aa08ca42bc3e3dc9",
+    "research/j3-coverage-2026-10-12/REVIEW.md": "7293f3f3442855c8521698605aab504e026915a7bf1e77f5a24710d89a812443",
+    "research/j3-coverage-2026-10-12/restart-reference-21296.h5": "7192f510dd7820675aa1de130f55514136fba782cf77f92545189918a7e0c328",
+    "research/j3-coverage-2026-10-12/negative-end-20760.h5": "bd0bd063579d625e358762b1fdde5ac11bfcf739646a847fb77a4a2031011b9b",
+    "research/j3-coverage-2026-10-12/baseline-status.txt": "31c949b11b20d7cd4202dba16882b5712aa1653da0cb2da2f0ebd69bf488040e",
+    "research/j3-coverage-2026-10-12/baseline.json": "d8844104f2665a25bfc417ee29becf89ab3955fac9105b5ddb12cfb1fe2a55b0",
+    "research/j3-coverage-2026-10-12/verification.json": "205986efd2b41635721b7fd20288be982348c765180102c7102750ba088f3a28",
+    "research/j3-coverage-2026-10-12/negative-budget-20744.h5": "c09d75fc4a2cff68039a0956bd9d32b79b9cd3a6b386c72b4db54c214b110cd8",
+    "research/j3-coverage-2026-10-12/gpu-validation.log": "505cd5a5db46d7984aefb2a614151c25c4ace0e7d2a52e02c3e4f9792fd8eb95",
+    "research/j3-coverage-2026-10-12/results.json": "02460981ad49c9cc13b4246abad1d8afd2599c61bfb545a6e32da9bbcd5c0db1",
+    "research/j3-coverage-2026-10-12/incremental.diff": "98aa7855d5d6b91b4509a924c8a5aabab4339ba29c7e7dc2d91262c48e3848ca",
+    "research/audit-2026-10-09/numerical_semantics_results.json": "b95b065b594aa2911740dab216f87936c9bf7f7fa25acfda93b5738443564035",
+    "research/audit-2026-10-09/REVIEW.zh-CN.md": "2841fd3aa7a6baedbe1079d90915c8b05212b133824ed6abccaa1f09656eaefe",
+    "research/audit-2026-10-09/root-initializers-report.md": "ca448457c444949d5d0e1e10fa7121064510b77fc4c3512580900f0299219867",
+    "research/audit-2026-10-09/numerical-report.md": "970330b3a593f79f09866ce6ae82bc0ddd81226230d0a6ff06ae8ae756ee80da",
+    "research/audit-2026-10-09/numerical_collision_results.json": "51e5c263bb8cde82cedef2ccfdbf5ef657742a80218d7896b1ff877516e59693",
+    "research/audit-2026-10-09/architecture-cpu-results.json": "e1b809210005c8765b13fddbb5ed710d15f6fcbb4c5788a4064f3e88808433ef",
+    "research/audit-2026-10-09/numerical_compile_results.json": "c3b0ae02072a2ec408ada7513b542ec255f6855cb743a3ed7f91bd8f31504f44",
+    "research/audit-2026-10-09/state_results.json": "da9170df3e11231c73f20e5e79ed68e08966673d1dd52004ea6b6a279afc0dcd",
+    "research/audit-2026-10-09/architecture-report.md": "861079dc3f4ced9fdc41bfb22002d32e190c0d630d3ba2f138f9dc7a949b8371",
+    "research/audit-2026-10-09/state-report.md": "f8708807efc2e109810c5955f7c1884a932668c0b3cb2963c2df3b09f2a3d5c4",
+    "research/j3-offline-2026-10-12/REVIEW.md": "d9902c58498e73c29e054b23adb968f7e1e14421cba5c58d03bbc5a50159ae79",
+    "research/j3-offline-2026-10-12/lags.csv": "fbd9addd413f24c47f4411317e872265bb774e8e1724fe169412befa860ae94d",
+    "research/j3-offline-2026-10-12/localization.png": "a72907638e32b0ecfc2205bea438e7b408f40aad86217ce6ad9b4877840c9cfc",
+    "research/j3-offline-2026-10-12/results.json": "cdb857bea6f4e06ed15acf773505ce6d5147f8cb8ce0a53cc368ee267cde6361",
+    "research/j3-offline-2026-10-12/cpu-analysis.log": "bc02a9b197fc15ae1b503ca54655a7622d4361f9b45b7848ff9c387ea3665f11",
+    "research/j3-offline-2026-10-12/regions.csv": "3a8fc640b61d70e3b7f73d2bf8ac2bd3f720adf39a90dfda6180430e0489efae",
+    "research/j2-slot-2026-10-12/REVIEW.md": "10c4a94ffc32e0a2c4e0f6593b7cfc28479b5869f279f0b9d0b708fa3a47d1e6",
+    "research/j2-slot-2026-10-12/gpu-serialization-failure.log": "df804e53b35e7ddaad79a17842b4b5fd9d834e29ca2d56edb00e835848d09200",
+    "research/j2-slot-2026-10-12/baseline-status.txt": "812616e2d941efcf854e1b37d6e662dda1aaf2b69074fcc04017133e13b72166",
+    "research/j2-slot-2026-10-12/baseline.json": "e82a1844145fd0cbc585c581b29f80b56193f122cfe1dfa7578f26904a720285",
+    "research/j2-slot-2026-10-12/cli.log": "9482ad7101d501f27f92e204b2f3ae5c6d91bd887b525aa31cb4a2a188f3cb92",
+    "research/j2-slot-2026-10-12/cpu.log": "91aba5961006909fbbb860429a9d3cfc930112a0d74c7788bc51c0a5897b47e5",
+    "research/j2-slot-2026-10-12/gpu-validation.log": "223351b52c70fa4523289f3a1b3db435a11286379253280470900ffe397580a6",
+    "research/j2-slot-2026-10-12/results.json": "7d35ca7989aed5380e0a45de7f583972566fc516a051da63c53b35514e267494",
+    "research/j2-slot-2026-10-12/incremental.diff": "c9e391bc91438cd912c1ed5a419705d4388522f672c67a066cfc055e814e699f",
+    "research/design-2026-10-09/math-and-history.md": "64f8c82e4949d6f58b46faa09800958714859c36cad20bbeeae8b449ae7a6099",
+    "research/design-2026-10-09/math-checks.json": "94750381954317cde8d649db26beaed8ea945666572a05030ca2b4d97d384011",
+    "research/design-2026-10-09/Contracts.lean": "2442d9a778ef20e8af3fecf23be6fea6d73c6299ff744c9664b652bc5ee3f034",
+    "research/design-2026-10-09/jet-study.md": "a362142ef04a5ad5dbb4c9db9d221b1199dccec53780c8f2da49a15201cfe529",
+    "research/design-2026-10-09/PLAN.zh-CN.md": "0341dd7ee306a040340c8e5dedb07a109e931c27dbf3c994d072aa78e3b6bc67",
+    "research/design-2026-10-09/jet_closure_results.json": "12cf7d400a206f9f9ec9ea6ad251fe6bb0232e27bcbed22fbc1ead2c0fc7d249",
+    "research/design-2026-10-09/grid-study.md": "4435dc1275ec5e15b118becc6ac391f306195d1e5beaa58037b1aff3bb2465c7",
+    "research/design-2026-10-09/jet_closure_check.py": "fde45d0f8518740ef5c0bf0fe7635d6adaf9a2e789927dd4e68e991c138ddc30",
+    "research/design-2026-10-09/api-architecture-study.md": "d6fb45ec784f0e1db55fb9f34e137b9f551db0b9b39fd4f0ef247a78fc34eedf",
+    "research/design-2026-10-09/math_checks.py": "4254983a783fe4bad8888b3d7c243c87d991c7bbf242edb0f56f25cbaefee890",
+    "research/refinement_example_20261013/incremental.patch": "6acd05df6669ccdcf234ac1680c6e76c75a2587974adb6728f7edda6fd625b69",
+    "research/refinement_example_20261013/baseline.json": "ae0af15ddb40709d1e348655a665264984a240ded1e28af816a8000d08e784be",
+    "research/refinement_example_20261013/manifest.json": "6da85ac513065dcf49200bc0872bec38b6c7ba61f7d82036c2189cabe5ac29ce",
+    "research/refinement_example_20261013/before.json": "d95cd518f080eab92af5e53e1e9b6b6fad626eae51990e510d2d2f2ae9d0ec7b",
+    "research/refinement_example_20261013/notes.txt": "f111f8cba94b43d1127945fa41615037e1740efcfc529e802338dd8c4ff02795",
+    "research/refinement_example_20261013/stdout.txt": "9c59fb315a5552cce4ceab171003e425bf64d747137c89bd86d8779a34adcbd1",
+    "research/refinement_example_20261013/results.json": "8ab13bbc022f2a66898aa07ed94f43cb6716570e7a360a809b7fcd097316db7e",
+    "research/j3-reservoir-2026-10-12/gpu-availability-sandbox.log": "1d58470512e583a0acfabf6896ee5f31e5b493b8231aed54b864f64eb275b02c",
+    "research/j3-reservoir-2026-10-12/REVIEW.md": "1ea5f860728584ea6cbe40ba3994e40471102d8e2cf6d93e28fe47222cba0cab",
+    "research/j3-reservoir-2026-10-12/baseline-status.txt": "0ef1a8c9878c4053ebc1a7d4bace6d4ec38bf27ace167b4239ddbb1c6c897e20",
+    "research/j3-reservoir-2026-10-12/baseline.json": "847fefd1eae971985d34d04d89ee6d6f1c91f6940c54fe351d112faba7bc6838",
+    "research/j3-reservoir-2026-10-12/cpu.log": "b33f6c1a1b0ee67968c4cff85d491e46e30e0d6c796b552629714ab8b5dcead0",
+    "research/j3-reservoir-2026-10-12/gpu-validation.log": "ff04024db197e332f37c912a96413e3251fd0186947348ffbc33af6f4a899f2c",
+    "research/j3-reservoir-2026-10-12/results.json": "49685de7679a14860258abf1753aaa6d116ad709b868d907ddb40e74c9b845ea",
+    "research/j3-reservoir-2026-10-12/incremental.diff": "fae312831d71e46dd477a640b06ed927853a9e735d26bf9f5868927fa31cfa56"
+  },
+  "new_source": "examples/fixed_patch_jet.py"
+}