Compare commits

..
Author SHA1 Message Date
ClaudeandClaude Opus 5.5 5167c79378 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>
2026-10-21 01:46:52 +00:00
ClaudeandClaude Opus 5.5 aedddc35b1 P1 (3/n): three-level multipatch unit tests use the level-list constructor
KW (legacy base/fine/child blocks + child_rectangles_in_parent) becomes
levels(): refinements=[PARENTS, CHILDREN], level_blocks, level_objects,
level_jets. Every negative case is kept and expressed per level (child
rectangles, per-level blocks); the L1-body case now expects the level-list
rule's message 'only on the finest level' instead of the legacy keyword
message 'only on L2' (same constraint).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-21 01:46:06 +00:00
ClaudeandClaude Opus 5.5 7821c6ad71 P1 (2/n): runners and example use the level-list constructor
run_refined_dfg, run_dfg_re20, time_window_dfg, time_refined_dfg,
run_jet_circle_cv and examples/fixed_patch_circle pass refinements /
level_blocks / level_objects / level_jets instead of bounds, base_block,
fine_block, fine_objects and jets. One-to-one with _legacy_levels: same
rectangle (FixedPatch2D frame), same blocks, bodies and Jets.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-21 01:35:04 +00:00
ClaudeandClaude Opus 5.5 392314e1ae P1 (1/n): remap_child builds its candidate through the level-list API
The only in-library caller of the legacy constructor keywords now passes
refinements=[L1 bounds, L2 set], level_blocks=[base, fine, child],
level_objects=[(), (), child_objects], level_jets=[(), (), jets] -- the
exact lists _legacy_levels produced for it. Legacy keywords stay until
every caller is migrated (final P1 commit).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-21 01:34:33 +00:00
15 changed files with 61 additions and 62 deletions

No files matched your search

