Add stationary passive circles across same-level block seams

blocks.cu: BlockCurvedBoundary passes the receiver-local core cell and the
block-offset fi to the unchanged apply_bouzidi_link (Uw=Vw=0, obs=nullptr),
so k_s and the q<1/2 donor follow the window image the next pull reads.
BlockStep takes nullable block-cell flags; solid cores store NaN each step.
Adds core/flags.cuh, core/obs.cuh and boundary/curved_boundary.cuh.
block_stepper.py: objects=() accepts stationary passive circles only; host
preparation rejects before CUDA: non-circle/moving/actuated/sensor roles,
overlap, domain-edge contact, and any fluid core (all rows/columns, periodic
neighbors) whose pull from a solid lacks exactly one cut link. Uses
map_cut_links for unique receiver owner/local writer. Order per step:
halo copy -> BFL -> pull/collide, no copy in between. Fluid-only
initialize validation; solids NaN.
Tests: CPU rejections/tables; GPU 32x24, nu .1, 8 steps, circle
(15.5,11.5) R4.3 with halo-write and halo-donor presence asserted,
1x1/2x2/4x2 bit-identical, finite fluid/NaN solid, FP64 BFL+pull/SRT
<= 3e-6 on fluid; drift reported. Body-free gate unchanged.

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

tests/validation/multigrid/test_block_stepper.py

@@ -2,7 +2,11 @@
 
 Frozen GPU gates (32x24, 8 steps, positive low-Mach non-equilibrium state):
 finite cores; bit-identical 1x1, 2x2 and 4x2 splits; max |G - FP64 oracle|
