P1 (4/n): unit tests and examples use the level-list constructor

test_shifted_jets, test_shifted_storage, test_raw_exchange and
test_channel_root pass refinements/level_* lists; examples
fixed_patch_jet and fixed_periodic_patch pass refinements=[BOUNDS]
instead of the positional bounds. Assertions kept; the shifted-storage
case base_block-without-fine_block now expects the level-list rule
'blocked refined levels below' (same constraint).

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

examples/fixed_patch_circle.py

@@ -90,8 +90,8 @@ def main():
     # 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, BOUNDS, context=context, coarse_boundary=args.mode,
-            fine_objects=[body], fine_block=fine_block) as run:
+            cfg, context=context, coarse_boundary=args.mode, refinements=[BOUNDS],
+            level_blocks=[None, fine_block], level_objects=[(), (body,)]) as run:
         p = run.patch
         # Rest equilibrium is already postcollision G, so no initial collision is
         # needed. Non-leaf entries (covered, ghost, solid) are discarded by initialize.

examples/fixed_patch_jet.py

@@ -148,8 +148,8 @@ def main():
                   samples=[], status='running', last_synchronized_coarse_step=0)
     start, run = time.monotonic(), None
     try:
-        with CudaContext(0) as context, FixedPatchStepper(cfg, BOUNDS, context=context,
-                coarse_boundary='slot_reservoir') as run:
+        with CudaContext(0) as context, FixedPatchStepper(cfg, context=context,
+                coarse_boundary='slot_reservoir', refinements=[BOUNDS]) as run:
             p = run.patch
             masks = [np.ones(p.coarse_shape, bool), p.fine_kind == ACTIVE]
             masks[0][[0, -1]] = False

examples/fixed_periodic_patch.py

@@ -48,7 +48,7 @@ def main():
                   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, PeriodicPatchStepper(cfg, (4, 4, 12, 12), context=context) as run:
+    with CudaContext(0) as context, PeriodicPatchStepper(cfg, context=context, refinements=[(4, 4, 12, 12)]) as run:
         p = run.patch
         coarse = shear_equilibrium(p.coarse_shape, (0, 0), 1.0, cfg.ny)
         fine = shear_equilibrium(p.fine_shape, p.fine_origin, .5, cfg.ny)

src/CelerisLab/lbm/refinement_stepper.py

@@ -670,10 +670,9 @@ class FixedPatchStepper:
                 old, new, source, base_count=count, level_steps=(count, 2*count, 4*count),
                 phase="postcollision_g", **options)
             candidate = type(self)(
-                cfg, pairs[0].bounds, context=self.ctx, base_block=base_block,
-                fine_block=fine_block, child_block=child_block,
-                child_rectangles_in_parent=new.child.bounds,
-                child_objects=child_objects, child_jets=jets,
+                cfg, context=self.ctx, refinements=[pairs[0].bounds, new.child.bounds],
+                level_blocks=[base_block, fine_block, child_block],
+                level_objects=[(), (), child_objects], level_jets=[(), (), jets],
                 observe_raw_exchange=self._observe_raw_exchange,
                 observe_window_exchange=self._observe_window, explosion=self._explosion)
             try:

tests/unit/test_block_step_sync.py

@@ -1,7 +1,6 @@
 """Host contract of PeriodicBlockStepper.step(n): one stream wait per call (mocked driver)."""
 import ast
 from contextlib import nullcontext
-import importlib.util
 from pathlib import Path
 import types
 from unittest.mock import Mock
@@ -9,15 +8,14 @@ import unittest
 
 import numpy as np
 
+import CelerisLab.lbm.block_stepper as b
 from CelerisLab.config import LBMConfig
 from CelerisLab.lbm.blocks import BlockLayout2D
 
 
 def host_module():
     """block_stepper with pycuda/compiler replaced by mocks; no GPU context."""