+2 -2
View File
@@ -90,8 +90,8 @@ def main():
# The caller owns the CUDA context; the stepper must be closed first (the # The caller owns the CUDA context; the stepper must be closed first (the
# nested with-statement does that). # nested with-statement does that).
with CudaContext(0) as context, FixedPatchStepper( with CudaContext(0) as context, FixedPatchStepper(
cfg, BOUNDS, context=context, coarse_boundary=args.mode, cfg, context=context, coarse_boundary=args.mode, refinements=[BOUNDS],
fine_objects=[body], fine_block=fine_block) as run: level_blocks=[None, fine_block], level_objects=[(), (body,)]) as run:
p = run.patch p = run.patch
# Rest equilibrium is already postcollision G, so no initial collision is # Rest equilibrium is already postcollision G, so no initial collision is
# needed. Non-leaf entries (covered, ghost, solid) are discarded by initialize. # needed. Non-leaf entries (covered, ghost, solid) are discarded by initialize.
+2 -2
View File
@@ -148,8 +148,8 @@ def main():
samples=[], status='running', last_synchronized_coarse_step=0) samples=[], status='running', last_synchronized_coarse_step=0)
start, run = time.monotonic(), None start, run = time.monotonic(), None
try: try:
with CudaContext(0) as context, FixedPatchStepper(cfg, BOUNDS, context=context, with CudaContext(0) as context, FixedPatchStepper(cfg, context=context,
coarse_boundary='slot_reservoir') as run: coarse_boundary='slot_reservoir', refinements=[BOUNDS]) as run:
p = run.patch p = run.patch
masks = [np.ones(p.coarse_shape, bool), p.fine_kind == ACTIVE] masks = [np.ones(p.coarse_shape, bool), p.fine_kind == ACTIVE]
masks[0][[0, -1]] = False masks[0][[0, -1]] = False
+1 -1
View File
@@ -48,7 +48,7 @@ def main():
nx=16, ny=16, viscosity=.1, velocity=1e-3, rho=1.0, nx=16, ny=16, viscosity=.1, velocity=1e-3, rho=1.0,
lattice_model="D2Q9", collision="SRT", streaming="double_buffer", lattice_model="D2Q9", collision="SRT", streaming="double_buffer",
store_precision="FP32", ddf_shifting=False, les_enabled=False) 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 p = run.patch
coarse = shear_equilibrium(p.coarse_shape, (0, 0), 1.0, cfg.ny) coarse = shear_equilibrium(p.coarse_shape, (0, 0), 1.0, cfg.ny)
fine = shear_equilibrium(p.fine_shape, p.fine_origin, .5, cfg.ny) fine = shear_equilibrium(p.fine_shape, p.fine_origin, .5, cfg.ny)
+3 -4
View File
@@ -670,10 +670,9 @@ class FixedPatchStepper:
old, new, source, base_count=count, level_steps=(count, 2*count, 4*count), old, new, source, base_count=count, level_steps=(count, 2*count, 4*count),
phase="postcollision_g", **options) phase="postcollision_g", **options)
candidate = type(self)( candidate = type(self)(
cfg, pairs[0].bounds, context=self.ctx, base_block=base_block, cfg, context=self.ctx, refinements=[pairs[0].bounds, new.child.bounds],
fine_block=fine_block, child_block=child_block, level_blocks=[base_block, fine_block, child_block],
child_rectangles_in_parent=new.child.bounds, level_objects=[(), (), child_objects], level_jets=[(), (), jets],
child_objects=child_objects, child_jets=jets,
observe_raw_exchange=self._observe_raw_exchange, observe_raw_exchange=self._observe_raw_exchange,
observe_window_exchange=self._observe_window, explosion=self._explosion) observe_window_exchange=self._observe_window, explosion=self._explosion)
try: try:
+2 -4
View File
@@ -1,7 +1,6 @@
"""Host contract of PeriodicBlockStepper.step(n): one stream wait per call (mocked driver).""" """Host contract of PeriodicBlockStepper.step(n): one stream wait per call (mocked driver)."""
import ast import ast
from contextlib import nullcontext from contextlib import nullcontext
import importlib.util
from pathlib import Path from pathlib import Path
import types import types
from unittest.mock import Mock from unittest.mock import Mock
@@ -9,15 +8,14 @@ import unittest
import numpy as np import numpy as np
import CelerisLab.lbm.block_stepper as b
from CelerisLab.config import LBMConfig from CelerisLab.config import LBMConfig
from CelerisLab.lbm.blocks import BlockLayout2D from CelerisLab.lbm.blocks import BlockLayout2D
def host_module(): def host_module():
"""block_stepper with pycuda/compiler replaced by mocks; no GPU context.""" """block_stepper with pycuda/compiler replaced by mocks; no GPU context."""
# Locate the source without importing it: importing block_stepper loads pycuda.driver, path = Path(b.__file__)
# which CPU-only import-boundary tests (test_build_contracts) must never see.
path = Path(importlib.util.find_spec("CelerisLab.lbm.block_stepper").origin)
tree = ast.parse(path.read_text()) tree = ast.parse(path.read_text())
tree.body = [node for node in tree.body if not ( 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) isinstance(node, ast.Import) and any(a.name == "pycuda.driver" for a in node.names)
+2 -2
View File
@@ -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)]) host.cuda.memcpy_dtoh.side_effect = lambda a, ptr: np.copyto(a, storage[id(ptr)])
context = Mock(activate=nullcontext, sm_arch="sm_70") context = Mock(activate=nullcontext, sm_arch="sm_70")
cfg = LBMConfig(nx=24, ny=20, viscosity=.1, velocity=.025) cfg = LBMConfig(nx=24, ny=20, viscosity=.1, velocity=.025)
backend = host.FixedPatchStepper(cfg, (6, 6, 18, 14), context=context, backend = host.FixedPatchStepper(cfg, context=context, coarse_boundary="channel",
coarse_boundary="channel", base_block=(4, 6), fine_block=(4, 4)) refinements=[(6, 6, 18, 14)], level_blocks=[(4, 6), (4, 4)])
try: try:
weights = np.array([4/9]+[1/9]*4+[1/36]*4)[:, None, None] 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] arrays = [np.broadcast_to(weights, level.shape).copy() for level in backend._levels]
+3 -2
View File
@@ -157,8 +157,9 @@ class RawExchange(unittest.TestCase):
host = host_module() host = host_module()
ctx = Mock() ctx = Mock()
with self.assertRaisesRegex(ValueError, 'blocked body'): with self.assertRaisesRegex(ValueError, 'blocked body'):
host.FixedPatchStepper(LBMConfig(nx=32, ny=32, viscosity=.1), (4, 4, 28, 28), host.FixedPatchStepper(LBMConfig(nx=32, ny=32, viscosity=.1), context=ctx,
context=ctx, fine_objects=[body(radius=2.15)], observe_raw_exchange=True) refinements=[(4, 4, 28, 28)],
level_objects=[(), (body(radius=2.15),)], observe_raw_exchange=True)
ctx.activate.assert_not_called() ctx.activate.assert_not_called()
def test_all_depth_weights(self): def test_all_depth_weights(self):
@@ -173,8 +173,10 @@ def bodies_and_jets(speed=.002):
return bodies,jets return bodies,jets
KW=dict(base_block=(4,4),fine_block=(4,4),child_block=(4,4), def levels(parents=PARENTS,children=CHILDREN,blocks=((4,4),)*3,objects=((),(),()),jets=((),(),())):
child_rectangles_in_parent=CHILDREN) """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): 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 module.cuda.memcpy_htod.side_effect=upload
objects,jets=bodies_and_jets() if bodies else ((),()) objects,jets=bodies_and_jets() if bodies else ((),())
try: try:
run=module.FixedPatchStepper(CFG,PARENTS,context=context, run=module.FixedPatchStepper(CFG,context=context,
child_objects=objects,child_jets=jets, **levels(children=children,objects=((),(),objects),jets=((),(),jets)))
**dict(KW,child_rectangles_in_parent=children))
except RuntimeError: except RuntimeError:
for allocation in allocations: for allocation in allocations:
allocation.free.assert_called_once_with() 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): class ConstructorAndSchedule(unittest.TestCase):
def test_invalid_inputs_fail_before_context_or_allocations(self): def test_invalid_inputs_fail_before_context_or_allocations(self):
context=Mock() context=Mock()
cases=[dict(child=(8,8,16,16)),dict(child_rectangles_in_parent=[]), b=(4,4)
dict(child_rectangles_in_parent=[(16,16,32)]), cases=[dict(children=(8,8,16,16)),dict(children=[]),
dict(child_rectangles_in_parent=[(16.5,16,32,40)]), dict(children=[(16,16,32)]),
dict(child_rectangles_in_parent=[(16,16,32,24),(16,27,32,55)]), dict(children=[(16.5,16,32,40)]),
dict(child_rectangles_in_parent=[(40,16,48,40)]), dict(children=[(16,16,32,24),(16,27,32,55)]),
dict(child_rectangles_in_parent=[(8,16,32,40)]), dict(children=[(40,16,48,40)]),
dict(child_block=None),dict(fine_block=None),dict(base_block=None), dict(children=[(8,16,32,40)]),
dict(child_block=(5,4)),dict(fine_block=(5,4)), dict(blocks=(b,b,None)),dict(blocks=(b,None,b)),dict(blocks=(None,b,b)),
dict(child_block=(4,)),dict(child_rectangles_in_parent=(16,16,32,40))] 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: for changes in cases:
with self.subTest(changes=changes),self.assertRaises((ValueError,TypeError)): 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'): 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() objects,jets=bodies_and_jets()
with self.assertRaisesRegex(ValueError,'only on L2'): with self.assertRaisesRegex(ValueError,'only on the finest level'):
host.FixedPatchStepper(CFG,PARENTS,context=context,fine_objects=objects,**KW) host.FixedPatchStepper(CFG,context=context,**levels(objects=((),objects,())))
from CelerisLab.body.jets import Jet,Tube,Parallel from CelerisLab.body.jets import Jet,Tube,Parallel
spanning=Jet(Tube((10.5,14.),0.,25.,.3),Parallel(0.),amplitude=0.) spanning=Jet(Tube((10.5,14.),0.,25.,.3),Parallel(0.),amplitude=0.)
with self.assertRaisesRegex(ValueError,'one jet'): with self.assertRaisesRegex(ValueError,'one jet'):
host.FixedPatchStepper(CFG,PARENTS,context=context,child_objects=objects, host.FixedPatchStepper(CFG,context=context,
child_jets=[spanning],**KW) **levels(objects=((),(),objects),jets=((),(),[spanning])))
context.activate.assert_not_called() context.activate.assert_not_called()
host.cuda.mem_alloc.assert_not_called() host.cuda.mem_alloc.assert_not_called()
+5 -6
View File
@@ -54,14 +54,13 @@ class ShiftedJets(unittest.TestCase):
(Jet(Tube((10.,14.),0.,26.,.3),Parallel(0.)),))] (Jet(Tube((10.,14.),0.,26.,.3),Parallel(0.)),))]
for objects,jets in cases: for objects,jets in cases:
with self.subTest(objects=len(objects),jets=len(jets)),self.assertRaises(ValueError): with self.subTest(objects=len(objects),jets=len(jets)),self.assertRaises(ValueError):
module.FixedPatchStepper(CFG,backend.PARENTS,context=None, module.FixedPatchStepper(CFG,context=None,refinements=[backend.PARENTS,A],
base_block=(4,4),fine_block=(4,4),child_block=(4,4), level_blocks=[(4,4)]*3,level_objects=[(),(),objects],level_jets=[(),(),jets])
child_rectangles_in_parent=A,child_objects=objects,child_jets=jets)
for blocks in ((None,None,None),((4,4),None,(4,4))): for blocks in ((None,None,None),((4,4),None,(4,4))):
with self.assertRaises(ValueError): with self.assertRaises(ValueError):
module.FixedPatchStepper(CFG,backend.PARENTS,context=None, module.FixedPatchStepper(CFG,context=None,refinements=[backend.PARENTS,A],
base_block=blocks[0],fine_block=blocks[1],child_block=blocks[2], level_blocks=list(blocks),level_objects=[(),(),(body(),)],
child_rectangles_in_parent=A,child_objects=(body(),),child_jets=(jet(),)) level_jets=[(),(),(jet(),)])
module.cuda.mem_alloc.assert_not_called() module.cuda.mem_alloc.assert_not_called()
module.compiler.compile_kernel.assert_not_called() module.compiler.compile_kernel.assert_not_called()
+4 -3
View File
@@ -129,9 +129,10 @@ class ShiftedStorage(unittest.TestCase):
def test_dense_or_mixed_shifted_rejected_before_compilation(self): def test_dense_or_mixed_shifted_rejected_before_compilation(self):
module=backend.host_module() module=backend.host_module()
cfg=replace(backend.CFG,ddf_shifting=True) cfg=replace(backend.CFG,ddf_shifting=True)
for kwargs in ({},dict(base_block=(4,4)),dict(fine_block=(4,4))): for blocks in ([None,None],[(4,4),None],[None,(4,4)]):
with self.assertRaisesRegex(ValueError,'all-blocked|base_block requires fine_block'): with self.assertRaisesRegex(ValueError,'all-blocked|blocked refined levels below'):
module.FixedPatchStepper(cfg,(4,4,20,28),context=None,**kwargs) module.FixedPatchStepper(cfg,context=None,refinements=[(4,4,20,28)],
level_blocks=blocks)
module.compiler.compile_kernel.assert_not_called() module.compiler.compile_kernel.assert_not_called()
def test_uniform_block_codec_and_raw_snapshot(self): def test_uniform_block_codec_and_raw_snapshot(self):
+2 -2
View File
@@ -126,8 +126,8 @@ def run_case(a, h, case):
cfg, pair, body, host = rr.host_geometry(a.source, h, a.collision) cfg, pair, body, host = rr.host_geometry(a.source, h, a.collision)
context = stack.enter_context(CudaContext(0)) context = stack.enter_context(CudaContext(0))
backend = stack.enter_context(FixedPatchStepper( backend = stack.enter_context(FixedPatchStepper(
cfg, rr.PLACEMENTS["wide"], context=context, coarse_boundary="channel", cfg, context=context, coarse_boundary="channel", refinements=[rr.PLACEMENTS["wide"]],
base_block=rr.BASE_BLOCK, fine_block=rr.FINE_BLOCK, fine_objects=(body,), level_blocks=[rr.BASE_BLOCK, rr.FINE_BLOCK], level_objects=[(), (body,)],
observe_raw_exchange=True, observe_window_exchange=True)) observe_raw_exchange=True, observe_window_exchange=True))
from CelerisLab.lbm.channel import channel_masks from CelerisLab.lbm.channel import channel_masks
from CelerisLab.lbm.refinement import ACTIVE from CelerisLab.lbm.refinement import ACTIVE
+4 -5
View File
@@ -279,12 +279,11 @@ def run_case(c, ctx, output, provenance, continuation=False):
PeriodicBlockStepper(fine_cfg, layout, context=ctx, objects=[fobj]) as uniform, PeriodicBlockStepper(fine_cfg, layout, context=ctx, objects=[fobj]) as uniform,
FixedPatchStepper( FixedPatchStepper(
cfg, cfg,
c["bounds"],
context=ctx, context=ctx,
base_block=(8, 8), refinements=[c["bounds"]],
fine_block=(8, 8), level_blocks=[(8, 8), (8, 8)],
fine_objects=[obj], level_objects=[(), (obj,)],
jets=jets, level_jets=[(), tuple(jets)],
observe_raw_exchange=True, observe_raw_exchange=True,
) as amr, ) as amr,
): ):
+4 -5
View File
@@ -383,13 +383,12 @@ def run_case(a, h, periodic, case):
backend = stack.enter_context( backend = stack.enter_context(
FixedPatchStepper( FixedPatchStepper(
cfg, cfg,
PLACEMENTS[a.placement],
context=context, context=context,
coarse_boundary="channel", coarse_boundary="channel",
base_block=BASE_BLOCK, refinements=[PLACEMENTS[a.placement]],
fine_block=FINE_BLOCK, level_blocks=[BASE_BLOCK, FINE_BLOCK],
fine_objects=(body,), level_objects=[(), (body,)],
jets=public_jets((80.5, 81.0), 20.0, a.jet_scenario), level_jets=[(), public_jets((80.5, 81.0), 20.0, a.jet_scenario)],
observe_raw_exchange=True, observe_raw_exchange=True,
**({"observe_window_exchange": True} if a.observation_mode == "window" else {}), **({"observe_window_exchange": True} if a.observation_mode == "window" else {}),
) )
+3 -2
View File
@@ -173,8 +173,9 @@ def time_refined(a, h, sched):
cfg, pair, body, host = r.host_geometry(a.source, h, "MRT") cfg, pair, body, host = r.host_geometry(a.source, h, "MRT")
context = stack.enter_context(CudaContext(0)) context = stack.enter_context(CudaContext(0))
backend = stack.enter_context(FixedPatchStepper( backend = stack.enter_context(FixedPatchStepper(
cfg, r.BOUNDS, context=context, coarse_boundary="channel", base_block=r.BASE_BLOCK, cfg, context=context, coarse_boundary="channel", refinements=[r.BOUNDS],
fine_block=r.FINE_BLOCK, fine_objects=(body,), observe_raw_exchange=True)) 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 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)] (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), fresh = (r.initial_state(pair.coarse_shape, (0.0, 0.0), 1.0, root=True),
+2 -2
View File
@@ -130,8 +130,8 @@ def main():
cfg, pair, body, host = r.host_geometry(a.source, h, "MRT") cfg, pair, body, host = r.host_geometry(a.source, h, "MRT")
context = stack.enter_context(CudaContext(0)) context = stack.enter_context(CudaContext(0))
backend = stack.enter_context(FixedPatchStepper( backend = stack.enter_context(FixedPatchStepper(
cfg, r.BOUNDS, context=context, coarse_boundary="channel", base_block=r.BASE_BLOCK, cfg, context=context, coarse_boundary="channel", refinements=[r.BOUNDS],
fine_block=r.FINE_BLOCK, fine_objects=(body,), observe_raw_exchange=True, level_blocks=[r.BASE_BLOCK, r.FINE_BLOCK], level_objects=[(), (body,)], observe_raw_exchange=True,
observe_window_exchange=True)) observe_window_exchange=True))
masks = [channel_masks(pair.coarse_shape)[0] & ~pair.covered, masks = [channel_masks(pair.coarse_shape)[0] & ~pair.covered,
(pair.fine_kind == ACTIVE) & ((host.flags.reshape(pair.fine_shape) & SOLID) == 0)] (pair.fine_kind == ACTIVE) & ((host.flags.reshape(pair.fine_shape) & SOLID) == 0)]