-<= 3e-6. Mass/momentum drift is reported, not gated.
+<= 3e-6. Static circle (centre (15.5, 11.5), R=4.3, on the 2x2 corner seam), same
+case: halo writes and q<.5 halo donors asserted present; finite fluid / NaN
+solid cores; bit-identical splits; max |G - FP64 BFL+pull/SRT| <= 3e-6 on
+fluid cells, from the same FP32-packed link data and initial populations.
+Mass/momentum drift is reported, not gated.
 """
 from contextlib import nullcontext
 from pathlib import Path
@@ -14,10 +18,12 @@ from unittest.mock import MagicMock, Mock, patch
 import numpy as np
 import pycuda.driver as cuda
 
+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.lbm import block_stepper as implementation
-from CelerisLab.lbm.blocks import BlockLayout2D
+from CelerisLab.lbm.blocks import NO_DONOR, BlockLayout2D
 from CelerisLab.lbm.block_stepper import PeriodicBlockStepper
 from CelerisLab.lbm.descriptors import D2Q9_EX, D2Q9_EY
 
@@ -59,6 +65,48 @@ def oracle(g, steps):
     return g
 
 
+CENTER, RADIUS = (15.5, 11.5), 4.3
+
+
+def circle(center=CENTER, radius=RADIUS):
+    return SimObject(0, geometry=CircleGeometry(*center, radius), center=center, radius=radius)
+
+
+def dense_flags():
+    """FLUID everywhere, circle flags on its solids (as the stepper builds them)."""
+    mask = circle().get_flag_mask(NX, NY)
+    flags = np.full(NX * NY, 1, np.uint16)
+    flags[(mask & 2) != 0] = mask[(mask & 2) != 0]
+    return flags
+
+
+def circle_oracle(g, steps, solid, links):
+    """FP64 periodic static linear BFL -> pull -> SRT on fluid; solids NaN."""
+    g = g.astype(np.float64)
+    g[:, solid] = np.nan
+    omega = 1 / (3 * NU + .5)
+    rows = [(*divmod(int(link.fluid_idx), NX), int(link.dir), float(np.float32(link.q)),
+             int(link.fallback)) for link in links]
+    for _ in range(steps):
+        staged = g.copy()
+        for y, x, d, q, fallback in rows:
+            ey, ex, o = D2Q9_EY[d], D2Q9_EX[d], d + 1 if d % 2 else d - 1
+            toward = g[d, y, x]
+            if fallback:
+                value = toward
+            elif q < .5:
+                value = 2 * q * toward + (1 - 2 * q) * g[d, (y - ey) % NY, (x - ex) % NX]
+            else:
+                value = toward / (2 * q) + (1 - 1 / (2 * q)) * g[o, y, x]
+            staged[o, (y + ey) % NY, (x + ex) % NX] = value
+        f = np.stack([np.roll(staged[q], (D2Q9_EY[q], D2Q9_EX[q]), axis=(0, 1)) for q in range(9)])
+        rho = f.sum(axis=0)
+        ux, uy = (CX[:, None, None] * f).sum(axis=0) / rho, (CY[:, None, None] * f).sum(axis=0) / rho
+        g = f + omega * (feq(rho, ux, uy) - f)
+        g[:, solid] = np.nan
+    return g
+
+
 def totals(g):
     g = g.astype(np.float64)
     return g.sum(), (CX[:, None, None] * g).sum(), (CY[:, None, None] * g).sum()
@@ -80,6 +128,17 @@ class CpuContracts(unittest.TestCase):
             with self.subTest(cfg=cfg.collision, layout=getattr(lay, "periodic", lay)):
                 with self.assertRaises(ValueError):
                     PeriodicBlockStepper(cfg, lay, context=self.forbidden_context())
+        moving = circle()
+        moving.state.vx = .01
+        build_links = CircleGeometry.build_cut_links
+        for objects in ([moving], [circle((1.5, 11.5), 2.0)], [circle(), circle()]):
+            with self.assertRaises(ValueError):
+                PeriodicBlockStepper(config(), layout, context=self.forbidden_context(), objects=objects)
+        with patch.object(CircleGeometry, "build_cut_links",
+                          lambda geometry, *a, **k: build_links(geometry, *a, **k)[1:]):
+            with self.assertRaisesRegex(ValueError, "cover every fluid pull"):
+                PeriodicBlockStepper(config(), layout, context=self.forbidden_context(),
+                                     objects=[circle()])
         with patch.object(implementation, "MAX_GRID_DIM", 3):
             with self.assertRaisesRegex(ValueError, "launch limits"):
                 PeriodicBlockStepper(config(), layout, context=self.forbidden_context())
@@ -107,6 +166,16 @@ class CpuContracts(unittest.TestCase):
             alloc.assert_not_called()
             upload.assert_not_called()
 
+    def test_static_circle_tables(self):
+        layout = BlockLayout2D.build(NY, NX, 12, 16)
+        tables = implementation._static_circles(layout, (circle(),))
+        links = CircleGeometry(*CENTER, RADIUS).build_cut_links(NX, NY, domain_flags=dense_flags())
+        self.assertEqual(len(tables["cell"]), len(links))
+        np.testing.assert_array_equal(tables["q"], np.array([l.q for l in links], np.float32))
+        solid_cells = layout.owner[tables["solid"]].astype(np.intp)
+        self.assertTrue((tables["flags"][solid_cells] & 2).all())
+        self.assertEqual(int(np.count_nonzero(tables["flags"] & 2)), int(tables["solid"].sum()))
+
     def fake_backend(self):
         backend = PeriodicBlockStepper.__new__(PeriodicBlockStepper)
         backend.layout = BlockLayout2D.build(NY, NX, 12, 16)
@@ -117,6 +186,7 @@ class CpuContracts(unittest.TestCase):
         backend._stream = Mock()
         backend._module = Mock()
         backend._copy = backend._step = Mock()
+        backend.boundary, backend._curved, backend._tables, backend._links = None, None, {}, 0
         backend._dst, backend._src = Mock(), Mock()
         backend._block, backend._grid, backend._copy_grid = (32, 1, 1), (1, 1, 1), (1, 1)
         backend._allocations = [Mock(), Mock()]
@@ -211,6 +281,46 @@ class PeriodicBlockGPU(unittest.TestCase):
             *(a - b for a, b in zip(after, before))), flush=True)
         self.assertLessEqual(error, ORACLE_ATOL)
 
+    def test_static_circle_across_block_seams(self):
+        from CelerisLab.cuda.context import CudaContext
+        flags = dense_flags()
+        solid = ((flags & 2) != 0).reshape(NY, NX)
+        links = CircleGeometry(*CENTER, RADIUS).build_cut_links(NX, NY, domain_flags=flags)
+        for by, bx in SPLITS[1:]:  # fixture must exercise receiver-local halo staging
+            layout = BlockLayout2D.build(NY, NX, by, bx)
+            mapped = layout.map_cut_links(links)
+            cells = int(np.prod(layout.local_shape))
+            core = set(layout.owner.ravel().tolist())
+            writes = {int(w) // (9 * cells) * cells + int(w) % cells for w in mapped.write}
+            self.assertTrue(writes - core, (by, bx))
+            self.assertTrue({int(d) for d in mapped.donor if d != NO_DONOR} - core, (by, bx))
+        g0 = initial_state()
+        results = []
+        with CudaContext(0) as context:
+            for by, bx in SPLITS:
+                layout = BlockLayout2D.build(NY, NX, by, bx)
+                with PeriodicBlockStepper(config(), layout, context=context, objects=[circle()]) as backend:
+                    for key, values, dtype in (("q", [l.q for l in links], np.float32),
+                                               ("dir", [l.dir for l in links], np.uint8),
+                                               ("fallback", [l.fallback for l in links], np.uint8)):
+                        np.testing.assert_array_equal(backend.boundary[key], np.array(values, dtype))
+                    backend.initialize(g0)
+                    backend.step(STEPS)
+                    results.append(backend.download())
+        for (by, bx), g in zip(SPLITS, results):
+            self.assertTrue(np.isfinite(g[:, ~solid]).all(), (by, bx))
+            self.assertTrue(np.isnan(g[:, solid]).all(), (by, bx))
+            np.testing.assert_array_equal(g, results[0], err_msg=f"split {(by, bx)}")
+        expected = circle_oracle(g0, STEPS, solid, links)
+        error = np.abs(results[0][:, ~solid].astype(np.float64) - expected[:, ~solid]).max()
+        start = g0.copy()
+        start[:, solid] = 0
+        before, after = totals(start), totals(np.nan_to_num(results[0]))
+        print(f"circle max_abs_oracle_error={error:.3e} gate={ORACLE_ATOL:.0e} links={len(links)}", flush=True)
+        print("circle drift mass={:.3e} jx={:.3e} jy={:.3e}".format(
+            *(a - b for a, b in zip(after, before))), flush=True)
+        self.assertLessEqual(error, ORACLE_ATOL)
+
 
 if __name__ == "__main__":
     unittest.main()