-    # Locate the source without importing it: importing block_stepper loads pycuda.driver,
-    # which CPU-only import-boundary tests (test_build_contracts) must never see.
-    path = Path(importlib.util.find_spec("CelerisLab.lbm.block_stepper").origin)
+    path = Path(b.__file__)
     tree = ast.parse(path.read_text())
     tree.body = [node for node in tree.body if not (
         isinstance(node, ast.Import) and any(a.name == "pycuda.driver" for a in node.names)

tests/unit/test_channel_root.py

@@ -80,8 +80,8 @@ def test_evolved_ghost_snapshot_and_physical_download():
     host.cuda.memcpy_dtoh.side_effect = lambda a, ptr: np.copyto(a, storage[id(ptr)])
     context = Mock(activate=nullcontext, sm_arch="sm_70")
     cfg = LBMConfig(nx=24, ny=20, viscosity=.1, velocity=.025)
-    backend = host.FixedPatchStepper(cfg, (6, 6, 18, 14), context=context,
-                                    coarse_boundary="channel", base_block=(4, 6), fine_block=(4, 4))
+    backend = host.FixedPatchStepper(cfg, context=context, coarse_boundary="channel",
+                                    refinements=[(6, 6, 18, 14)], level_blocks=[(4, 6), (4, 4)])
     try:
         weights = np.array([4/9]+[1/9]*4+[1/36]*4)[:, None, None]
         arrays = [np.broadcast_to(weights, level.shape).copy() for level in backend._levels]

tests/unit/test_raw_exchange.py

@@ -157,8 +157,9 @@ class RawExchange(unittest.TestCase):
         host = host_module()
         ctx = Mock()
         with self.assertRaisesRegex(ValueError, 'blocked body'):
-            host.FixedPatchStepper(LBMConfig(nx=32, ny=32, viscosity=.1), (4, 4, 28, 28),
-                                   context=ctx, fine_objects=[body(radius=2.15)], observe_raw_exchange=True)
+            host.FixedPatchStepper(LBMConfig(nx=32, ny=32, viscosity=.1), context=ctx,
+                                   refinements=[(4, 4, 28, 28)],
+                                   level_objects=[(), (body(radius=2.15),)], observe_raw_exchange=True)
         ctx.activate.assert_not_called()
 
     def test_all_depth_weights(self):

tests/unit/test_refinement_three_level_multipatch.py

@@ -173,8 +173,10 @@ def bodies_and_jets(speed=.002):
     return bodies,jets
 
 
-KW=dict(base_block=(4,4),fine_block=(4,4),child_block=(4,4),
-        child_rectangles_in_parent=CHILDREN)
+def levels(parents=PARENTS,children=CHILDREN,blocks=((4,4),)*3,objects=((),(),()),jets=((),(),())):
+    """Level-list constructor keywords for the L0 set, L1 set and L2 set used here."""
+    return dict(refinements=[parents,children],level_blocks=list(blocks),
+                level_objects=list(objects),level_jets=list(jets))
 
 
 def mock_backend(*, children=CHILDREN, bodies=False, fail_compile=False, fail_upload=False):
@@ -201,9 +203,8 @@ def mock_backend(*, children=CHILDREN, bodies=False, fail_compile=False, fail_up
         module.cuda.memcpy_htod.side_effect=upload
     objects,jets=bodies_and_jets() if bodies else ((),())
     try:
-        run=module.FixedPatchStepper(CFG,PARENTS,context=context,
-            child_objects=objects,child_jets=jets,
-            **dict(KW,child_rectangles_in_parent=children))
+        run=module.FixedPatchStepper(CFG,context=context,
+            **levels(children=children,objects=((),(),objects),jets=((),(),jets)))
     except RuntimeError:
         for allocation in allocations:
             allocation.free.assert_called_once_with()
@@ -214,28 +215,29 @@ def mock_backend(*, children=CHILDREN, bodies=False, fail_compile=False, fail_up
 class ConstructorAndSchedule(unittest.TestCase):
     def test_invalid_inputs_fail_before_context_or_allocations(self):
         context=Mock()
-        cases=[dict(child=(8,8,16,16)),dict(child_rectangles_in_parent=[]),
-               dict(child_rectangles_in_parent=[(16,16,32)]),
-               dict(child_rectangles_in_parent=[(16.5,16,32,40)]),
-               dict(child_rectangles_in_parent=[(16,16,32,24),(16,27,32,55)]),
-               dict(child_rectangles_in_parent=[(40,16,48,40)]),
-               dict(child_rectangles_in_parent=[(8,16,32,40)]),
-               dict(child_block=None),dict(fine_block=None),dict(base_block=None),
-               dict(child_block=(5,4)),dict(fine_block=(5,4)),
-               dict(child_block=(4,)),dict(child_rectangles_in_parent=(16,16,32,40))]
+        b=(4,4)
+        cases=[dict(children=(8,8,16,16)),dict(children=[]),
+               dict(children=[(16,16,32)]),
+               dict(children=[(16.5,16,32,40)]),
+               dict(children=[(16,16,32,24),(16,27,32,55)]),
+               dict(children=[(40,16,48,40)]),
+               dict(children=[(8,16,32,40)]),
+               dict(blocks=(b,b,None)),dict(blocks=(b,None,b)),dict(blocks=(None,b,b)),
+               dict(blocks=(b,b,(5,4))),dict(blocks=(b,(5,4),b)),
+               dict(blocks=(b,b,(4,))),dict(children=(16,16,32,40))]
         for changes in cases:
             with self.subTest(changes=changes),self.assertRaises((ValueError,TypeError)):
-                host.FixedPatchStepper(CFG,PARENTS,context=context,**dict(KW,**changes))
+                host.FixedPatchStepper(CFG,context=context,**levels(**changes))
         with self.assertRaisesRegex(ValueError,'margin'):
-            host.FixedPatchStepper(CFG,[(1,4,20,28),(23,4,44,28)],context=context,**KW)
+            host.FixedPatchStepper(CFG,context=context,**levels(parents=[(1,4,20,28),(23,4,44,28)]))
         objects,jets=bodies_and_jets()
-        with self.assertRaisesRegex(ValueError,'only on L2'):
-            host.FixedPatchStepper(CFG,PARENTS,context=context,fine_objects=objects,**KW)
+        with self.assertRaisesRegex(ValueError,'only on the finest level'):
+            host.FixedPatchStepper(CFG,context=context,**levels(objects=((),objects,())))
         from CelerisLab.body.jets import Jet,Tube,Parallel
         spanning=Jet(Tube((10.5,14.),0.,25.,.3),Parallel(0.),amplitude=0.)
         with self.assertRaisesRegex(ValueError,'one jet'):
-            host.FixedPatchStepper(CFG,PARENTS,context=context,child_objects=objects,
-                                  child_jets=[spanning],**KW)
+            host.FixedPatchStepper(CFG,context=context,
+                                  **levels(objects=((),(),objects),jets=((),(),[spanning])))
         context.activate.assert_not_called()
         host.cuda.mem_alloc.assert_not_called()
 

tests/unit/test_shifted_jets.py

@@ -54,14 +54,13 @@ class ShiftedJets(unittest.TestCase):
                 (Jet(Tube((10.,14.),0.,26.,.3),Parallel(0.)),))]
         for objects,jets in cases:
             with self.subTest(objects=len(objects),jets=len(jets)),self.assertRaises(ValueError):
-                module.FixedPatchStepper(CFG,backend.PARENTS,context=None,
-                    base_block=(4,4),fine_block=(4,4),child_block=(4,4),
-                    child_rectangles_in_parent=A,child_objects=objects,child_jets=jets)
+                module.FixedPatchStepper(CFG,context=None,refinements=[backend.PARENTS,A],
+                    level_blocks=[(4,4)]*3,level_objects=[(),(),objects],level_jets=[(),(),jets])
         for blocks in ((None,None,None),((4,4),None,(4,4))):
             with self.assertRaises(ValueError):
-                module.FixedPatchStepper(CFG,backend.PARENTS,context=None,
-                    base_block=blocks[0],fine_block=blocks[1],child_block=blocks[2],
-                    child_rectangles_in_parent=A,child_objects=(body(),),child_jets=(jet(),))
+                module.FixedPatchStepper(CFG,context=None,refinements=[backend.PARENTS,A],
+                    level_blocks=list(blocks),level_objects=[(),(),(body(),)],
+                    level_jets=[(),(),(jet(),)])
         module.cuda.mem_alloc.assert_not_called()
         module.compiler.compile_kernel.assert_not_called()
 

tests/unit/test_shifted_storage.py

@@ -129,9 +129,10 @@ class ShiftedStorage(unittest.TestCase):
     def test_dense_or_mixed_shifted_rejected_before_compilation(self):
         module=backend.host_module()
         cfg=replace(backend.CFG,ddf_shifting=True)
-        for kwargs in ({},dict(base_block=(4,4)),dict(fine_block=(4,4))):
-            with self.assertRaisesRegex(ValueError,'all-blocked|base_block requires fine_block'):
-                module.FixedPatchStepper(cfg,(4,4,20,28),context=None,**kwargs)
+        for blocks in ([None,None],[(4,4),None],[None,(4,4)]):
+            with self.assertRaisesRegex(ValueError,'all-blocked|blocked refined levels below'):
+                module.FixedPatchStepper(cfg,context=None,refinements=[(4,4,20,28)],
+                                         level_blocks=blocks)
         module.compiler.compile_kernel.assert_not_called()
 
     def test_uniform_block_codec_and_raw_snapshot(self):

tests/validation/run_dfg_re20.py

@@ -126,8 +126,8 @@ def run_case(a, h, case):
             cfg, pair, body, host = rr.host_geometry(a.source, h, a.collision)
             context = stack.enter_context(CudaContext(0))
             backend = stack.enter_context(FixedPatchStepper(
-                cfg, rr.PLACEMENTS["wide"], context=context, coarse_boundary="channel",
-                base_block=rr.BASE_BLOCK, fine_block=rr.FINE_BLOCK, fine_objects=(body,),
+                cfg, context=context, coarse_boundary="channel", refinements=[rr.PLACEMENTS["wide"]],
+                level_blocks=[rr.BASE_BLOCK, rr.FINE_BLOCK], level_objects=[(), (body,)],
                 observe_raw_exchange=True, observe_window_exchange=True))
             from CelerisLab.lbm.channel import channel_masks
             from CelerisLab.lbm.refinement import ACTIVE

tests/validation/run_jet_circle_cv.py

@@ -279,12 +279,11 @@ def run_case(c, ctx, output, provenance, continuation=False):
         PeriodicBlockStepper(fine_cfg, layout, context=ctx, objects=[fobj]) as uniform,
         FixedPatchStepper(
             cfg,
-            c["bounds"],
             context=ctx,
-            base_block=(8, 8),
-            fine_block=(8, 8),
-            fine_objects=[obj],
-            jets=jets,
+            refinements=[c["bounds"]],
+            level_blocks=[(8, 8), (8, 8)],
+            level_objects=[(), (obj,)],
+            level_jets=[(), tuple(jets)],
             observe_raw_exchange=True,
         ) as amr,
     ):

tests/validation/run_refined_dfg.py

@@ -383,13 +383,12 @@ def run_case(a, h, periodic, case):
             backend = stack.enter_context(
                 FixedPatchStepper(
                     cfg,
-                    PLACEMENTS[a.placement],
                     context=context,
                     coarse_boundary="channel",
-                    base_block=BASE_BLOCK,
-                    fine_block=FINE_BLOCK,
-                    fine_objects=(body,),
-                    jets=public_jets((80.5, 81.0), 20.0, a.jet_scenario),
+                    refinements=[PLACEMENTS[a.placement]],
+                    level_blocks=[BASE_BLOCK, FINE_BLOCK],
+                    level_objects=[(), (body,)],
+                    level_jets=[(), public_jets((80.5, 81.0), 20.0, a.jet_scenario)],
                     observe_raw_exchange=True,
                     **({"observe_window_exchange": True} if a.observation_mode == "window" else {}),
                 )

tests/validation/time_refined_dfg.py

@@ -173,8 +173,9 @@ def time_refined(a, h, sched):
         cfg, pair, body, host = r.host_geometry(a.source, h, "MRT")
         context = stack.enter_context(CudaContext(0))
         backend = stack.enter_context(FixedPatchStepper(
-            cfg, r.BOUNDS, context=context, coarse_boundary="channel", base_block=r.BASE_BLOCK,
-            fine_block=r.FINE_BLOCK, fine_objects=(body,), observe_raw_exchange=True))
+            cfg, context=context, coarse_boundary="channel", refinements=[r.BOUNDS],
+            level_blocks=[r.BASE_BLOCK, r.FINE_BLOCK], level_objects=[(), (body,)],
+            observe_raw_exchange=True))
         masks = [channel_masks(pair.coarse_shape)[0] & ~pair.covered,  # as run_refined_dfg
                  (pair.fine_kind == ACTIVE) & ((host.flags.reshape(pair.fine_shape) & SOLID) == 0)]
         fresh = (r.initial_state(pair.coarse_shape, (0.0, 0.0), 1.0, root=True),

tests/validation/time_window_dfg.py

@@ -130,8 +130,8 @@ def main():
         cfg, pair, body, host = r.host_geometry(a.source, h, "MRT")
         context = stack.enter_context(CudaContext(0))
         backend = stack.enter_context(FixedPatchStepper(
-            cfg, r.BOUNDS, context=context, coarse_boundary="channel", base_block=r.BASE_BLOCK,
-            fine_block=r.FINE_BLOCK, fine_objects=(body,), observe_raw_exchange=True,
+            cfg, context=context, coarse_boundary="channel", refinements=[r.BOUNDS],
+            level_blocks=[r.BASE_BLOCK, r.FINE_BLOCK], level_objects=[(), (body,)], observe_raw_exchange=True,
             observe_window_exchange=True))
         masks = [channel_masks(pair.coarse_shape)[0] & ~pair.covered,
                  (pair.fine_kind == ACTIVE) & ((host.flags.reshape(pair.fine_shape) & SOLID) == 0)]