Compare commits
27
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
18f018befe | ||
|
|
ec9b3d721c | ||
|
|
84b76f49cc | ||
|
|
050d12b76c | ||
|
|
ec3e3b928a | ||
|
|
2be80324ad | ||
|
|
0fcd4ac4cb | ||
|
|
af0566db98 | ||
|
|
0b1b3d938f | ||
|
|
5167c79378 | ||
|
|
aedddc35b1 | ||
|
|
7821c6ad71 | ||
|
|
392314e1ae | ||
|
|
f3f1e3d588 | ||
|
|
3648ad70ef | ||
|
|
5399c9c0a6 | ||
|
|
54be33e006 | ||
|
|
750e8a483e | ||
|
|
6a03f463bc | ||
|
|
46dc6ba086 | ||
|
|
e1efc18274 | ||
|
|
9660894a1b | ||
|
|
ba3772e3b8 | ||
|
|
b4692e6ec4 | ||
|
|
5731c5171b | ||
|
|
05de02ee60 | ||
|
|
87c3a3165e |
No files matched your search
@@ -112,8 +112,9 @@ from CelerisLab.lbm.refinement_stepper import FixedPatchStepper
|
|||||||
cfg = LBMConfig(nx=32, ny=24, viscosity=.1)
|
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,
|
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
|
surface_actuation=SurfaceActuation(0.7, 0.85, 0.002)) # angle, half-width, speed
|
||||||
with CudaContext(0) as ctx, FixedPatchStepper(cfg, (8, 6, 24, 18), context=ctx,
|
with CudaContext(0) as ctx, FixedPatchStepper(cfg, context=ctx, refinements=[(8, 6, 24, 18)],
|
||||||
fine_objects=[body], fine_block=(16, 20)) as run:
|
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]
|
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.
|
# (9, ny, nx) postcollision populations per level; non-leaf cells are discarded.
|
||||||
run.initialize(np.broadcast_to(rest, (9, *run.patch.coarse_shape)),
|
run.initialize(np.broadcast_to(rest, (9, *run.patch.coarse_shape)),
|
||||||
@@ -133,19 +134,19 @@ Scope and limits:
|
|||||||
- Bodies must be stationary circles whose whole boundary stencil lies in the fine
|
- 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
|
active region, clear of the coarse/fine transfer cells; violations are rejected
|
||||||
before any GPU allocation.
|
before any GPU allocation.
|
||||||
- `fine_block=(by, bx)` stores the fine level in fixed-size blocks; `by`/`bx` must
|
- `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
|
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
|
four-cell ghost band. It gives results identical to dense storage and is
|
||||||
infrastructure for future block AMR, not a speedup.
|
infrastructure for future block AMR, not a speedup.
|
||||||
- Several regions: pass a sequence of `(x0, y0, x1, y1)` rectangles as
|
- Several regions: pass a sequence of `(x0, y0, x1, y1)` rectangles as
|
||||||
`bounds`, with both `fine_block` and `base_block`. Transfers are built once
|
`refinements[0]`, with both levels blocked (`level_blocks`). Transfers are built once
|
||||||
from their union; adjacent, overlapping and concave unions are accepted when
|
from their union; adjacent, overlapping and concave unions are accepted when
|
||||||
their actual dependencies close. There is no fixed rectangle-gap rule.
|
their actual dependencies close. There is no fixed rectangle-gap rule.
|
||||||
The fine level is then one level-wide grid `(2*ny, 2*nx)`:
|
The fine level is then one level-wide grid `(2*ny, 2*nx)`:
|
||||||
`run.patch.fine_shape` gives it, `initialize`/`download` use it, and only the
|
`run.patch.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.
|
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
|
Block sizes must divide the level-wide grid; rectangle edges need not align
|
||||||
with tiles. Order of rectangles does not matter. `fine_objects`/`jets` work
|
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
|
as for one patch: each circle (same coarse cell-edge frame) must lie wholly
|
||||||
inside the union's active region with
|
inside the union's active region with
|
||||||
its boundary stencil clear of transfer cells; a jet may not select links of two
|
its boundary stencil clear of transfer cells; a jet may not select links of two
|
||||||
@@ -156,8 +157,8 @@ Scope and limits:
|
|||||||
cfg = LBMConfig(nx=32, ny=16, viscosity=.1)
|
cfg = LBMConfig(nx=32, ny=16, viscosity=.1)
|
||||||
rest = np.asarray(compute_feq_d2q9(1.0, 0.0, 0.0), np.float32)[:, None, None]
|
rest = np.asarray(compute_feq_d2q9(1.0, 0.0, 0.0), np.float32)[:, None, None]
|
||||||
with CudaContext(0) as ctx, FixedPatchStepper(
|
with CudaContext(0) as ctx, FixedPatchStepper(
|
||||||
cfg, ((4, 4, 12, 12), (16, 4, 24, 12)), context=ctx,
|
cfg, context=ctx, refinements=[((4, 4, 12, 12), (16, 4, 24, 12))],
|
||||||
fine_block=(4, 4), base_block=(4, 4)) as run:
|
level_blocks=[(4, 4), (4, 4)]) as run:
|
||||||
run.initialize(np.broadcast_to(rest, (9, *run.patch.coarse_shape)),
|
run.initialize(np.broadcast_to(rest, (9, *run.patch.coarse_shape)),
|
||||||
np.broadcast_to(rest, (9, *run.patch.fine_shape))) # (9, 32, 64)
|
np.broadcast_to(rest, (9, *run.patch.fine_shape))) # (9, 32, 64)
|
||||||
run.step(32)
|
run.step(32)
|
||||||
@@ -166,12 +167,12 @@ Scope and limits:
|
|||||||
```
|
```
|
||||||
- Legacy three-level scalar chain: add `child=(x0, y0, x1, y1)` in
|
- Legacy three-level scalar chain: add `child=(x0, y0, x1, y1)` in
|
||||||
**L1 window cells** (the patch's fine grid including its 4-cell ghost band) and
|
**L1 window cells** (the patch's fine grid including its 4-cell ghost band) and
|
||||||
`child_block`, with `fine_block` and `base_block`. L2 must sit inside L1's
|
all three `level_blocks` entries. L2 must sit inside L1's
|
||||||
ACTIVE cells, away from L1's ghost band and transfer footprint (checked before
|
ACTIVE cells, away from L1's ghost band and transfer footprint (checked before
|
||||||
any GPU allocation). `initialize` and `download` take/return three arrays; each
|
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
|
level is NaN on its non-ACTIVE (and child-covered) cells. One coarse step = 2 L1
|
||||||
steps = 4 L2 steps. One L1 patch only. Optional stationary circles and Jets
|
steps = 4 L2 steps. One L1 patch only. Optional stationary circles and Jets
|
||||||
live on L2 via `child_objects` and `child_jets`; `fine_objects`/`jets` retain
|
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
|
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
|
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
|
dx=dt=0.25, so prescribed lattice velocity is unchanged. Each whole body and
|
||||||
@@ -188,9 +189,9 @@ Scope and limits:
|
|||||||
jet = Jet(Tube((6.5, 8.), 0., 3., .3), Parallel(0.), amplitude=.002)
|
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]
|
rest = np.asarray(compute_feq_d2q9(1.0, 0.0, 0.0), np.float32)[:, None, None]
|
||||||
with CudaContext(0) as ctx, FixedPatchStepper(
|
with CudaContext(0) as ctx, FixedPatchStepper(
|
||||||
cfg, (4, 4, 12, 12), context=ctx, fine_block=(4, 4), base_block=(4, 4),
|
cfg, context=ctx, refinements=[(4, 4, 12, 12), (8, 8, 16, 16)],
|
||||||
child=(8, 8, 16, 16), child_block=(4, 4),
|
level_blocks=[(4, 4)] * 3, level_objects=[(), (), (body,)],
|
||||||
child_objects=[body], child_jets=[jet]) as run:
|
level_jets=[(), (), (jet,)]) as run:
|
||||||
shapes = (run.patch.coarse_shape, run.patch.fine_shape, run.child_patch.fine_shape)
|
shapes = (run.patch.coarse_shape, run.patch.fine_shape, run.child_patch.fine_shape)
|
||||||
run.initialize(*(np.broadcast_to(rest, (9, *s)) for s in shapes)) # 16², 24², 24²
|
run.initialize(*(np.broadcast_to(rest, (9, *s)) for s in shapes)) # 16², 24², 24²
|
||||||
run.step(4)
|
run.step(4)
|
||||||
|
|||||||
@@ -0,0 +1,35 @@
|
|||||||
|
# Compatibility and API changes
|
||||||
|
|
||||||
|
Changes that can make a previously accepted setup or call behave differently.
|
||||||
|
Each entry names the commit, the affected entry points and the observable result.
|
||||||
|
|
||||||
|
## 87c3a31: cut-link ownership is validated for every body
|
||||||
|
|
||||||
|
`validate_cut_link_ownership` (`body/preprocess/flag_overlay.py`) now runs for
|
||||||
|
passive bodies as well as Jet/aperture bodies. Every cut link must have an
|
||||||
|
active fluid receiver (FLUID set, SOLID clear), and each `(receiver, direction)`
|
||||||
|
population may have only one writer.
|
||||||
|
|
||||||
|
Rejected with `ValueError`, before flags, populations or device buffers change:
|
||||||
|
|
||||||
|
1. Overlapping or touching passive solids whose cut links write the same
|
||||||
|
population ("Boundary requires unique cut-link writers").
|
||||||
|
2. A body whose cut-link receiver is a non-fluid cell, e.g. a channel wall row
|
||||||
|
or the inlet/outlet column ("Cut links must have active fluid receivers").
|
||||||
|
|
||||||
|
Both were previously accepted silently for passive bodies; the interpolated
|
||||||
|
boundary then had undefined results. The rules apply to the cut links of all
|
||||||
|
bodies together, so a passive body overlapping a Jet body is rejected as well.
|
||||||
|
The check runs in `Simulation.initialize`, runtime body sync (`sync_bodies`),
|
||||||
|
checkpoint save and checkpoint load (`common/checkpoint.py`). Load validates
|
||||||
|
before restoring anything, so a checkpoint whose saved geometry violates either
|
||||||
|
rule no longer restores; rebuild the geometry with separated bodies.
|
||||||
|
|
||||||
|
## 87c3a31: `Simulation.read_surface_exchange` accepts Jet-driven bodies
|
||||||
|
|
||||||
|
`read_surface_exchange(id)` previously required `SurfaceActuation` on the body.
|
||||||
|
It now also accepts bodies that own Jet aperture links, including Jets with zero
|
||||||
|
or negative amplitude (the aperture test is geometric). Bodies with neither
|
||||||
|
`SurfaceActuation` nor aperture links still raise
|
||||||
|
`ValueError("Body has no surface actuation")`. The value is unchanged: the latest
|
||||||
|
step's wall/aperture exchange, not total nozzle force.
|
||||||
@@ -1,6 +1,6 @@
|
|||||||
# Blocked AMR root channel increment
|
# Blocked AMR root channel increment
|
||||||
|
|
||||||
Opt in with `FixedPatchStepper(..., coarse_boundary="channel", base_block=(by,bx), fine_block=(fy,fx))`, or the existing level-list form. 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.
|
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`:
|
`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`:
|
||||||
|
|
||||||
|
|||||||
@@ -16,8 +16,8 @@ Keep the existing scalar `child=(x0,y0,x1,y1)` for a single scalar parent patch.
|
|||||||
Its coordinates retain their original meaning: half-open integer indices in the
|
Its coordinates retain their original meaning: half-open integer indices in the
|
||||||
allocated L1 window, including its ghost band.
|
allocated L1 window, including its ghost band.
|
||||||
|
|
||||||
The new keyword `child_rectangles_in_parent=[...]` is mutually exclusive with
|
A rectangle list as the second `refinements` entry (formerly the keyword
|
||||||
`child`. It accepts a scalar or a set parent and interprets every rectangle in
|
`child_rectangles_in_parent=[...]`) 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
|
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
|
region-local coordinates. The physical root cell edge corresponding to an L1
|
||||||
index `(x,y)` is `parent.fine_origin + (x,y)/2`:
|
index `(x,y)` is `parent.fine_origin + (x,y)/2`:
|
||||||
@@ -47,9 +47,9 @@ tile edges.
|
|||||||
|
|
||||||
```python
|
```python
|
||||||
run = FixedPatchStepper(
|
run = FixedPatchStepper(
|
||||||
cfg, [(4, 4, 20, 28), (24, 4, 44, 28)], context=ctx,
|
cfg, context=ctx,
|
||||||
base_block=(4, 4), fine_block=(4, 4), child_block=(4, 4),
|
refinements=[[(4, 4, 20, 28), (24, 4, 44, 28)], [(16, 16, 32, 40), (56, 16, 80, 40)]],
|
||||||
child_rectangles_in_parent=[(16, 16, 32, 40), (56, 16, 80, 40)],
|
level_blocks=[(4, 4)] * 3,
|
||||||
)
|
)
|
||||||
```
|
```
|
||||||
|
|
||||||
@@ -57,7 +57,7 @@ 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
|
dense arrays. Public arrays and masks still scale with the full allocated
|
||||||
extent; sparse device buffers do not remove that host-memory limit.
|
extent; sparse device buffers do not remove that host-memory limit.
|
||||||
|
|
||||||
Stationary whole-circle `child_objects` and `child_jets` use root edge
|
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
|
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
|
positions, not region IDs or caller `obj_id`. Complete boundary stencils must
|
||||||
avoid the transfer footprint. Change a child Jet with
|
avoid the transfer footprint. Change a child Jet with
|
||||||
|
|||||||
@@ -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`.
|
||||||
@@ -56,3 +56,62 @@ Root must independently review and admit any execution. An admitted paired pilot
|
|||||||
the existing watchdog, device selection, `--gpu-gates-approved`, positive
|
the existing watchdog, device selection, `--gpu-gates-approved`, positive
|
||||||
`--max-wall-seconds` and a new output directory, adding only `--exchange-window` to the
|
`--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.
|
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.
|
||||||
@@ -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.
|
||||||
|
|||||||
@@ -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
|
||||||
|
|||||||
@@ -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)
|
||||||
|
|||||||
@@ -216,11 +216,8 @@ def surface_link_velocity(objects, cfg, flags, fluid_idx, dir, body_id, rx, ry,
|
|||||||
enabled = [obj for obj in objects if obj.surface_actuation is not None]
|
enabled = [obj for obj in objects if obj.surface_actuation is not None]
|
||||||
if not enabled and not jets:
|
if not enabled and not jets:
|
||||||
return None, None
|
return None, None
|
||||||
from ..lbm.descriptors import FLUID, SOLID
|
from .preprocess.flag_overlay import validate_cut_link_ownership
|
||||||
if np.any((flags[fluid_idx] & FLUID) == 0) or np.any(flags[fluid_idx] & SOLID):
|
validate_cut_link_ownership(flags, fluid_idx, dir, cfg.nq)
|
||||||
raise ValueError("Surface cut links must have active fluid receivers")
|
|
||||||
if len(np.unique(fluid_idx.astype(np.uint64)*cfg.nq+dir)) != len(dir):
|
|
||||||
raise ValueError("Surface boundary requires unique cut-link writers")
|
|
||||||
surface_velocity = np.zeros((len(dir), 2), np.float32)
|
surface_velocity = np.zeros((len(dir), 2), np.float32)
|
||||||
surface_aperture = np.zeros(len(dir), bool)
|
surface_aperture = np.zeros(len(dir), bool)
|
||||||
for obj in enabled:
|
for obj in enabled:
|
||||||
|
|||||||
@@ -27,7 +27,7 @@ import pycuda.driver as cuda
|
|||||||
|
|
||||||
from .objects import SimObject
|
from .objects import SimObject
|
||||||
from .registry import BodyRegistry
|
from .registry import BodyRegistry
|
||||||
from .preprocess.flag_overlay import merge_flag_masks
|
from .preprocess.flag_overlay import merge_flag_masks, validate_cut_link_ownership
|
||||||
from ..cuda.compiler_v2 import obs_layout
|
from ..cuda.compiler_v2 import obs_layout
|
||||||
from ..cuda.obs_layout import ObsLayout
|
from ..cuda.obs_layout import ObsLayout
|
||||||
from ..lbm.descriptors import (
|
from ..lbm.descriptors import (
|
||||||
@@ -369,9 +369,9 @@ class ObjectManager:
|
|||||||
|
|
||||||
Args:
|
Args:
|
||||||
objects: List of SimObject instances to process.
|
objects: List of SimObject instances to process.
|
||||||
domain_flags: Optional uint16 flags for donor-cell classification.
|
domain_flags: Optional uint16 flags for receiver/donor classification.
|
||||||
sensor_cell_counts_out: Int array to fill with per-object sensor
|
sensor_cell_counts_out: Int array to fill with per-object sensor
|
||||||
cell counts. If provided, ``fill(0)`` is called first.
|
cell counts after the full geometry has passed validation.
|
||||||
hits_out: List that receives one FP64 (n, 2) array of true hit
|
hits_out: List that receives one FP64 (n, 2) array of true hit
|
||||||
points row-aligned with the cut-link columns (for Jets).
|
points row-aligned with the cut-link columns (for Jets).
|
||||||
|
|
||||||
@@ -394,8 +394,8 @@ class ObjectManager:
|
|||||||
active_fluid = ((domain_flags & FLUID) != 0) & ((domain_flags & SOLID) == 0)
|
active_fluid = ((domain_flags & FLUID) != 0) & ((domain_flags & SOLID) == 0)
|
||||||
force_owners: set[int] = set()
|
force_owners: set[int] = set()
|
||||||
|
|
||||||
if sensor_cell_counts_out is not None:
|
sensor_counts = (np.zeros_like(sensor_cell_counts_out)
|
||||||
sensor_cell_counts_out.fill(0)
|
if sensor_cell_counts_out is not None else None)
|
||||||
|
|
||||||
ez = None
|
ez = None
|
||||||
if self.cfg and self.cfg.is_d3q19:
|
if self.cfg and self.cfg.is_d3q19:
|
||||||
@@ -430,9 +430,9 @@ class ObjectManager:
|
|||||||
if len(cells) > 0:
|
if len(cells) > 0:
|
||||||
s_cells.append(cells)
|
s_cells.append(cells)
|
||||||
s_ids.append(ids)
|
s_ids.append(ids)
|
||||||
if (sensor_cell_counts_out is not None
|
if (sensor_counts is not None
|
||||||
and 0 <= obj.obj_id < sensor_cell_counts_out.size):
|
and 0 <= obj.obj_id < sensor_counts.size):
|
||||||
sensor_cell_counts_out[obj.obj_id] = int(len(cells))
|
sensor_counts[obj.obj_id] = int(len(cells))
|
||||||
if obj.is_force_region and hasattr(obj, 'get_sensor_list'):
|
if obj.is_force_region and hasattr(obj, 'get_sensor_list'):
|
||||||
cells, ids = obj.get_sensor_list(self.nx, self.ny, self.nz)
|
cells, ids = obj.get_sensor_list(self.nx, self.ny, self.nz)
|
||||||
keep = active_fluid[cells]
|
keep = active_fluid[cells]
|
||||||
@@ -461,8 +461,9 @@ class ObjectManager:
|
|||||||
r_fr_ids = np.concatenate(fr_ids) if fr_ids else np.zeros(0, dtype=np.int32)
|
r_fr_ids = np.concatenate(fr_ids) if fr_ids else np.zeros(0, dtype=np.int32)
|
||||||
|
|
||||||
r_hit = np.concatenate(cl_hit) if cl_hit else np.zeros((0, 2))
|
r_hit = np.concatenate(cl_hit) if cl_hit else np.zeros((0, 2))
|
||||||
if hits_out is not None:
|
# Passive walls need the same ownership guarantees as driven walls.
|
||||||
hits_out.append(r_hit)
|
# Overlapping solids are not a supported union-boundary operation.
|
||||||
|
validate_cut_link_ownership(domain_flags, r_idx, r_dir, self.nq)
|
||||||
if self.jets or any(obj.surface_actuation is not None for obj in objects):
|
if self.jets or any(obj.surface_actuation is not None for obj in objects):
|
||||||
# Reject unresolved apertures/ownership before sync or restart mutates state.
|
# Reject unresolved apertures/ownership before sync or restart mutates state.
|
||||||
from ..lbm.curved_links import CurvedLinkSoA
|
from ..lbm.curved_links import CurvedLinkSoA
|
||||||
@@ -470,6 +471,11 @@ class ObjectManager:
|
|||||||
links.assign_host(r_idx, r_dir, r_q, r_bid, r_rx, r_ry, r_rz, r_fallback)
|
links.assign_host(r_idx, r_dir, r_q, r_bid, r_rx, r_ry, r_rz, r_fallback)
|
||||||
links.assign_surface(objects, self.cfg, domain_flags, jets=self.jets, hits=r_hit)
|
links.assign_surface(objects, self.cfg, domain_flags, jets=self.jets, hits=r_hit)
|
||||||
|
|
||||||
|
if sensor_cell_counts_out is not None:
|
||||||
|
sensor_cell_counts_out[:] = sensor_counts
|
||||||
|
if hits_out is not None:
|
||||||
|
hits_out.append(r_hit)
|
||||||
|
|
||||||
return (
|
return (
|
||||||
r_idx, r_dir, r_q, r_bid,
|
r_idx, r_dir, r_q, r_bid,
|
||||||
r_rx, r_ry, r_rz, r_fallback,
|
r_rx, r_ry, r_rz, r_fallback,
|
||||||
@@ -487,8 +493,6 @@ class ObjectManager:
|
|||||||
the caller has already prepared and uploaded the final flag field
|
the caller has already prepared and uploaded the final flag field
|
||||||
for this geometry, such as during initialization.
|
for this geometry, such as during initialization.
|
||||||
"""
|
"""
|
||||||
self._telemetry_field = field
|
|
||||||
|
|
||||||
next_flags = self.build_flags(field.build_channel_flags()) if rebuild_flags else field.flag
|
next_flags = self.build_flags(field.build_channel_flags()) if rebuild_flags else field.flag
|
||||||
hits = []
|
hits = []
|
||||||
|
|
||||||
@@ -499,6 +503,7 @@ class ObjectManager:
|
|||||||
fr_cells, fr_obj_id,
|
fr_cells, fr_obj_id,
|
||||||
) = self.build_compact_lists(domain_flags=next_flags, hits_out=hits)
|
) = self.build_compact_lists(domain_flags=next_flags, hits_out=hits)
|
||||||
|
|
||||||
|
self._telemetry_field = field
|
||||||
if rebuild_flags:
|
if rebuild_flags:
|
||||||
field.flag = next_flags
|
field.flag = next_flags
|
||||||
field.upload_flags()
|
field.upload_flags()
|
||||||
|
|||||||
@@ -1,6 +1,6 @@
|
|||||||
# CelerisLab/body/preprocess/flag_overlay.py
|
# CelerisLab/body/preprocess/flag_overlay.py
|
||||||
"""
|
"""
|
||||||
Flag overlay: merge per-object flag masks onto a clean domain base.
|
Flag overlay and cut-link ownership checks against the merged domain.
|
||||||
"""
|
"""
|
||||||
|
|
||||||
from __future__ import annotations
|
from __future__ import annotations
|
||||||
@@ -12,6 +12,15 @@ import numpy as np
|
|||||||
from ...lbm.descriptors import FLUID, SOLID, SENSOR_FLAG, FRC_REGION
|
from ...lbm.descriptors import FLUID, SOLID, SENSOR_FLAG, FRC_REGION
|
||||||
|
|
||||||
|
|
||||||
|
def validate_cut_link_ownership(flags, fluid_idx, directions, nq):
|
||||||
|
"""Reject solid receivers and multiple writers to one population."""
|
||||||
|
if np.any((flags[fluid_idx] & FLUID) == 0) or np.any(flags[fluid_idx] & SOLID):
|
||||||
|
raise ValueError("Cut links must have active fluid receivers")
|
||||||
|
writers = fluid_idx.astype(np.uint64) * nq + directions
|
||||||
|
if len(np.unique(writers)) != len(directions):
|
||||||
|
raise ValueError("Boundary requires unique cut-link writers")
|
||||||
|
|
||||||
|
|
||||||
def merge_flag_masks(
|
def merge_flag_masks(
|
||||||
base: np.ndarray,
|
base: np.ndarray,
|
||||||
masks: List[np.ndarray],
|
masks: List[np.ndarray],
|
||||||
|
|||||||
@@ -204,11 +204,21 @@ class PeriodicBlockStepper:
|
|||||||
raise
|
raise
|
||||||
|
|
||||||
def step(self, n=1):
|
def step(self, n=1):
|
||||||
"""Advance n steps: halo refresh, then core pull/collide, per step."""
|
"""Advance n steps: halo refresh, then core pull/collide, per step.
|
||||||
|
|
||||||
|
All n steps are enqueued in order on the one stream and the host waits
|
||||||
|
once before returning (same launches and bits as n step(1) calls).
|
||||||
|
Asynchronous device errors surface at that single wait, so they are not
|
||||||
|
attributed to the step that caused them; call step(1) repeatedly to
|
||||||
|
localize one. On any failure the instance is failed and step_count keeps
|
||||||
|
its entry value.
|
||||||
|
"""
|
||||||
if isinstance(n, bool) or not isinstance(n, Integral) or n < 0:
|
if isinstance(n, bool) or not isinstance(n, Integral) or n < 0:
|
||||||
raise ValueError("n must be a nonnegative integer")
|
raise ValueError("n must be a nonnegative integer")
|
||||||
with self._lock, self.ctx.activate():
|
with self._lock, self.ctx.activate():
|
||||||
self._require("ready")
|
self._require("ready")
|
||||||
|
if n == 0:
|
||||||
|
return
|
||||||
kw = dict(block=self._block, stream=self._stream)
|
kw = dict(block=self._block, stream=self._stream)
|
||||||
try:
|
try:
|
||||||
self._status = "advancing"
|
self._status = "advancing"
|
||||||
@@ -224,9 +234,9 @@ class PeriodicBlockStepper:
|
|||||||
self._step(self._current, self._spare, np.uint32(self.layout.halo),
|
self._step(self._current, self._spare, np.uint32(self.layout.halo),
|
||||||
self._tables.get("flags", np.uintp(0)), np.uintp(0), # no kind
|
self._tables.get("flags", np.uintp(0)), np.uintp(0), # no kind
|
||||||
grid=self._grid, **kw)
|
grid=self._grid, **kw)
|
||||||
self._stream.synchronize()
|
self._current, self._spare = self._spare, self._current # host handles only
|
||||||
self._current, self._spare = self._spare, self._current
|
self._stream.synchronize()
|
||||||
self._step_count += 1
|
self._step_count += n
|
||||||
self._status = "ready"
|
self._status = "ready"
|
||||||
except BaseException:
|
except BaseException:
|
||||||
self._status = "failed"
|
self._status = "failed"
|
||||||
|
|||||||
@@ -65,52 +65,8 @@ def _level_name(level):
|
|||||||
return ("base", "fine", "child")[level] if level < 3 else f"level {level}"
|
return ("base", "fine", "child")[level] if level < 3 else f"level {level}"
|
||||||
|
|
||||||
|
|
||||||
def _legacy_levels(bounds, *, fine_block, base_block, child, child_block, child_rectangles_in_parent,
|
|
||||||
fine_objects, jets, child_objects, child_jets):
|
|
||||||
"""Normalise the original two/three-level keywords to per-level lists (original errors)."""
|
|
||||||
if child is not None and child_rectangles_in_parent is not None:
|
|
||||||
raise ValueError("child and child_rectangles_in_parent are mutually exclusive")
|
|
||||||
nested = child is not None or child_rectangles_in_parent is not None
|
|
||||||
bounds = tuple(bounds)
|
|
||||||
if not is_rectangle(bounds) and (fine_block is None or base_block is None):
|
|
||||||
raise ValueError("several patches require fine_block and base_block")
|
|
||||||
fine_objects, jets = tuple(fine_objects), tuple(jets)
|
|
||||||
child_objects, child_jets = tuple(child_objects), tuple(child_jets)
|
|
||||||
if not nested and (child_objects or child_jets):
|
|
||||||
raise ValueError("child_objects/child_jets require a nested child")
|
|
||||||
if base_block is not None and fine_block is None:
|
|
||||||
raise ValueError("base_block requires fine_block")
|
|
||||||
refinements, blocks = [bounds], [base_block, fine_block]
|
|
||||||
objects, level_jets = [(), fine_objects], [(), jets]
|
|
||||||
if nested:
|
|
||||||
if child is not None and not is_rectangle(bounds):
|
|
||||||
raise ValueError("scalar child requires one parent patch; use child_rectangles_in_parent")
|
|
||||||
if fine_block is None or base_block is None or child_block is None:
|
|
||||||
raise ValueError("a nested child needs fine_block, base_block and child_block")
|
|
||||||
if fine_objects or jets:
|
|
||||||
raise ValueError("a nested child supports bodies/Jets only on L2; use child_objects/child_jets")
|
|
||||||
refinements.append(tuple(child) if child is not None else tuple(child_rectangles_in_parent))
|
|
||||||
blocks.append(child_block)
|
|
||||||
objects.append(child_objects)
|
|
||||||
level_jets.append(child_jets)
|
|
||||||
return refinements, blocks, objects, level_jets
|
|
||||||
|
|
||||||
|
|
||||||
def _initial_levels(level_g, coarse_g, fine_g, child_g):
|
|
||||||
"""One tuple of per-level arrays from initialize()'s positional or legacy named form."""
|
|
||||||
if coarse_g is None and fine_g is None:
|
|
||||||
if child_g is not None and len(level_g) != 2:
|
|
||||||
raise TypeError("child_g needs exactly the coarse and fine arrays before it")
|
|
||||||
return tuple(level_g) + (() if child_g is None else (child_g,))
|
|
||||||
if level_g:
|
|
||||||
raise TypeError("pass level arrays positionally or as coarse_g/fine_g/child_g, not both")
|
|
||||||
if coarse_g is None or fine_g is None:
|
|
||||||
raise TypeError("coarse_g and fine_g are both required in the named form")
|
|
||||||
return (coarse_g, fine_g) + (() if child_g is None else (child_g,))
|
|
||||||
|
|
||||||
|
|
||||||
def _check_levels(refinements, blocks, objects, jets):
|
def _check_levels(refinements, blocks, objects, jets):
|
||||||
"""Candidate limits shared by the list and the legacy entry points."""
|
"""Candidate limits of the level lists, checked before any device work."""
|
||||||
depth = len(refinements) + 1
|
depth = len(refinements) + 1
|
||||||
if depth < 2:
|
if depth < 2:
|
||||||
raise ValueError("at least one refinement level is required")
|
raise ValueError("at least one refinement level is required")
|
||||||
@@ -134,7 +90,14 @@ def _check_levels(refinements, blocks, objects, jets):
|
|||||||
|
|
||||||
|
|
||||||
class FixedPatchStepper:
|
class FixedPatchStepper:
|
||||||
"""D2Q9/SRT/FP32, one unforced internal 2:1 patch in an x-periodic box.
|
"""D2Q9 SRT/MRT FP32 fixed 2:1 refinement hierarchy, built from level lists.
|
||||||
|
|
||||||
|
``refinements[l]`` gives level l+1 in level-l integer cells: one rectangle
|
||||||
|
(x0, y0, x1, y1) (FixedPatch2D, a fine window with its own origin) or a
|
||||||
|
sequence of rectangles (FixedPatchSet2D, a dependency-validated union on one
|
||||||
|
level-wide grid, public fine arrays (2*ny, 2*nx), NaN outside ACTIVE cells);
|
||||||
|
see lbm.hierarchy. ``level_blocks``, ``level_objects`` and ``level_jets``
|
||||||
|
hold one entry per level, L0 included (L0 bodies/Jets are not supported).
|
||||||
|
|
||||||
``coarse_boundary`` is ``periodic`` (default) or ``slot_reservoir``:
|
``coarse_boundary`` is ``periodic`` (default) or ``slot_reservoir``:
|
||||||
a bottom on-site slot and top fixed-density reservoir from ``cfg``.
|
a bottom on-site slot and top fixed-density reservoir from ``cfg``.
|
||||||
@@ -145,68 +108,53 @@ class FixedPatchStepper:
|
|||||||
actual channel closure footprint. Channel remapping is not supported.
|
actual channel closure footprint. Channel remapping is not supported.
|
||||||
Periodic mode does not apply the wall/slot boundary fields in ``cfg``.
|
Periodic mode does not apply the wall/slot boundary fields in ``cfg``.
|
||||||
Outer walls remain coarse; fine halo donors must be ordinary fluid.
|
Outer walls remain coarse; fine halo donors must be ordinary fluid.
|
||||||
``fine_objects`` accepts fixed circles in coarse physical coordinates;
|
|
||||||
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
|
Bodies are fixed circles in root (L0) physical coordinates; velocities are
|
||||||
already in postcollision phase. It does not collide or build channel flags.
|
in root lattice units (dx=dt=1). Independent local copies are projected at
|
||||||
Every ``step()`` publishes only after both levels complete on one stream.
|
fine cell centers; their complete stencil must be active and disjoint from
|
||||||
On a device/launch failure the instance becomes unusable: close and recreate
|
the actual two-hop transfer footprint. These use the edge/cell-center frame
|
||||||
it, rather than pretending the partially advanced fine buffer rolled back.
|
(coarse centers I+.5), whereas ordinary Simulation objects use the
|
||||||
|
integer-node frame. Jets (body.jets.Jet) use the same frame and drive cut
|
||||||
|
links selected at their true hits; ``set_jet_amplitude(index, amplitude,
|
||||||
|
level=l)`` re-uploads the per-link velocity column only.
|
||||||
|
|
||||||
|
``initialize(*level_g)`` accepts one physical Q-major (9, ny, nx) array per
|
||||||
|
level, already in postcollision phase. It does not collide or build channel
|
||||||
|
flags. Every ``step()`` publishes only after all levels complete on one
|
||||||
|
stream. On a device/launch failure the instance becomes unusable: close and
|
||||||
|
recreate it, rather than pretending a partially advanced buffer rolled back.
|
||||||
|
|
||||||
|
A ``level_blocks`` entry (by, bx) stores that level in blocks.cu storage:
|
||||||
|
the ENTIRE level shape, including the four-cell patch ghost band, is
|
||||||
|
partitioned by a non-periodic BlockLayout2D with one-cell same-level halos.
|
||||||
|
Patch kinds stay per cell (OUTER invalid, INNER stream only, ACTIVE
|
||||||
|
collide); halos are gathered before each hop. Public arrays keep the dense
|
||||||
|
shapes; only the allocation differs. A blocked level requires blocked
|
||||||
|
refined levels below it; several L1 rectangles and depth >= 3 require all
|
||||||
|
levels blocked. Blocked bodies are stationary circles, optionally
|
||||||
|
surface-actuated: prepare_fine_boundary decides legality on the dense grid,
|
||||||
|
then cut links are staged receiver-local per hop: halo -> BFL -> step, same
|
||||||
|
buffer. A blocked parent gathers halos before receiver-local coalescence
|
||||||
|
staging and pull/collision; covered cells are poisoned on every step.
|
||||||
|
|
||||||
``fine_block=(by, bx)`` (opt-in) stores the fine level in
|
|
||||||
blocks.cu storage: the ENTIRE fine_shape, including the four-cell patch
|
|
||||||
ghost band, is partitioned by a non-periodic BlockLayout2D with one-cell
|
|
||||||
same-level halos. Patch kinds stay per cell (OUTER invalid, INNER stream
|
|
||||||
only, ACTIVE collide); halos are gathered before each fine hop. Public
|
|
||||||
arrays keep the dense (9, ny, nx) fine shape; only the allocation differs.
|
|
||||||
Blocked fine_objects are stationary circles, optionally surface-actuated:
|
|
||||||
prepare_fine_boundary decides legality on the dense fine grid, then cut
|
|
||||||
links are staged receiver-local per hop: halo -> BFL -> step, same buffer.
|
|
||||||
``base_block=(by, bx)`` also blocks the parent; it requires ``fine_block``.
|
|
||||||
Parent halos precede receiver-local coalescence staging and pull/collision;
|
|
||||||
covered cells are explicitly poisoned on every step. Public shapes stay dense.
|
|
||||||
``observe_raw_exchange=True`` records blocked physical cut-link exchange
|
``observe_raw_exchange=True`` records blocked physical cut-link exchange
|
||||||
without changing populations. read_raw_exchange reports the last complete
|
without changing populations. read_raw_exchange reports the last complete
|
||||||
base interval or last substep in base-lattice units per unit depth. This
|
base interval or last substep in base-lattice units per unit depth. This
|
||||||
is boundary momentum reaction, not a validated nozzle/stress load. Dense
|
is boundary momentum reaction, not a validated nozzle/stress load. Dense
|
||||||
body layouts are not supported by this new diagnostic in this candidate.
|
body levels are not supported by this diagnostic.
|
||||||
``observe_window_exchange=True`` (requires observe_raw_exchange) adds a second
|
``observe_window_exchange=True`` (requires observe_raw_exchange) adds a second
|
||||||
per-link FP64 ledger accumulated by the same kernel between
|
per-link FP64 ledger accumulated by the same kernel between
|
||||||
start_exchange_window() and read_exchange_window(); disabled by default.
|
start_exchange_window() and read_exchange_window(); disabled by default.
|
||||||
``jets`` (body.jets.Jet) use the same edge frame as ``fine_objects`` and
|
|
||||||
drive fine cut links selected at their true hits; ``set_jet_amplitude``
|
|
||||||
re-uploads the per-link velocity column only.
|
|
||||||
|
|
||||||
Several patches: pass ``bounds`` as a sequence of (x0, y0, x1, y1)
|
Nested levels: a child set's coordinates index the allocated parent array,
|
||||||
rectangles (FixedPatchSet2D, dependency-validated union). This requires
|
including ghost bands and holes: root edge = parent fine_origin + index / 2
|
||||||
fine_block and base_block; fine_objects/jets are projected once onto the
|
(zero origin for a parent set; a scalar parent keeps its shifted window
|
||||||
level-wide fine grid (each circle inside the union, body ids = object
|
origin). A scalar child requires a scalar parent. Each pair requires gap >= 4
|
||||||
positions, jet and writer checks level-wide), and
|
in its own parent-cell units. All regions share one buffer pair per level
|
||||||
uses one level-wide fine grid (2*ny, 2*nx): public fine arrays have that
|
and the fixed schedule of 2**l hops per base step at level l. Bodies/Jets are supported only on the
|
||||||
shape, NaN outside the patches' ACTIVE cells. The step sequence is the
|
finest level of a nested hierarchy (L2 dx=dt=.25 in root units, unchanged
|
||||||
blocked one above, with unique union transfers in one launch each.
|
lattice velocity); every whole circle and its BFL stencil must fit strictly
|
||||||
|
away from that level's transfer footprint.
|
||||||
Three-level separated unions: ``child_rectangles_in_parent=[...]`` is
|
|
||||||
mutually exclusive with scalar ``child`` and accepts either parent form.
|
|
||||||
Coordinates index the allocated L1 array, including ghost bands and holes:
|
|
||||||
root edge = patch.fine_origin + L1 index / 2. A parent set has origin zero;
|
|
||||||
a scalar parent retains its shifted window origin. The child set's public
|
|
||||||
extent is twice the allocated L1 shape, even though storage is sparse.
|
|
||||||
Each pair requires gap >= 4 in its own parent-cell units. All regions share
|
|
||||||
one buffer pair per level and the fixed 1:2:4 schedule; L2-only bodies/Jets
|
|
||||||
below apply unchanged, with object IDs assigned over the whole level.
|
|
||||||
|
|
||||||
Three-level single chain: ``child`` bounds use L1 window cells; all three
|
|
||||||
levels must be blocked. ``child_objects`` and ``child_jets`` use the L0
|
|
||||||
edge frame, with L2 dx=dt=.25 and unchanged lattice velocity. L1 bodies
|
|
||||||
and Jets remain unsupported in a chain. Every whole circle and its BFL
|
|
||||||
stencil must fit strictly away from the L2 transfer footprint. L2 runs
|
|
||||||
halo -> BFL -> step four times per base step. Runtime child Jet changes
|
|
||||||
require ``set_jet_amplitude(index, amplitude, level=2)``.
|
|
||||||
|
|
||||||
``explosion="projected_linear"`` selects experimental transverse linear
|
``explosion="projected_linear"`` selects experimental transverse linear
|
||||||
reconstruction on each adjacent pair. Default "constant" is unchanged.
|
reconstruction on each adjacent pair. Default "constant" is unchanged.
|
||||||
@@ -214,43 +162,21 @@ class FixedPatchStepper:
|
|||||||
bodies/Jets or LES; this backend supplies no forcing. Geometry is generic,
|
bodies/Jets or LES; this backend supplies no forcing. Geometry is generic,
|
||||||
but union/multilevel GPU and matched-physics qualification remain pending.
|
but union/multilevel GPU and matched-physics qualification remain pending.
|
||||||
|
|
||||||
Level lists (any depth): ``refinements[l]`` gives level l+1 in level-l
|
One recursive hop advances every level: a child explodes from its parent's
|
||||||
integer cells (scalar window or rectangle list, see lbm.hierarchy);
|
current hop source, takes two hops, then the parent gathers halos, stages
|
||||||
``level_blocks``/``level_objects``/``level_jets`` hold one entry per level,
|
restriction, applies BFL and steps.
|
||||||
L0 included. They are mutually exclusive with the legacy keywords above,
|
|
||||||
which are normalised to the same lists. One recursive hop advances every
|
|
||||||
level: a child explodes from its parent's current hop source, takes two
|
|
||||||
hops, then the parent gathers halos, stages restriction, applies BFL and
|
|
||||||
steps. Depth >= 3 must be fully blocked with bodies/Jets on the finest level.
|
|
||||||
"""
|
"""
|
||||||
def __init__(self, cfg, bounds=None, *, context, coarse_boundary="periodic", fine_objects=(),
|
def __init__(self, cfg, *, context, refinements, coarse_boundary="periodic",
|
||||||
fine_block=None, base_block=None, jets=(), child=None, child_block=None,
|
level_blocks=None, level_objects=None, level_jets=None,
|
||||||
child_objects=(), child_jets=(), child_rectangles_in_parent=None,
|
|
||||||
refinements=None, level_blocks=None, level_objects=None, level_jets=None,
|
|
||||||
observe_raw_exchange=False, observe_window_exchange=False, explosion="constant"):
|
observe_raw_exchange=False, observe_window_exchange=False, explosion="constant"):
|
||||||
if HALO != 4:
|
if HALO != 4:
|
||||||
raise RuntimeError("refinement.cu requires a four-cell fine halo")
|
raise RuntimeError("refinement.cu requires a four-cell fine halo")
|
||||||
if coarse_boundary not in ("periodic", "slot_reservoir", "channel"):
|
if coarse_boundary not in ("periodic", "slot_reservoir", "channel"):
|
||||||
raise ValueError("coarse_boundary must be periodic, slot_reservoir or channel")
|
raise ValueError("coarse_boundary must be periodic, slot_reservoir or channel")
|
||||||
if refinements is None:
|
depth = len(refinements) + 1
|
||||||
if bounds is None:
|
level_blocks = [None] * depth if level_blocks is None else list(level_blocks)
|
||||||
raise ValueError("bounds or refinements is required")
|
level_objects = [()] * depth if level_objects is None else list(level_objects)
|
||||||
if level_blocks is not None or level_objects is not None or level_jets is not None:
|
level_jets = [()] * depth if level_jets is None else list(level_jets)
|
||||||
raise ValueError("level_blocks/level_objects/level_jets require refinements")
|
|
||||||
refinements, level_blocks, level_objects, level_jets = _legacy_levels(
|
|
||||||
bounds, fine_block=fine_block, base_block=base_block, child=child,
|
|
||||||
child_block=child_block, child_rectangles_in_parent=child_rectangles_in_parent,
|
|
||||||
fine_objects=fine_objects, jets=jets, child_objects=child_objects,
|
|
||||||
child_jets=child_jets)
|
|
||||||
else:
|
|
||||||
if (bounds is not None or child is not None or child_rectangles_in_parent is not None
|
|
||||||
or fine_block is not None or base_block is not None or child_block is not None
|
|
||||||
or tuple(fine_objects) or tuple(jets) or tuple(child_objects) or tuple(child_jets)):
|
|
||||||
raise ValueError("refinements and the legacy patch keywords are mutually exclusive")
|
|
||||||
depth = len(refinements) + 1
|
|
||||||
level_blocks = [None] * depth if level_blocks is None else list(level_blocks)
|
|
||||||
level_objects = [()] * depth if level_objects is None else list(level_objects)
|
|
||||||
level_jets = [()] * depth if level_jets is None else list(level_jets)
|
|
||||||
level_objects = [tuple(o) for o in level_objects]
|
level_objects = [tuple(o) for o in level_objects]
|
||||||
level_jets = [tuple(j) for j in level_jets]
|
level_jets = [tuple(j) for j in level_jets]
|
||||||
level_blocks = [None if b is None else tuple(b) for b in level_blocks]
|
level_blocks = [None if b is None else tuple(b) for b in level_blocks]
|
||||||
@@ -540,13 +466,13 @@ class FixedPatchStepper:
|
|||||||
if self._ddf_shifting and any(layout is None for layout in self._layouts):
|
if self._ddf_shifting and any(layout is None for layout in self._layouts):
|
||||||
raise ValueError("shifted populations require all-blocked levels")
|
raise ValueError("shifted populations require all-blocked levels")
|
||||||
|
|
||||||
def initialize(self, *level_g, coarse_g=None, fine_g=None, child_g=None):
|
def initialize(self, *level_g):
|
||||||
"""Upload physical postcollision G, encoding before any FP32 rounding.
|
"""Upload physical postcollision G, encoding before any FP32 rounding.
|
||||||
|
|
||||||
Shifted input should be physical FP64 to retain small perturbations.
|
Shifted input should be physical FP64 to retain small perturbations.
|
||||||
Public initialization resets the step count; non-leaves are discarded.
|
Public initialization resets the step count; non-leaves are discarded.
|
||||||
"""
|
"""
|
||||||
given = _initial_levels(level_g, coarse_g, fine_g, child_g)
|
given = tuple(level_g)
|
||||||
with self._lock, self.ctx.activate():
|
with self._lock, self.ctx.activate():
|
||||||
self._require("new", "ready")
|
self._require("new", "ready")
|
||||||
self._check_storage()
|
self._check_storage()
|
||||||
@@ -670,10 +596,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:
|
||||||
|
|||||||
@@ -336,13 +336,19 @@ class Simulation:
|
|||||||
def read_surface_exchange(self, id: int):
|
def read_surface_exchange(self, id: int):
|
||||||
"""Latest step's wall/aperture (Fx,Fy,Tz) exchange, not total nozzle force.
|
"""Latest step's wall/aperture (Fx,Fy,Tz) exchange, not total nozzle force.
|
||||||
|
|
||||||
|
Supports SurfaceActuation and Jet-driven bodies, including zero-amplitude
|
||||||
|
apertures. Passive bodies without an aperture are rejected.
|
||||||
Unlike read_body this is not accumulated/time-averaged. It resets after
|
Unlike read_body this is not accumulated/time-averaged. It resets after
|
||||||
geometry sync or checkpoint load; advance before interpreting it.
|
geometry sync or checkpoint load; advance before interpreting it.
|
||||||
"""
|
"""
|
||||||
if self.bodies.get(id).surface_actuation is None:
|
obj = self.bodies.get(id)
|
||||||
|
curved = self.field.curved
|
||||||
|
has_aperture = (curved.aperture is not None
|
||||||
|
and np.any(curved.aperture & (curved.body_id == id)))
|
||||||
|
if obj.surface_actuation is None and not has_aperture:
|
||||||
raise ValueError("Body has no surface actuation")
|
raise ValueError("Body has no surface actuation")
|
||||||
self.stream.synchronize()
|
self.stream.synchronize()
|
||||||
return self.field.curved.surface_exchange(id)
|
return curved.surface_exchange(id)
|
||||||
|
|
||||||
@context_bound
|
@context_bound
|
||||||
def read_body(self, id: int, *,
|
def read_body(self, id: int, *,
|
||||||
@@ -451,18 +457,21 @@ class Simulation:
|
|||||||
@context_bound
|
@context_bound
|
||||||
def initialize(self):
|
def initialize(self):
|
||||||
"""Initialize flow field and sync objects to GPU."""
|
"""Initialize flow field and sync objects to GPU."""
|
||||||
# Recompile if objects were added after construction.
|
|
||||||
self._assert_allocation_contract()
|
self._assert_allocation_contract()
|
||||||
|
# Validate the complete geometry before flags, populations or modules
|
||||||
|
# change. Compact-list construction publishes no outputs on failure.
|
||||||
|
next_flags = self.bodies.build_flags(self.field.build_channel_flags())
|
||||||
|
if self.bodies.jets and self.bodies.count == 0:
|
||||||
|
raise ValueError("Jets need bodies with cut links")
|
||||||
|
self.bodies.build_compact_lists_for(self.bodies.objects, next_flags)
|
||||||
|
|
||||||
|
# Recompile if objects were added after construction.
|
||||||
if self._read_generated_n_objects() != self.bodies.count:
|
if self._read_generated_n_objects() != self.bodies.count:
|
||||||
self.recompile()
|
self.recompile()
|
||||||
|
|
||||||
self.field.flag = self.field.build_channel_flags()
|
self.field.flag = next_flags
|
||||||
if self.bodies.count > 0:
|
|
||||||
self.field.flag = self.bodies.build_flags(self.field.flag)
|
|
||||||
self.field.upload_flags()
|
self.field.upload_flags()
|
||||||
|
|
||||||
if self.bodies.jets and self.bodies.count == 0:
|
|
||||||
raise ValueError("Jets need bodies with cut links")
|
|
||||||
self.stepper.initialize()
|
self.stepper.initialize()
|
||||||
if self.bodies.count > 0:
|
if self.bodies.count > 0:
|
||||||
self.bodies.sync_to_gpu(self.field, rebuild_flags=False)
|
self.bodies.sync_to_gpu(self.field, rebuild_flags=False)
|
||||||
|
|||||||
@@ -0,0 +1,102 @@
|
|||||||
|
"""Host contract of PeriodicBlockStepper.step(n): one stream wait per call (mocked driver)."""
|
||||||
|
import ast
|
||||||
|
from contextlib import nullcontext
|
||||||
|
from pathlib import Path
|
||||||
|
import types
|
||||||
|
from unittest.mock import Mock
|
||||||
|
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."""
|
||||||
|
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)
|
||||||
|
or isinstance(node, ast.ImportFrom) and node.module == "cuda")]
|
||||||
|
module = types.ModuleType("CelerisLab.lbm._test_host_block_stepper")
|
||||||
|
module.__package__ = "CelerisLab.lbm"
|
||||||
|
module.__dict__.update(cuda=Mock(), compiler=Mock())
|
||||||
|
exec(compile(tree, str(path), "exec"), module.__dict__)
|
||||||
|
return module
|
||||||
|
|
||||||
|
|
||||||
|
def backend():
|
||||||
|
host, log = host_module(), []
|
||||||
|
host.cuda.mem_get_info.return_value = (1 << 40, 1 << 40)
|
||||||
|
host.cuda.mem_alloc.side_effect = lambda size: Mock(size=size) # distinct buffers
|
||||||
|
module = Mock()
|
||||||
|
module.get_global.return_value = (Mock(), 20)
|
||||||
|
module.get_function.side_effect = lambda name: Mock(
|
||||||
|
side_effect=lambda *a, **k: log.append((name, a[:2])))
|
||||||
|
host.compiler.load_module.return_value = module
|
||||||
|
cfg = LBMConfig(nx=16, ny=16, viscosity=.1)
|
||||||
|
run = host.PeriodicBlockStepper(cfg, BlockLayout2D.build(16, 16, 8, 8),
|
||||||
|
context=Mock(activate=nullcontext, sm_arch="sm_70"))
|
||||||
|
run._stream.synchronize.side_effect = lambda: log.append(("sync", ()))
|
||||||
|
run.initialize(np.full((9, 16, 16), 1 / 9))
|
||||||
|
log.clear()
|
||||||
|
return run, log
|
||||||
|
|
||||||
|
|
||||||
|
class BlockStepSync(unittest.TestCase):
|
||||||
|
def test_step_n_waits_once_and_matches_n_single_steps(self):
|
||||||
|
many, log_many = backend()
|
||||||
|
many.step(3)
|
||||||
|
single, log_single = backend()
|
||||||
|
for _ in range(3):
|
||||||
|
single.step(1)
|
||||||
|
names = [name for name, _ in log_many]
|
||||||
|
self.assertEqual(names.count("sync"), 1)
|
||||||
|
self.assertEqual(names[-1], "sync")
|
||||||
|
self.assertEqual(names.count("BlockStep"), 3)
|
||||||
|
# Same launch order and buffer roles as three step(1) calls.
|
||||||
|
strip = lambda log: [(n, tuple(id(x) for x in a)) for n, a in log if n != "sync"]
|
||||||
|
roles = lambda run, log: [(n, tuple({id(run._current): "c", id(run._spare): "s"}.get(x, "-")
|
||||||
|
for x in ids)) for n, ids in strip(log)]
|
||||||
|
self.assertEqual([n for n, _ in strip(log_many)], [n for n, _ in strip(log_single)])
|
||||||
|
self.assertEqual(roles(many, log_many), roles(single, log_single))
|
||||||
|
self.assertIsNot(many._current, many._spare)
|
||||||
|
self.assertEqual((many.step_count, single.step_count), (3, 3))
|
||||||
|
|
||||||
|
def test_step_zero_launches_and_waits_for_nothing(self):
|
||||||
|
run, log = backend()
|
||||||
|
run.step(0)
|
||||||
|
self.assertEqual((log, run.step_count), ([], 0))
|
||||||
|
|
||||||
|
def test_failure_keeps_entry_step_count(self):
|
||||||
|
run, log = backend()
|
||||||
|
run.step(1)
|
||||||
|
run._stream.synchronize.side_effect = RuntimeError("device fault")
|
||||||
|
with self.assertRaises(RuntimeError):
|
||||||
|
run.step(2)
|
||||||
|
self.assertEqual((run.step_count, run._status), (1, "failed"))
|
||||||
|
|
||||||
|
def test_launch_failure_mid_batch_fails_closed_without_waiting(self):
|
||||||
|
run, log = backend()
|
||||||
|
calls = []
|
||||||
|
step = run._step
|
||||||
|
|
||||||
|
def failing(*args, **kwargs):
|
||||||
|
calls.append(1)
|
||||||
|
if len(calls) == 2:
|
||||||
|
raise RuntimeError("launch failure")
|
||||||
|
return step(*args, **kwargs)
|
||||||
|
|
||||||
|
run._step = failing
|
||||||
|
with self.assertRaises(RuntimeError):
|
||||||
|
run.step(3)
|
||||||
|
self.assertNotIn("sync", [name for name, _ in log])
|
||||||
|
self.assertEqual((run.step_count, run._status), (0, "failed"))
|
||||||
|
with self.assertRaises(RuntimeError):
|
||||||
|
run.download()
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
unittest.main()
|
||||||
@@ -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]
|
||||||
|
|||||||
@@ -0,0 +1,79 @@
|
|||||||
|
"""CPU-only contract tests for run_dfg_re20. Not CUDA or DFG acceptance evidence."""
|
||||||
|
|
||||||
|
import sys
|
||||||
|
from pathlib import Path
|
||||||
|
import unittest
|
||||||
|
|
||||||
|
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "validation"))
|
||||||
|
import run_dfg_re20 as v # noqa: E402
|
||||||
|
import run_refined_dfg as rr # noqa: E402
|
||||||
|
|
||||||
|
h, _ = rr.helpers(rr.DEFAULT_SOURCE)
|
||||||
|
|
||||||
|
|
||||||
|
def rows(values, tstar_end=v.TSTAR_MAX):
|
||||||
|
n = int(round(tstar_end / v.SAMPLE_TSTAR))
|
||||||
|
return [dict(tstar=(i + 1) * v.SAMPLE_TSTAR, **values(i)) for i in range(n)]
|
||||||
|
|
||||||
|
|
||||||
|
class Re20Contract(unittest.TestCase):
|
||||||
|
def test_lattice_parameters_and_bounds(self):
|
||||||
|
root, uniform = v.lattice_parameters(40), v.lattice_parameters(80)
|
||||||
|
self.assertAlmostEqual(root["tau"], 0.56, places=12)
|
||||||
|
self.assertAlmostEqual(uniform["tau"], 0.62, places=12)
|
||||||
|
self.assertEqual((root["steps"], root["interval"]), (240000, 2000))
|
||||||
|
self.assertEqual((uniform["steps"], uniform["interval"]), (480000, 4000))
|
||||||
|
self.assertAlmostEqual(v.plan()["refined_fine_tau"], 0.62, places=12)
|
||||||
|
|
||||||
|
def test_config_only_changes_viscosity(self):
|
||||||
|
base = v._re100_config(h, 40, "SRT", "none")
|
||||||
|
cfg, body, p = v.config(h, 40, "SRT")
|
||||||
|
self.assertAlmostEqual(cfg["physics"]["viscosity"], 0.01 * 40 / 20, places=15)
|
||||||
|
self.assertEqual((p["re"], p["viscosity"]), (20.0, cfg["physics"]["viscosity"]))
|
||||||
|
base[0]["physics"]["viscosity"] = cfg["physics"]["viscosity"]
|
||||||
|
self.assertEqual(base[0], cfg)
|
||||||
|
self.assertEqual(base[1], body)
|
||||||
|
with self.assertRaisesRegex(ValueError, "no Jets"):
|
||||||
|
v.config(h, 40, "MRT", "zero")
|
||||||
|
|
||||||
|
def test_units(self):
|
||||||
|
s = v.sample([2.0, -0.5], 4, 40, 3.0)
|
||||||
|
den = rr.SPEED**2 * 40 / 2
|
||||||
|
self.assertAlmostEqual(s["cd"], 2.0 / 4 / den)
|
||||||
|
self.assertAlmostEqual(s["cl"], -0.5 / 4 / den)
|
||||||
|
self.assertAlmostEqual(s["p_diff"], 3.0 * 0.04)
|
||||||
|
self.assertEqual(s["dp_scaled"], 3.0)
|
||||||
|
|
||||||
|
def test_steady_and_verdict(self):
|
||||||
|
inside = dict(cd=5.58, cl=0.0106, p_diff=0.1174)
|
||||||
|
out = v.summarize(rows(lambda i: inside))
|
||||||
|
self.assertEqual((out["status"], out["steady"], out["window_samples"]),
|
||||||
|
("WITHIN_INTERVALS", True, 21))
|
||||||
|
self.assertTrue(out["cd_positive"])
|
||||||
|
self.assertAlmostEqual(out["edge_distance"]["cl"], 0.0002)
|
||||||
|
self.assertTrue(all(out["verdict"].values()))
|
||||||
|
low = v.summarize(rows(lambda i: dict(inside, cl=0.0100)))
|
||||||
|
self.assertEqual(low["status"], "OUTSIDE_INTERVALS")
|
||||||
|
self.assertFalse(low["verdict"]["cl"])
|
||||||
|
|
||||||
|
def test_slow_drift_gives_no_verdict(self):
|
||||||
|
# Range 2e-5 passes (limit 6e-5); slope * window 2e-5 exceeds 1.2e-5.
|
||||||
|
out = v.summarize(rows(lambda i: dict(cd=5.58, cl=0.0106 + 1e-6 * i, p_diff=0.1174)))
|
||||||
|
self.assertEqual((out["status"], out["verdict"]), ("NOT_STEADY", None))
|
||||||
|
self.assertLessEqual(out["ranges"]["cl"], out["range_limits"]["cl"])
|
||||||
|
self.assertGreater(out["drifts"]["cl"], out["slope_limits"]["cl"])
|
||||||
|
|
||||||
|
def test_noise_range(self):
|
||||||
|
quiet = v.summarize(rows(lambda i: dict(cd=5.58, cl=0.0106 + 2e-5 * (i % 2), p_diff=0.1174)))
|
||||||
|
self.assertTrue(quiet["steady"]) # within the range limit, no trend
|
||||||
|
noisy = v.summarize(rows(lambda i: dict(cd=5.58, cl=0.0106 + 1e-4 * (i % 2), p_diff=0.1174)))
|
||||||
|
self.assertEqual(noisy["status"], "NOT_STEADY")
|
||||||
|
self.assertGreater(noisy["ranges"]["cl"], noisy["range_limits"]["cl"])
|
||||||
|
|
||||||
|
def test_incomplete_run_gives_no_verdict(self):
|
||||||
|
out = v.summarize(rows(lambda i: dict(cd=5.58, cl=0.0106, p_diff=0.1174), tstar_end=30))
|
||||||
|
self.assertEqual((out["status"], out["verdict"]), ("INCOMPLETE", None))
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
unittest.main()
|
||||||
@@ -16,6 +16,7 @@ from run_jet_circle_cv import (
|
|||||||
case,
|
case,
|
||||||
state,
|
state,
|
||||||
cv,
|
cv,
|
||||||
|
cv_from_macros,
|
||||||
aperture_probe,
|
aperture_probe,
|
||||||
measured_aperture_flux,
|
measured_aperture_flux,
|
||||||
verify,
|
verify,
|
||||||
@@ -28,6 +29,39 @@ def eq(rho, u, v):
|
|||||||
|
|
||||||
|
|
||||||
class Host(unittest.TestCase):
|
class Host(unittest.TestCase):
|
||||||
|
def test_public_macros_pressure_advection_and_cropped_frames(self):
|
||||||
|
for h, origin, shape, rect in (
|
||||||
|
(.5, (0., 0.), (48, 64), (5., 4., 25., 20.)),
|
||||||
|
(.5, (.25, .5), (48, 64), (5.25, 4., 25.25, 20.)),
|
||||||
|
(.25, (.375, .75), (96, 128), (5.125, 4., 25.125, 20.)),
|
||||||
|
):
|
||||||
|
y, x = np.indices(shape)
|
||||||
|
x = origin[0] + h * (x + .5)
|
||||||
|
k, u, v = 1e-5, .02, -.01
|
||||||
|
rho = 1 + 3 * k * x # p=(rho-1)/3=k*x
|
||||||
|
ux, uy, fluid = np.full(shape, u), np.full(shape, v), np.ones(shape, bool)
|
||||||
|
result = cv_from_macros(rho, ux, uy, fluid, origin, rect, .004, h)
|
||||||
|
expected = 320 * np.array([3*k*u, k + 3*k*u*u, 3*k*u*v])
|
||||||
|
np.testing.assert_allclose(result[1], expected, rtol=1e-11, atol=1e-13)
|
||||||
|
np.testing.assert_allclose(result, cv(eq(rho, u, v), fluid, origin, rect, .004, h), atol=1e-12)
|
||||||
|
x0, y0, x1, y1 = np.rint((np.array(rect)-np.tile(origin, 2))/h).astype(int)
|
||||||
|
selection = np.s_[y0-2:y1+2, x0-2:x1+2]
|
||||||
|
cropped_origin = np.asarray(origin) + h*np.array([x0-2, y0-2])
|
||||||
|
cropped = cv_from_macros(rho[selection], ux[selection], uy[selection],
|
||||||
|
fluid[selection], cropped_origin, rect, .004, h)
|
||||||
|
np.testing.assert_array_equal(cropped, result)
|
||||||
|
|
||||||
|
def test_public_macros_full_normal_viscous_stress(self):
|
||||||
|
y, x = np.indices((48, 64))
|
||||||
|
x = (x + .5) * .5
|
||||||
|
rho, ux, uy, fluid = np.ones_like(x), 1e-4*x*x, np.zeros_like(x), np.ones(x.shape, bool)
|
||||||
|
args = (rho, ux, uy, fluid, (0., 0.), (5., 4., 25., 20.))
|
||||||
|
_, viscous = cv_from_macros(*args, .004)
|
||||||
|
_, inviscid = cv_from_macros(*args, 0.)
|
||||||
|
np.testing.assert_allclose(viscous-inviscid, [0, -4*.004*1e-4*320, 0], atol=1e-13)
|
||||||
|
with self.assertRaisesRegex(ValueError, "matching 2D"):
|
||||||
|
cv_from_macros(rho, ux, uy[:-1], fluid, (0, 0), (5, 4, 25, 20), .004)
|
||||||
|
|
||||||
def test_descriptor_and_uniform_closed_flux(self):
|
def test_descriptor_and_uniform_closed_flux(self):
|
||||||
from CelerisLab.lbm.descriptors import D2Q9_EX, D2Q9_EY
|
from CelerisLab.lbm.descriptors import D2Q9_EX, D2Q9_EY
|
||||||
|
|
||||||
|
|||||||
@@ -188,6 +188,55 @@ def jet_case(device, jets):
|
|||||||
return field, bodies
|
return field, bodies
|
||||||
|
|
||||||
|
|
||||||
|
def test_public_surface_exchange_for_jet_preserves_aperture_at_zero_and_reverse(device):
|
||||||
|
from CelerisLab.simulation import Simulation
|
||||||
|
jet = Jet(Sector(CENTER, 0., .6, 3.), Radial(CENTER, inward=False), "quartic", 2e-3)
|
||||||
|
field, bodies = jet_case(device, [jet])
|
||||||
|
sim = SimpleNamespace(bodies=bodies, field=field, _initialized=True,
|
||||||
|
stream=SimpleNamespace(synchronize=device.synchronize))
|
||||||
|
cl = field.curved
|
||||||
|
assert bodies.get(0).surface_actuation is None
|
||||||
|
aperture, velocity = cl.aperture, cl.surface_velocity.copy()
|
||||||
|
assert aperture.any() and (~aperture).any()
|
||||||
|
# Synthetic per-link exchanges test readback/splitting, not kernel physics.
|
||||||
|
values = np.arange(cl.count * 3, dtype=np.float32).reshape(-1, 3)
|
||||||
|
device.htod(cl.link_exchange_gpu, values)
|
||||||
|
for amplitude in (2e-3, 0., -1e-3):
|
||||||
|
Simulation.set_jet_amplitude(sim, 0, amplitude)
|
||||||
|
result = Simulation.read_surface_exchange(sim, 0)
|
||||||
|
assert cl.aperture is aperture
|
||||||
|
np.testing.assert_array_equal(aperture, cl.jet_id >= 0)
|
||||||
|
np.testing.assert_allclose(cl.surface_velocity, velocity * (amplitude / 2e-3))
|
||||||
|
for name, mask in (("wall", ~aperture), ("aperture", aperture)):
|
||||||
|
np.testing.assert_array_equal(result[name], values[mask].sum(axis=0, dtype=np.float64))
|
||||||
|
|
||||||
|
|
||||||
|
def test_public_surface_exchange_keeps_legacy_and_passive_guards(device):
|
||||||
|
from CelerisLab.simulation import Simulation
|
||||||
|
field = make_field(device)
|
||||||
|
bodies = manager(field, [circle(SurfaceActuation(0., .6, .002), radius=2.)])
|
||||||
|
bodies.sync_to_gpu(field)
|
||||||
|
sim = SimpleNamespace(bodies=bodies, field=field,
|
||||||
|
stream=SimpleNamespace(synchronize=device.synchronize))
|
||||||
|
for value in Simulation.read_surface_exchange(sim, 0).values():
|
||||||
|
np.testing.assert_array_equal(value, 0.)
|
||||||
|
field.curved.free_gpu_columns()
|
||||||
|
with pytest.raises(RuntimeError, match="diagnostic is allocated"):
|
||||||
|
Simulation.read_surface_exchange(sim, 0)
|
||||||
|
|
||||||
|
# An exchange buffer elsewhere in the scene must not admit a passive body.
|
||||||
|
for jets in ([], [Jet(Sector(CENTER, 0., .6, 3.), Radial(CENTER))]):
|
||||||
|
field, bodies = jet_case(device, jets)
|
||||||
|
passive = bodies.add(circle(center=(2., 3.), radius=.6))
|
||||||
|
bodies.sync_to_gpu(field)
|
||||||
|
sim.bodies, sim.field = bodies, field
|
||||||
|
with pytest.raises(ValueError, match="Body has no surface actuation"):
|
||||||
|
Simulation.read_surface_exchange(sim, passive)
|
||||||
|
if not jets:
|
||||||
|
with pytest.raises(ValueError, match="Body has no surface actuation"):
|
||||||
|
Simulation.read_surface_exchange(sim, 0)
|
||||||
|
|
||||||
|
|
||||||
def test_manager_passes_true_hits_and_reuploads_only_velocity(device):
|
def test_manager_passes_true_hits_and_reuploads_only_velocity(device):
|
||||||
# CPU memory double only: checks host/device bookkeeping, not GPU numerics.
|
# CPU memory double only: checks host/device bookkeeping, not GPU numerics.
|
||||||
jet = Jet(Sector(CENTER, 0., .6, 3.), Radial(CENTER, inward=False), "quartic", 2e-3)
|
jet = Jet(Sector(CENTER, 0., .6, 3.), Radial(CENTER, inward=False), "quartic", 2e-3)
|
||||||
|
|||||||
@@ -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):
|
||||||
|
|||||||
@@ -146,23 +146,26 @@ def test_full_requires_completed_pilot():
|
|||||||
r.verify_pilot(None, r.verify_source(r.DEFAULT_SOURCE, "MRT", "window"))
|
r.verify_pilot(None, r.verify_source(r.DEFAULT_SOURCE, "MRT", "window"))
|
||||||
|
|
||||||
|
|
||||||
def pilot_fixture(path, observation_mode="window"):
|
def pilot_fixture(path, observation_mode="window", jet_scenario="none", case_selection="both", uniform_diameter=80, placement="wide"):
|
||||||
"""Synthetic contract fixture only; never a physical result or run receipt."""
|
"""Synthetic contract fixture only; never a physical result or run receipt."""
|
||||||
manifest = (r.verify_source(r.DEFAULT_SOURCE, "MRT", "window")
|
manifest = (r.verify_source(r.DEFAULT_SOURCE, "MRT", "window", jet_scenario)
|
||||||
if observation_mode == "window" else
|
if observation_mode == "window" else
|
||||||
json.loads((r.HERE / "data/refined_dfg/source_manifest_mrt.json").read_text()))
|
json.loads((r.HERE / "data/refined_dfg/source_manifest_mrt.json").read_text()))
|
||||||
|
selection = dict(case_selection=case_selection, uniform_diameter=uniform_diameter, placement=placement)
|
||||||
(path / "plan.json").write_text(
|
(path / "plan.json").write_text(
|
||||||
json.dumps(
|
json.dumps(
|
||||||
dict(
|
dict(
|
||||||
source_manifest=manifest,
|
source_manifest=manifest,
|
||||||
|
**selection,
|
||||||
collision="MRT",
|
collision="MRT",
|
||||||
|
jet_scenario=jet_scenario,
|
||||||
observation_mode=observation_mode,
|
observation_mode=observation_mode,
|
||||||
bounds_root_edge=list(r.BOUNDS),
|
bounds_root_edge=list(r.PLACEMENTS[placement]),
|
||||||
runner_sha256=r.runner_hash(),
|
runner_sha256=r.runner_hash(),
|
||||||
)
|
)
|
||||||
)
|
)
|
||||||
)
|
)
|
||||||
for case, diameter in (("uniform", 80), ("refined", 40)):
|
for case, diameter in r.selected_cases(case_selection, uniform_diameter):
|
||||||
dest = path / case
|
dest = path / case
|
||||||
dest.mkdir()
|
dest.mkdir()
|
||||||
interval = round(0.02 * diameter / r.SPEED)
|
interval = round(0.02 * diameter / r.SPEED)
|
||||||
@@ -189,7 +192,9 @@ def pilot_fixture(path, observation_mode="window"):
|
|||||||
json.dumps(
|
json.dumps(
|
||||||
dict(
|
dict(
|
||||||
case=case,
|
case=case,
|
||||||
|
**selection,
|
||||||
collision="MRT",
|
collision="MRT",
|
||||||
|
jet_scenario=jet_scenario,
|
||||||
observation_mode=observation_mode,
|
observation_mode=observation_mode,
|
||||||
mode="pilot",
|
mode="pilot",
|
||||||
status="pilot_complete",
|
status="pilot_complete",
|
||||||
@@ -206,7 +211,9 @@ def pilot_fixture(path, observation_mode="window"):
|
|||||||
json.dumps(
|
json.dumps(
|
||||||
dict(
|
dict(
|
||||||
case=case,
|
case=case,
|
||||||
|
**selection,
|
||||||
collision="MRT",
|
collision="MRT",
|
||||||
|
jet_scenario=jet_scenario,
|
||||||
observation_mode=observation_mode,
|
observation_mode=observation_mode,
|
||||||
mode="pilot",
|
mode="pilot",
|
||||||
step=interval,
|
step=interval,
|
||||||
@@ -451,6 +458,169 @@ def test_window_contract_rejection():
|
|||||||
assert not backend.events
|
assert not backend.events
|
||||||
|
|
||||||
|
|
||||||
|
def test_public_jet_configuration_and_geometry():
|
||||||
|
for diameter, center, radius in ((40, (80.5, 81), 20), (80, (160, 160.5), 40)):
|
||||||
|
cfg, _, _ = r.config(h, diameter, "MRT", "fixed")
|
||||||
|
assert not cfg["method"]["ddf_shifting"] and not cfg["method"]["les"]["enabled"]
|
||||||
|
jets = r.public_jets(center, radius, "fixed")
|
||||||
|
assert [j.amplitude for j in jets] == [.001, -.001]
|
||||||
|
assert all(j.field.inward is False and j.profile == "parabolic" for j in jets)
|
||||||
|
assert all(j.region.r_max == radius * 1.005 for j in jets)
|
||||||
|
assert all(j.amplitude == 0 for j in r.public_jets(center, radius, "zero"))
|
||||||
|
cfg, _, _, host = r.host_geometry(r.DEFAULT_SOURCE, h, "MRT", "fixed")
|
||||||
|
assert not cfg.ddf_shifting and len(host.boundary_cells) > 0
|
||||||
|
assert r.public_jets((0, 0), 1, "none") == ()
|
||||||
|
with unittest.TestCase().assertRaises(ValueError):
|
||||||
|
r.config(h, 40, "SRT", "fixed")
|
||||||
|
|
||||||
|
|
||||||
|
def test_public_jet_reversal_boundary_and_windows():
|
||||||
|
from types import SimpleNamespace
|
||||||
|
|
||||||
|
calls = []
|
||||||
|
handle = SimpleNamespace(set_jet_amplitude=lambda i, a: calls.append((i, a)))
|
||||||
|
for diameter in (40, 80):
|
||||||
|
boundary = round(250 * diameter / r.SPEED)
|
||||||
|
assert r.jet_interval(handle, "fixed", boundary - 3, 80, diameter) == (3, None)
|
||||||
|
switch = round(300 * diameter / r.SPEED)
|
||||||
|
assert r.jet_interval(handle, "reverse", switch - 3, 80, diameter) == (3, None)
|
||||||
|
assert not calls
|
||||||
|
n, event = r.jet_interval(handle, "reverse", switch, 80, diameter)
|
||||||
|
assert n == 80 and event["step"] == switch and event["tstar"] == 300
|
||||||
|
assert calls == [(0, -.001), (1, .001)]
|
||||||
|
calls.clear()
|
||||||
|
assert r.jet_interval(handle, "reverse", switch + 80, 80, diameter) == (80, None)
|
||||||
|
assert r.jet_interval(handle, "fixed", switch, 80, diameter) == (80, None)
|
||||||
|
assert not calls
|
||||||
|
rows = [dict(tstar=t, tstar_force=t - .5, cd=2.0, cl=-.1) for t in range(251, 306)]
|
||||||
|
windows = r.jet_diagnostics(rows, "reverse")
|
||||||
|
assert len(windows) == 6 and all(w["complete"] for w in windows)
|
||||||
|
assert all(w["cd"]["mean"] == 2 and np.isclose(w["cl"]["mean"], -.1) for w in windows)
|
||||||
|
assert windows[-1]["covered_tstar"] == 5
|
||||||
|
with unittest.TestCase().assertRaisesRegex(ValueError, "crosses"):
|
||||||
|
r.jet_diagnostics([dict(tstar=250.5, tstar_force=250, cd=1, cl=0)], "fixed")
|
||||||
|
assert r.plan(h, "MRT", "window", "reverse")["modes"]["full_tstar"] == 305
|
||||||
|
|
||||||
|
|
||||||
|
def test_public_jet_source_and_pilot_separation():
|
||||||
|
from tempfile import TemporaryDirectory
|
||||||
|
|
||||||
|
with TemporaryDirectory() as tmp:
|
||||||
|
path = Path(tmp)
|
||||||
|
manifest = pilot_fixture(path, jet_scenario="fixed")
|
||||||
|
assert manifest["source_capture"].startswith("current checkout")
|
||||||
|
assert len(manifest["checkout_revision"]) == 40
|
||||||
|
assert r.verify_pilot(path, manifest, "MRT", "window", "fixed") == 3606.0
|
||||||
|
for scenario in ("none", "zero", "reverse"):
|
||||||
|
with unittest.TestCase().assertRaisesRegex(ValueError, "Jet scenario"):
|
||||||
|
r.verify_pilot(path, manifest, "MRT", "window", scenario)
|
||||||
|
for relative in ("uniform/summary.json", "refined/ready.json"):
|
||||||
|
receipt = path / relative
|
||||||
|
record = json.loads(receipt.read_text())
|
||||||
|
receipt.write_text(json.dumps(dict(record, jet_scenario="zero")))
|
||||||
|
with unittest.TestCase().assertRaises(ValueError):
|
||||||
|
r.verify_pilot(path, manifest, "MRT", "window", "fixed")
|
||||||
|
receipt.write_text(json.dumps(record))
|
||||||
|
with unittest.TestCase().assertRaises(ValueError):
|
||||||
|
r.verify_source(r.DEFAULT_SOURCE, "MRT", "last_base_step", "fixed")
|
||||||
|
|
||||||
|
|
||||||
|
def test_cv_snapshot_common_units_and_window_endpoints():
|
||||||
|
records = []
|
||||||
|
for refined, shape, origin, diameter, impulse in (
|
||||||
|
(True, (240, 568), (38., 22.), 40, [4., -8.]),
|
||||||
|
(False, (330, 1761), (.25, .5), 80, [16., -32.]),
|
||||||
|
(False, (658, 3521), (.375, .75), 160, [64., -128.]),
|
||||||
|
):
|
||||||
|
rho, ux, uy, fluid = np.ones(shape), np.full(shape, .01), np.zeros(shape), np.ones(shape, bool)
|
||||||
|
begin, n = round(290*diameter/r.SPEED), round(.02*diameter/r.SPEED)
|
||||||
|
record = r.cv_snapshot(rho, ux, uy, fluid, origin, refined, begin, n, diameter, impulse)
|
||||||
|
records.append(record)
|
||||||
|
np.testing.assert_allclose(record["outward_flux"], 0, atol=1e-12)
|
||||||
|
assert r.cv_selected(begin, diameter, "full") and not r.cv_selected(begin-n, diameter, "full")
|
||||||
|
end = round(300*diameter/r.SPEED)
|
||||||
|
assert r.cv_selected(end, diameter, "full") and not r.cv_selected(end+n, diameter, "full")
|
||||||
|
assert r.cv_selected(n, diameter, "pilot")
|
||||||
|
assert sum(r.cv_selected(step, diameter, "full") for step in range(begin-n, end+n+1, n)) == 501
|
||||||
|
for key in ("time_root", "interval_start_root", "interval_dt_root", "interval_impulse_root", "inventory"):
|
||||||
|
for record in records[1:]:
|
||||||
|
np.testing.assert_allclose(records[0][key], record[key], rtol=0, atol=1e-10)
|
||||||
|
assert records[0]["interval_dt_root"] == 80 and np.isclose(records[0]["tstar"], 290.02)
|
||||||
|
np.testing.assert_array_equal(records[0]["interval_impulse_root"], [4, -8])
|
||||||
|
|
||||||
|
|
||||||
|
def test_cv_pilot_mode_and_helper_provenance():
|
||||||
|
from tempfile import TemporaryDirectory
|
||||||
|
|
||||||
|
manifest = r.verify_source(r.DEFAULT_SOURCE, "MRT", "window", "fixed", True)
|
||||||
|
assert "tests/validation/run_jet_circle_cv.py" in manifest["sha256"]
|
||||||
|
with TemporaryDirectory() as tmp:
|
||||||
|
path = Path(tmp)
|
||||||
|
old = pilot_fixture(path, jet_scenario="fixed")
|
||||||
|
with unittest.TestCase().assertRaisesRegex(ValueError, "CV observation mode"):
|
||||||
|
r.verify_pilot(path, old, "MRT", "window", "fixed", True)
|
||||||
|
for relative in ("plan.json", "uniform/summary.json", "refined/summary.json",
|
||||||
|
"uniform/ready.json", "refined/ready.json"):
|
||||||
|
file = path / relative
|
||||||
|
record = json.loads(file.read_text())
|
||||||
|
record.update(observe_cv=True, cv_samples=250)
|
||||||
|
if relative == "plan.json":
|
||||||
|
record["source_manifest"] = manifest
|
||||||
|
file.write_text(json.dumps(record))
|
||||||
|
assert r.verify_pilot(path, manifest, "MRT", "window", "fixed", True) == 3606
|
||||||
|
|
||||||
|
|
||||||
|
def test_compact_geometry_and_cv_stencils():
|
||||||
|
from CelerisLab.lbm.refinement import ACTIVE
|
||||||
|
from CelerisLab.lbm.descriptors import SOLID
|
||||||
|
|
||||||
|
_, pair, _, host = r.host_geometry(r.DEFAULT_SOURCE, h, "MRT", "fixed", "compact")
|
||||||
|
assert pair.fine_shape == (168, 168) and tuple(pair.fine_origin) == (46, 46)
|
||||||
|
fluid = (pair.fine_kind == ACTIVE) & ((host.flags.reshape(pair.fine_shape) & SOLID) == 0)
|
||||||
|
rho, ux, uy = np.ones(pair.fine_shape), np.full(pair.fine_shape, .01), np.zeros(pair.fine_shape)
|
||||||
|
record = r.cv_snapshot(rho, ux, uy, fluid, pair.fine_origin, True, 1160000, 80, 40, [1, 2], "compact")
|
||||||
|
np.testing.assert_allclose(record["outward_flux"], 0, atol=1e-12)
|
||||||
|
stencil = np.zeros(pair.fine_shape, bool)
|
||||||
|
for rect in r.cv_contours(True, 40, "compact"):
|
||||||
|
x0, y0, x1, y1 = np.rint((rect - np.tile(pair.fine_origin, 2))/.5).astype(int)
|
||||||
|
stencil[y0-2:y1+2, x0-2:x0+2] = stencil[y0-2:y1+2, x1-2:x1+2] = True
|
||||||
|
stencil[y0-2:y0+2, x0-2:x1+2] = stencil[y1-2:y1+2, x0-2:x1+2] = True
|
||||||
|
assert fluid[stencil].all() and not stencil.ravel()[host.transfer_fine_cells].any()
|
||||||
|
|
||||||
|
|
||||||
|
def test_d160_config_and_single_case_receipts():
|
||||||
|
from tempfile import TemporaryDirectory
|
||||||
|
from unittest.mock import patch
|
||||||
|
|
||||||
|
cfg, _, p = r.config(h, 160, "MRT", "fixed")
|
||||||
|
assert (p["nx"], p["ny"], p["center"], p["radius"]) == (3521, 658, [320, 320.5], 80)
|
||||||
|
assert p["viscosity"] == .016 and p["mean_speed"] == .01 and not cfg["method"]["ddf_shifting"]
|
||||||
|
assert r.uniform_origin(160) == (.375, .75)
|
||||||
|
np.testing.assert_array_equal(r.cv_contours(False, 160), r.CV_CONTOURS + [.125, 0, .125, 0])
|
||||||
|
for scenario, expected_exit in (("fixed", 0), ("zero", 2)):
|
||||||
|
with TemporaryDirectory() as tmp:
|
||||||
|
path = Path(tmp)
|
||||||
|
manifest = pilot_fixture(path, jet_scenario=scenario, case_selection="uniform", uniform_diameter=160)
|
||||||
|
assert r.verify_pilot(path, manifest, "MRT", "window", scenario, False, "uniform", 160) == 1803
|
||||||
|
for selection, diameter, placement in (("both", 160, "wide"), ("uniform", 80, "wide"), ("uniform", 160, "compact")):
|
||||||
|
with unittest.TestCase().assertRaises(ValueError):
|
||||||
|
r.verify_pilot(path, manifest, "MRT", "window", scenario, False, selection, diameter, placement)
|
||||||
|
# Synthetic dispatch/result check: no CUDA imports or execution.
|
||||||
|
output = path / "full"
|
||||||
|
argv = ["runner", "--collision", "MRT", "--exchange-window", "--jet-scenario", scenario,
|
||||||
|
"--case", "uniform", "--uniform-diameter", "160", "--mode", "full",
|
||||||
|
"--pilot-results", str(path), "--output", str(output), "--max-wall-seconds", "10", "--gpu-gates-approved"]
|
||||||
|
result = dict(case="uniform", healthy=True, periodic=scenario == "zero", jet_diagnostic_windows=[],
|
||||||
|
status="driven_diagnostics_complete" if scenario == "fixed" else "periodic",
|
||||||
|
reference_comparison=dict(reference_agreement=False))
|
||||||
|
with patch.object(sys, "argv", argv), patch.dict(r.os.environ, CUDA_VISIBLE_DEVICES="mock-no-gpu"), \
|
||||||
|
patch.object(r, "run_case", return_value=result) as run:
|
||||||
|
assert r.main() == expected_exit and run.call_count == 1
|
||||||
|
comparison = json.loads((output / "comparison.json").read_text())
|
||||||
|
assert comparison["matched_case_pass"] is False and "refined_vs_uniform" not in comparison
|
||||||
|
assert comparison["status"].startswith("single_case_")
|
||||||
|
|
||||||
|
|
||||||
if __name__ == "__main__":
|
if __name__ == "__main__":
|
||||||
suite = unittest.TestSuite(
|
suite = unittest.TestSuite(
|
||||||
unittest.FunctionTestCase(fn)
|
unittest.FunctionTestCase(fn)
|
||||||
|
|||||||
@@ -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()
|
||||||
|
|
||||||
@@ -313,21 +315,23 @@ class ConstructorAndSchedule(unittest.TestCase):
|
|||||||
|
|
||||||
|
|
||||||
|
|
||||||
class InitialLevels(unittest.TestCase):
|
class RemovedLegacyAPI(unittest.TestCase):
|
||||||
"""initialize() entry adapter: positional per-level arrays or the legacy names, never both."""
|
"""The pre-level-list constructor/initialize forms are gone and fail loudly."""
|
||||||
|
|
||||||
def test_forms(self):
|
def test_removed_constructor_forms_raise_type_error(self):
|
||||||
a, b, c = object(), object(), object()
|
import inspect
|
||||||
f = host._initial_levels
|
context = Mock()
|
||||||
self.assertEqual(f((a, b), None, None, None), (a, b))
|
with self.assertRaises(TypeError): # positional bounds
|
||||||
self.assertEqual(f((a, b, c), None, None, None), (a, b, c))
|
host.FixedPatchStepper(CFG, PARENTS, context=context)
|
||||||
self.assertEqual(f((a, b), None, None, c), (a, b, c)) # old initialize(c, f, child_g=g)
|
removed = dict(bounds=PARENTS, fine_block=(4, 4), base_block=(4, 4), fine_objects=(),
|
||||||
self.assertEqual(f((), a, b, None), (a, b))
|
jets=(), child=(8, 8, 16, 16), child_block=(4, 4), child_objects=(),
|
||||||
self.assertEqual(f((), a, b, c), (a, b, c))
|
child_jets=(), child_rectangles_in_parent=CHILDREN)
|
||||||
for args in (((a,), None, None, c), ((a, b, c), None, None, c), ((a,), a, b, None),
|
for name, value in removed.items():
|
||||||
((), a, None, None), ((), None, b, c)):
|
with self.subTest(keyword=name), self.assertRaises(TypeError):
|
||||||
with self.subTest(args=args), self.assertRaises(TypeError):
|
host.FixedPatchStepper(CFG, context=context, **levels(), **{name: value})
|
||||||
f(*args)
|
context.activate.assert_not_called()
|
||||||
|
self.assertEqual(list(inspect.signature(host.FixedPatchStepper.initialize).parameters),
|
||||||
|
["self", "level_g"]) # no coarse_g/fine_g/child_g
|
||||||
|
|
||||||
|
|
||||||
if __name__=='__main__':
|
if __name__=='__main__':
|
||||||
|
|||||||
@@ -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()
|
||||||
|
|
||||||
|
|||||||
@@ -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):
|
||||||
|
|||||||
@@ -238,6 +238,81 @@ def test_overlapping_force_regions_rejected(device):
|
|||||||
bodies.build_compact_lists(bodies.build_flags(field.flag))
|
bodies.build_compact_lists(bodies.build_flags(field.flag))
|
||||||
|
|
||||||
|
|
||||||
|
@pytest.mark.parametrize("second_x,error", [(14., "unique cut-link writers"),
|
||||||
|
(17., "active fluid receivers")])
|
||||||
|
def test_passive_overlap_rejected_before_publishing_lists(second_x, error):
|
||||||
|
cfg = LBMConfig(nx=32, ny=24)
|
||||||
|
cfg.validate()
|
||||||
|
bodies = ObjectManager(cfg.nx, cfg.ny, cfg.nz, cfg.nq, cfg)
|
||||||
|
for x in (14., second_x):
|
||||||
|
bodies.add(obj(x=x, y=12., r=4.3))
|
||||||
|
bodies.add(obj(x=4., y=4., r=2., is_sensor=True))
|
||||||
|
counts = np.full(bodies.count, 91, np.int32)
|
||||||
|
hits = []
|
||||||
|
flags = bodies.build_flags(np.full(cfg.nx * cfg.ny, FLUID, np.uint16))
|
||||||
|
for domain_flags in (flags, None):
|
||||||
|
with pytest.raises(ValueError, match=error):
|
||||||
|
bodies.build_compact_lists_for(bodies.objects, domain_flags,
|
||||||
|
sensor_cell_counts_out=counts, hits_out=hits)
|
||||||
|
np.testing.assert_array_equal(counts, 91)
|
||||||
|
assert hits == []
|
||||||
|
|
||||||
|
|
||||||
|
@pytest.mark.parametrize("centers", [((10., 12.), (22., 12.)),
|
||||||
|
((10.5, 12.), (19.5, 12.))])
|
||||||
|
def test_separated_passive_bodies_keep_valid_writers(centers):
|
||||||
|
# The second case has a subcell physical gap with a resolved fluid column.
|
||||||
|
cfg = LBMConfig(nx=32, ny=24)
|
||||||
|
cfg.validate()
|
||||||
|
bodies = ObjectManager(cfg.nx, cfg.ny, cfg.nz, cfg.nq, cfg)
|
||||||
|
for x, y in centers:
|
||||||
|
bodies.add(obj(x=x, y=y, r=4.3))
|
||||||
|
flags = bodies.build_flags(np.full(cfg.nx * cfg.ny, FLUID, np.uint16))
|
||||||
|
indices, directions, _, ids, *_ = bodies.build_compact_lists(flags)
|
||||||
|
assert set(ids) == {0, 1}
|
||||||
|
assert np.all(flags[indices] & FLUID) and not np.any(flags[indices] & SOLID)
|
||||||
|
assert len(np.unique(indices.astype(np.uint64) * cfg.nq + directions)) == len(indices)
|
||||||
|
|
||||||
|
|
||||||
|
@pytest.mark.parametrize("entry", ["sync", "initialize", "runtime_edit"])
|
||||||
|
@pytest.mark.parametrize("second_x", [5., 6.])
|
||||||
|
def test_passive_overlap_failure_keeps_live_state(device, entry, second_x):
|
||||||
|
from CelerisLab.simulation import Simulation
|
||||||
|
field = make_field(device)
|
||||||
|
bodies = manager(field, [obj(), obj(x=9., y=3., r=1., is_sensor=True)])
|
||||||
|
bodies.sync_to_gpu(field)
|
||||||
|
overlapping = obj(x=second_x)
|
||||||
|
if entry == "runtime_edit":
|
||||||
|
bodies.stage_add(overlapping)
|
||||||
|
else:
|
||||||
|
bodies.add(overlapping)
|
||||||
|
objects = bodies.objects
|
||||||
|
flags, curved, counts = field.flag.copy(), field.curved.fluid_idx.copy(), bodies.sensor_cell_counts.copy()
|
||||||
|
action = bodies.action.copy()
|
||||||
|
buffers = [(block, bytes(block.data), block.freed) for block in device.blocks]
|
||||||
|
writes = device.writes
|
||||||
|
sim = SimpleNamespace(bodies=bodies, field=field, lbm_cfg=field.cfg,
|
||||||
|
_initialized=entry == "runtime_edit",
|
||||||
|
_assert_allocation_contract=lambda: None,
|
||||||
|
stream=SimpleNamespace(synchronize=device.synchronize))
|
||||||
|
with pytest.raises(ValueError, match="active fluid receivers|unique cut-link writers"):
|
||||||
|
if entry == "sync":
|
||||||
|
bodies.sync_to_gpu(field)
|
||||||
|
elif entry == "initialize":
|
||||||
|
Simulation.initialize(sim)
|
||||||
|
else:
|
||||||
|
Simulation.sync_bodies(sim)
|
||||||
|
assert bodies.objects == objects
|
||||||
|
assert bodies.has_pending_edit() == (entry == "runtime_edit")
|
||||||
|
assert sim._initialized == (entry == "runtime_edit")
|
||||||
|
assert device.writes == writes and len(device.blocks) == len(buffers)
|
||||||
|
assert all(bytes(block.data) == data and block.freed == freed for block, data, freed in buffers)
|
||||||
|
np.testing.assert_array_equal(field.flag, flags)
|
||||||
|
np.testing.assert_array_equal(field.curved.fluid_idx, curved)
|
||||||
|
np.testing.assert_array_equal(bodies.sensor_cell_counts, counts)
|
||||||
|
np.testing.assert_array_equal(bodies.action, action)
|
||||||
|
|
||||||
|
|
||||||
def test_action_upload_and_scratch_are_pinned(device):
|
def test_action_upload_and_scratch_are_pinned(device):
|
||||||
field = make_field(device, streaming="esopull")
|
field = make_field(device, streaming="esopull")
|
||||||
bodies = manager(field, [obj(is_force_region=True)])
|
bodies = manager(field, [obj(is_force_region=True)])
|
||||||
|
|||||||
@@ -106,9 +106,10 @@ class ChannelRootGPU(unittest.TestCase):
|
|||||||
cfg = LBMConfig(nx=48, ny=32, viscosity=.1, velocity=.015, ddf_shifting=shifted)
|
cfg = LBMConfig(nx=48, ny=32, viscosity=.1, velocity=.015, ddf_shifting=shifted)
|
||||||
reference = None
|
reference = None
|
||||||
for block in ((32,48), (8,8), (4,1)):
|
for block in ((32,48), (8,8), (4,1)):
|
||||||
with FixedPatchStepper(cfg, (8,6,40,26), context=context,
|
with FixedPatchStepper(cfg, context=context, coarse_boundary="channel",
|
||||||
coarse_boundary="channel", base_block=block, fine_block=(8,8),
|
refinements=[(8,6,40,26)], level_blocks=[block, (8,8)],
|
||||||
fine_objects=(body,) if bodies else (), jets=(jet,) if bodies else ()) as backend:
|
level_objects=[(), (body,) if bodies else ()],
|
||||||
|
level_jets=[(), (jet,) if bodies else ()]) as backend:
|
||||||
arrays = [state(*level.shape[1:]) for level in backend._levels]
|
arrays = [state(*level.shape[1:]) for level in backend._levels]
|
||||||
backend.initialize(*arrays)
|
backend.initialize(*arrays)
|
||||||
backend.step(4)
|
backend.step(4)
|
||||||
|
|||||||
@@ -25,8 +25,8 @@ EPS = np.finfo(np.float64).eps
|
|||||||
|
|
||||||
|
|
||||||
def build(m, window=True, raw=True):
|
def build(m, window=True, raw=True):
|
||||||
return FixedPatchStepper(config("periodic"), BOUNDS, context=m["context"], base_block=(3, 4),
|
return FixedPatchStepper(config("periodic"), context=m["context"], refinements=[BOUNDS],
|
||||||
fine_block=(16, 20), fine_objects=[circle()],
|
level_blocks=[(3, 4), (16, 20)], level_objects=[(), (circle(),)],
|
||||||
observe_raw_exchange=raw, observe_window_exchange=window)
|
observe_raw_exchange=raw, observe_window_exchange=window)
|
||||||
|
|
||||||
|
|
||||||
@@ -109,10 +109,11 @@ class ExchangeWindowGPU(unittest.TestCase):
|
|||||||
from test_raw_exchange_gpu import BOUNDS as RB, CFG, circle as rc, jet, state
|
from test_raw_exchange_gpu import BOUNDS as RB, CFG, circle as rc, jet, state
|
||||||
from CelerisLab.cuda.context import CudaContext
|
from CelerisLab.cuda.context import CudaContext
|
||||||
with CudaContext(0) as ctx:
|
with CudaContext(0) as ctx:
|
||||||
kw = dict(context=ctx, fine_block=(16, 20), fine_objects=[rc()], jets=[jet()],
|
kw = dict(context=ctx, refinements=[RB], level_blocks=[None, (16, 20)],
|
||||||
|
level_objects=[(), (rc(),)], level_jets=[(), (jet(),)],
|
||||||
observe_raw_exchange=True)
|
observe_raw_exchange=True)
|
||||||
with FixedPatchStepper(CFG, RB, observe_window_exchange=True, **kw) as windowed, \
|
with FixedPatchStepper(CFG, observe_window_exchange=True, **kw) as windowed, \
|
||||||
FixedPatchStepper(CFG, RB, **kw) as plain:
|
FixedPatchStepper(CFG, **kw) as plain:
|
||||||
arrays = [state(level.shape) for level in windowed._levels]
|
arrays = [state(level.shape) for level in windowed._levels]
|
||||||
windowed.initialize(*arrays)
|
windowed.initialize(*arrays)
|
||||||
plain.initialize(*arrays)
|
plain.initialize(*arrays)
|
||||||
@@ -200,11 +201,11 @@ class ExchangeWindowShiftedMRTGPU(unittest.TestCase):
|
|||||||
from CelerisLab.cuda.context import CudaContext
|
from CelerisLab.cuda.context import CudaContext
|
||||||
cfg = LBMConfig(nx=32, ny=24, viscosity=.1, collision="MRT", ddf_shifting=True)
|
cfg = LBMConfig(nx=32, ny=24, viscosity=.1, collision="MRT", ddf_shifting=True)
|
||||||
with CudaContext(0) as ctx:
|
with CudaContext(0) as ctx:
|
||||||
kw = dict(context=ctx, base_block=(12, 8), fine_block=(16, 20), fine_objects=[rc()],
|
kw = dict(context=ctx, refinements=[RB], level_blocks=[(12, 8), (16, 20)],
|
||||||
observe_raw_exchange=True)
|
level_objects=[(), (rc(),)], observe_raw_exchange=True)
|
||||||
with FixedPatchStepper(cfg, RB, observe_window_exchange=True, **kw) as windowed, \
|
with FixedPatchStepper(cfg, observe_window_exchange=True, **kw) as windowed, \
|
||||||
FixedPatchStepper(cfg, RB, observe_window_exchange=True, **kw) as split, \
|
FixedPatchStepper(cfg, observe_window_exchange=True, **kw) as split, \
|
||||||
FixedPatchStepper(cfg, RB, **kw) as plain:
|
FixedPatchStepper(cfg, **kw) as plain:
|
||||||
arrays = [state(level.shape) for level in windowed._levels]
|
arrays = [state(level.shape) for level in windowed._levels]
|
||||||
for run in (windowed, split, plain):
|
for run in (windowed, split, plain):
|
||||||
run.initialize(*arrays)
|
run.initialize(*arrays)
|
||||||
|
|||||||
@@ -140,7 +140,8 @@ def run_patch(speed, *, audit=True):
|
|||||||
build = (patch.object(compiler, "compile_kernel", audit_compiler(compiler.compile_kernel))
|
build = (patch.object(compiler, "compile_kernel", audit_compiler(compiler.compile_kernel))
|
||||||
if audit else nullcontext())
|
if audit else nullcontext())
|
||||||
with build:
|
with build:
|
||||||
backend = implementation.FixedPatchStepper(cfg, BOUNDS, context=context, fine_objects=[source])
|
backend = implementation.FixedPatchStepper(cfg, context=context, refinements=[BOUNDS],
|
||||||
|
level_objects=[(), (source,)])
|
||||||
with backend, context.activate():
|
with backend, context.activate():
|
||||||
c, f = backend._levels
|
c, f = backend._levels
|
||||||
cl = backend._fine_curved
|
cl = backend._fine_curved
|
||||||
@@ -325,6 +326,7 @@ def test_cross_interface_donor_rejects_before_cuda():
|
|||||||
context.activate.side_effect = AssertionError("must reject before CUDA activation")
|
context.activate.side_effect = AssertionError("must reject before CUDA activation")
|
||||||
with patch.object(cuda, "mem_alloc") as allocate:
|
with patch.object(cuda, "mem_alloc") as allocate:
|
||||||
with pytest.raises(ValueError, match="donor crosses"):
|
with pytest.raises(ValueError, match="donor crosses"):
|
||||||
implementation.FixedPatchStepper(cfg, BOUNDS, context=context, fine_objects=[source])
|
implementation.FixedPatchStepper(cfg, context=context, refinements=[BOUNDS],
|
||||||
|
level_objects=[(), (source,)])
|
||||||
context.activate.assert_not_called()
|
context.activate.assert_not_called()
|
||||||
allocate.assert_not_called()
|
allocate.assert_not_called()
|
||||||
@@ -48,9 +48,8 @@ def make(context):
|
|||||||
for (x, y), amplitude in zip(centers, (.003, -.002))
|
for (x, y), amplitude in zip(centers, (.003, -.002))
|
||||||
)
|
)
|
||||||
run = FixedPatchStepper(
|
run = FixedPatchStepper(
|
||||||
CFG, PARENTS, context=context, base_block=(4, 4), fine_block=(4, 4),
|
CFG, context=context, refinements=[PARENTS, START], level_blocks=[(4, 4)] * 3,
|
||||||
child_block=(4, 4), child_rectangles_in_parent=START,
|
level_objects=[(), (), objects], level_jets=[(), (), jets],
|
||||||
child_objects=objects, child_jets=jets,
|
|
||||||
)
|
)
|
||||||
return run, objects
|
return run, objects
|
||||||
|
|
||||||
|
|||||||
@@ -25,9 +25,8 @@ B = ((16,16,32,40), (60,16,76,40))
|
|||||||
def make(ctx):
|
def make(ctx):
|
||||||
body = SimObject(71, geometry=CircleGeometry(12.,14.,.8),center=(12.,14.),radius=.8)
|
body = SimObject(71, geometry=CircleGeometry(12.,14.,.8),center=(12.,14.),radius=.8)
|
||||||
jet = Jet(Tube((10.5,14.),0.,3.,.3),Parallel(0.),'parabolic',.003)
|
jet = Jet(Tube((10.5,14.),0.,3.,.3),Parallel(0.),'parabolic',.003)
|
||||||
run = FixedPatchStepper(CFG,PARENTS,context=ctx,base_block=(4,4),fine_block=(4,4),
|
run = FixedPatchStepper(CFG,context=ctx,refinements=[PARENTS,A],level_blocks=[(4,4)]*3,
|
||||||
child_block=(4,4),child_rectangles_in_parent=A,
|
level_objects=[(),(),(body,)],level_jets=[(),(),(jet,)])
|
||||||
child_objects=(body,),child_jets=(jet,))
|
|
||||||
return run,(body,)
|
return run,(body,)
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@@ -90,14 +90,18 @@ def census(run, index, buffer):
|
|||||||
return totals(dense, leaf), external, independent
|
return totals(dense, leaf), external, independent
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
def fine(block):
|
||||||
|
"""Two-level circle+jet construction on BOUNDS; block None keeps the dense fine level."""
|
||||||
|
return dict(refinements=[BOUNDS], level_blocks=[None, block],
|
||||||
|
level_objects=[(), (circle(),)], level_jets=[(), (jet(),)])
|
||||||
|
|
||||||
class RawExchangeGPU(unittest.TestCase):
|
class RawExchangeGPU(unittest.TestCase):
|
||||||
def test_row_ledger_interval_jet_switch_and_no_population_effect(self):
|
def test_row_ledger_interval_jet_switch_and_no_population_effect(self):
|
||||||
with CudaContext(0) as ctx:
|
with CudaContext(0) as ctx:
|
||||||
for block in ((32, 40), (16, 20), (8, 10)):
|
for block in ((32, 40), (16, 20), (8, 10)):
|
||||||
with FixedPatchStepper(CFG, BOUNDS, context=ctx, fine_block=block,
|
with FixedPatchStepper(CFG, context=ctx, **fine(block), observe_raw_exchange=True) as measured, \
|
||||||
fine_objects=[circle()], jets=[jet()], observe_raw_exchange=True) as measured, \
|
FixedPatchStepper(CFG, context=ctx, **fine(block)) as plain:
|
||||||
FixedPatchStepper(CFG, BOUNDS, context=ctx, fine_block=block,
|
|
||||||
fine_objects=[circle()], jets=[jet()]) as plain:
|
|
||||||
arrays = [state(l.shape) for l in measured._levels]
|
arrays = [state(l.shape) for l in measured._levels]
|
||||||
measured.initialize(*arrays)
|
measured.initialize(*arrays)
|
||||||
plain.initialize(*arrays)
|
plain.initialize(*arrays)
|
||||||
@@ -146,9 +150,8 @@ class RawExchangeGPU(unittest.TestCase):
|
|||||||
"""Same fine resolution/initial data with dense storage: a numerical
|
"""Same fine resolution/initial data with dense storage: a numerical
|
||||||
reference for cut-link rows, not a uniform-whole-domain convergence study."""
|
reference for cut-link rows, not a uniform-whole-domain convergence study."""
|
||||||
with CudaContext(0) as ctx:
|
with CudaContext(0) as ctx:
|
||||||
with FixedPatchStepper(CFG, BOUNDS, context=ctx, fine_objects=[circle()], jets=[jet()]) as dense, \
|
with FixedPatchStepper(CFG, context=ctx, **fine(None)) as dense, \
|
||||||
FixedPatchStepper(CFG, BOUNDS, context=ctx, fine_block=(16, 20),
|
FixedPatchStepper(CFG, context=ctx, **fine((16, 20)), observe_raw_exchange=True) as blocked:
|
||||||
fine_objects=[circle()], jets=[jet()], observe_raw_exchange=True) as blocked:
|
|
||||||
arrays = [state(l.shape) for l in blocked._levels]
|
arrays = [state(l.shape) for l in blocked._levels]
|
||||||
dense.initialize(*arrays)
|
dense.initialize(*arrays)
|
||||||
blocked.initialize(*arrays)
|
blocked.initialize(*arrays)
|
||||||
@@ -229,8 +232,7 @@ class RawExchangeGPU(unittest.TestCase):
|
|||||||
layout = BlockLayout2D.build(48, 64, 8, 8)
|
layout = BlockLayout2D.build(48, 64, 8, 8)
|
||||||
with CudaContext(0) as ctx:
|
with CudaContext(0) as ctx:
|
||||||
with PeriodicBlockStepper(fine_cfg, layout, context=ctx, objects=[obj]) as uniform, \
|
with PeriodicBlockStepper(fine_cfg, layout, context=ctx, objects=[obj]) as uniform, \
|
||||||
FixedPatchStepper(CFG, BOUNDS, context=ctx, fine_block=(16, 20),
|
FixedPatchStepper(CFG, context=ctx, **fine((16, 20)), observe_raw_exchange=True) as amr:
|
||||||
fine_objects=[circle()], jets=[jet()], observe_raw_exchange=True) as amr:
|
|
||||||
amr.initialize(*(state(l.shape) for l in amr._levels))
|
amr.initialize(*(state(l.shape) for l in amr._levels))
|
||||||
uniform.initialize(state((9, 48, 64)))
|
uniform.initialize(state((9, 48, 64)))
|
||||||
b = amr._level_boundaries[1]
|
b = amr._level_boundaries[1]
|
||||||
|
|||||||
@@ -83,11 +83,10 @@ def mocked_backend(mode="periodic", fail_alloc=None):
|
|||||||
class BlockedBaseCPU(unittest.TestCase):
|
class BlockedBaseCPU(unittest.TestCase):
|
||||||
def test_reject_before_cuda(self):
|
def test_reject_before_cuda(self):
|
||||||
context = Mock(activate=Mock(side_effect=AssertionError("CUDA reached")))
|
context = Mock(activate=Mock(side_effect=AssertionError("CUDA reached")))
|
||||||
for kwargs in ({"base_block": (12, 8)},
|
for blocks in ([(12, 8), None], [(7, 8), FINE_BLOCK], [(12,), FINE_BLOCK]):
|
||||||
{"base_block": (7, 8), "fine_block": FINE_BLOCK},
|
with self.subTest(blocks=blocks), self.assertRaises(ValueError):
|
||||||
{"base_block": (12,), "fine_block": FINE_BLOCK}):
|
FixedPatchStepper(config("periodic"), context=context, refinements=[BOUNDS],
|
||||||
with self.subTest(kwargs=kwargs), self.assertRaises(ValueError):
|
level_blocks=blocks)
|
||||||
FixedPatchStepper(config("periodic"), BOUNDS, context=context, **kwargs)
|
|
||||||
context.activate.assert_not_called()
|
context.activate.assert_not_called()
|
||||||
|
|
||||||
def test_all_arrival_rows_donors_and_kind_masks(self):
|
def test_all_arrival_rows_donors_and_kind_masks(self):
|
||||||
@@ -193,9 +192,10 @@ class BlockedBaseCPU(unittest.TestCase):
|
|||||||
|
|
||||||
def test_launch_order_stream_wall_constants_and_buffer_swaps(self):
|
def test_launch_order_stream_wall_constants_and_buffer_swaps(self):
|
||||||
with mocked_backend("slot_reservoir") as m:
|
with mocked_backend("slot_reservoir") as m:
|
||||||
backend = FixedPatchStepper(config("slot_reservoir"), BOUNDS, context=m["context"],
|
backend = FixedPatchStepper(config("slot_reservoir"), context=m["context"],
|
||||||
coarse_boundary="slot_reservoir", fine_block=FINE_BLOCK,
|
coarse_boundary="slot_reservoir", refinements=[BOUNDS],
|
||||||
base_block=(3, 4), fine_objects=[circle(actuation(.002))])
|
level_blocks=[(3, 4), FINE_BLOCK],
|
||||||
|
level_objects=[(), (circle(actuation(.002)),)])
|
||||||
try:
|
try:
|
||||||
backend.initialize(state(NY, NX, 1), state(*backend.patch.fine_shape, 2))
|
backend.initialize(state(NY, NX, 1), state(*backend.patch.fine_shape, 2))
|
||||||
coarse, fine = backend._levels
|
coarse, fine = backend._levels
|
||||||
@@ -236,16 +236,16 @@ class BlockedBaseCPU(unittest.TestCase):
|
|||||||
for fail_at in (1, 6, 10):
|
for fail_at in (1, 6, 10):
|
||||||
with self.subTest(fail_at=fail_at), mocked_backend(fail_alloc=fail_at) as m:
|
with self.subTest(fail_at=fail_at), mocked_backend(fail_alloc=fail_at) as m:
|
||||||
with self.assertRaisesRegex(MemoryError, "injected allocation"):
|
with self.assertRaisesRegex(MemoryError, "injected allocation"):
|
||||||
FixedPatchStepper(config("periodic"), BOUNDS, context=m["context"],
|
FixedPatchStepper(config("periodic"), context=m["context"], refinements=[BOUNDS],
|
||||||
fine_block=FINE_BLOCK, base_block=(3, 4))
|
level_blocks=[(3, 4), FINE_BLOCK])
|
||||||
self.assertEqual(len(m["allocations"]), fail_at)
|
self.assertEqual(len(m["allocations"]), fail_at)
|
||||||
for allocation in m["allocations"]:
|
for allocation in m["allocations"]:
|
||||||
allocation.free.assert_called_once_with()
|
allocation.free.assert_called_once_with()
|
||||||
|
|
||||||
def test_failed_parent_stage_cannot_publish_or_resume(self):
|
def test_failed_parent_stage_cannot_publish_or_resume(self):
|
||||||
with mocked_backend() as m:
|
with mocked_backend() as m:
|
||||||
backend = FixedPatchStepper(config("periodic"), BOUNDS, context=m["context"],
|
backend = FixedPatchStepper(config("periodic"), context=m["context"], refinements=[BOUNDS],
|
||||||
fine_block=FINE_BLOCK, base_block=(3, 4))
|
level_blocks=[(3, 4), FINE_BLOCK])
|
||||||
backend.initialize(state(NY, NX, 1), state(*backend.patch.fine_shape, 2))
|
backend.initialize(state(NY, NX, 1), state(*backend.patch.fine_shape, 2))
|
||||||
m["functions"]["BlockCoalesce"].side_effect = RuntimeError("injected parent stage failure")
|
m["functions"]["BlockCoalesce"].side_effect = RuntimeError("injected parent stage failure")
|
||||||
current = backend._levels[0].current
|
current = backend._levels[0].current
|
||||||
@@ -289,9 +289,10 @@ class BlockedBaseGPU(unittest.TestCase):
|
|||||||
for base_block in (None, *layouts):
|
for base_block in (None, *layouts):
|
||||||
label = f"{mode} width={width} speed={speed} base={base_block}"
|
label = f"{mode} width={width} speed={speed} base={base_block}"
|
||||||
snapshots = []
|
snapshots = []
|
||||||
with FixedPatchStepper(cfg, BOUNDS, context=context, coarse_boundary=mode,
|
with FixedPatchStepper(cfg, context=context, coarse_boundary=mode,
|
||||||
fine_block=FINE_BLOCK, base_block=base_block,
|
refinements=[BOUNDS], level_blocks=[base_block, FINE_BLOCK],
|
||||||
fine_objects=() if speed is None else [circle(actuation(speed))]) as backend:
|
level_objects=[(), () if speed is None
|
||||||
|
else (circle(actuation(speed)),)]) as backend:
|
||||||
backend.initialize(*arrays)
|
backend.initialize(*arrays)
|
||||||
for step in (0, 1, 2, 8):
|
for step in (0, 1, 2, 8):
|
||||||
if step == 1 and base_block is not None:
|
if step == 1 and base_block is not None:
|
||||||
|
|||||||
@@ -105,9 +105,10 @@ class BlockedFineCPU(unittest.TestCase):
|
|||||||
return Mock(activate=Mock(side_effect=AssertionError("CUDA reached")), sm_arch="sm_70")
|
return Mock(activate=Mock(side_effect=AssertionError("CUDA reached")), sm_arch="sm_70")
|
||||||
|
|
||||||
def test_rejections_before_cuda(self):
|
def test_rejections_before_cuda(self):
|
||||||
for kw in ({"fine_block": (7, 7)}, {"fine_block": (16,)}):
|
for kw in ({"level_blocks": [None, (7, 7)]}, {"level_blocks": [None, (16,)]}):
|
||||||
with self.subTest(kw=kw), self.assertRaises(ValueError):
|
with self.subTest(kw=kw), self.assertRaises(ValueError):
|
||||||
FixedPatchStepper(config("periodic"), BOUNDS, context=self.forbidden_context(), **kw)
|
FixedPatchStepper(config("periodic"), context=self.forbidden_context(),
|
||||||
|
refinements=[BOUNDS], **kw)
|
||||||
|
|
||||||
def test_single_block_layout_allocates_no_empty_halo_tables(self):
|
def test_single_block_layout_allocates_no_empty_halo_tables(self):
|
||||||
# A 1x1 non-periodic fine layout has zero halo pairs; CUDA rejects mem_alloc(0).
|
# A 1x1 non-periodic fine layout has zero halo pairs; CUDA rejects mem_alloc(0).
|
||||||
@@ -125,8 +126,8 @@ class BlockedFineCPU(unittest.TestCase):
|
|||||||
patch.object(compiler, "compile_kernel"), patch.object(compiler, "cleanup_build_dir"), \
|
patch.object(compiler, "compile_kernel"), patch.object(compiler, "cleanup_build_dir"), \
|
||||||
patch.object(compiler, "load_module", return_value=module), \
|
patch.object(compiler, "load_module", return_value=module), \
|
||||||
patch.object(cuda, "mem_alloc", side_effect=alloc), patch.object(cuda, "memcpy_htod"):
|
patch.object(cuda, "mem_alloc", side_effect=alloc), patch.object(cuda, "memcpy_htod"):
|
||||||
backend = FixedPatchStepper(config("periodic"), BOUNDS, context=context,
|
backend = FixedPatchStepper(config("periodic"), context=context, refinements=[BOUNDS],
|
||||||
fine_block=FINE_BLOCKS[0])
|
level_blocks=[None, FINE_BLOCKS[0]])
|
||||||
self.assertEqual(len(backend.fine_layout.halo_dst), 0)
|
self.assertEqual(len(backend.fine_layout.halo_dst), 0)
|
||||||
self.assertIsNone(backend._levels[1].halo_dst)
|
self.assertIsNone(backend._levels[1].halo_dst)
|
||||||
backend._gather_halo(backend._levels[1], Mock()) # no launch without pairs
|
backend._gather_halo(backend._levels[1], Mock()) # no launch without pairs
|
||||||
@@ -177,8 +178,9 @@ class BlockedFineCPU(unittest.TestCase):
|
|||||||
patch.object(cuda, "mem_alloc", side_effect=lambda size: Mock()), \
|
patch.object(cuda, "mem_alloc", side_effect=lambda size: Mock()), \
|
||||||
patch.object(cuda, "memcpy_htod"), \
|
patch.object(cuda, "memcpy_htod"), \
|
||||||
patch.object(curved_links, "CurvedLinkSoA", side_effect=AssertionError("dense SoA built")):
|
patch.object(curved_links, "CurvedLinkSoA", side_effect=AssertionError("dense SoA built")):
|
||||||
backend = FixedPatchStepper(config("periodic"), BOUNDS, context=context,
|
backend = FixedPatchStepper(config("periodic"), context=context, refinements=[BOUNDS],
|
||||||
fine_objects=objects, fine_block=FINE_BLOCKS[1])
|
level_blocks=[None, FINE_BLOCKS[1]],
|
||||||
|
level_objects=[(), tuple(objects)])
|
||||||
backend.initialize(state(NY, NX, 1), state(*backend.patch.fine_shape, 2))
|
backend.initialize(state(NY, NX, 1), state(*backend.patch.fine_shape, 2))
|
||||||
return backend, calls
|
return backend, calls
|
||||||
|
|
||||||
@@ -289,8 +291,9 @@ class BlockedFineGPU(unittest.TestCase):
|
|||||||
results = []
|
results = []
|
||||||
with CudaContext(0) as context:
|
with CudaContext(0) as context:
|
||||||
for fine_block in (None, *FINE_BLOCKS):
|
for fine_block in (None, *FINE_BLOCKS):
|
||||||
with FixedPatchStepper(cfg, BOUNDS, context=context, coarse_boundary=mode,
|
with FixedPatchStepper(cfg, context=context, coarse_boundary=mode,
|
||||||
fine_block=fine_block) as backend:
|
refinements=[BOUNDS],
|
||||||
|
level_blocks=[None, fine_block]) as backend:
|
||||||
backend.initialize(g_coarse, g_fine)
|
backend.initialize(g_coarse, g_fine)
|
||||||
backend.step(STEPS)
|
backend.step(STEPS)
|
||||||
self.assertEqual(backend.step_count, STEPS)
|
self.assertEqual(backend.step_count, STEPS)
|
||||||
@@ -318,8 +321,9 @@ class BlockedFineGPU(unittest.TestCase):
|
|||||||
results = []
|
results = []
|
||||||
with CudaContext(0) as context:
|
with CudaContext(0) as context:
|
||||||
for fine_block in (None, *FINE_BLOCKS):
|
for fine_block in (None, *FINE_BLOCKS):
|
||||||
with FixedPatchStepper(cfg, BOUNDS, context=context, coarse_boundary=mode,
|
with FixedPatchStepper(cfg, context=context, coarse_boundary=mode,
|
||||||
fine_objects=[circle()], fine_block=fine_block) as backend:
|
refinements=[BOUNDS], level_blocks=[None, fine_block],
|
||||||
|
level_objects=[(), (circle(),)]) as backend:
|
||||||
backend.initialize(g_coarse, g_fine)
|
backend.initialize(g_coarse, g_fine)
|
||||||
backend.step(STEPS)
|
backend.step(STEPS)
|
||||||
results.append((backend.download(), raw(backend)))
|
results.append((backend.download(), raw(backend)))
|
||||||
@@ -346,9 +350,9 @@ class BlockedFineGPU(unittest.TestCase):
|
|||||||
results = []
|
results = []
|
||||||
with CudaContext(0) as context:
|
with CudaContext(0) as context:
|
||||||
for fine_block in (None, *FINE_BLOCKS):
|
for fine_block in (None, *FINE_BLOCKS):
|
||||||
with FixedPatchStepper(cfg, BOUNDS, context=context, coarse_boundary=mode,
|
with FixedPatchStepper(cfg, context=context, coarse_boundary=mode,
|
||||||
fine_objects=[circle(actuation(speed))],
|
refinements=[BOUNDS], level_blocks=[None, fine_block],
|
||||||
fine_block=fine_block) as backend:
|
level_objects=[(), (circle(actuation(speed)),)]) as backend:
|
||||||
backend.initialize(g_coarse, g_fine)
|
backend.initialize(g_coarse, g_fine)
|
||||||
backend.step(STEPS)
|
backend.step(STEPS)
|
||||||
results.append((backend.download(), raw(backend)))
|
results.append((backend.download(), raw(backend)))
|
||||||
|
|||||||
@@ -94,7 +94,8 @@ class FaultGuardsCPU(unittest.TestCase):
|
|||||||
("slot_reservoir", (12, 4, 20, 21))):
|
("slot_reservoir", (12, 4, 20, 21))):
|
||||||
with self.subTest(mode=mode, bounds=bounds):
|
with self.subTest(mode=mode, bounds=bounds):
|
||||||
with self.assertRaises(ValueError):
|
with self.assertRaises(ValueError):
|
||||||
implementation.FixedPatchStepper(cfg, bounds, context=context, coarse_boundary=mode)
|
implementation.FixedPatchStepper(cfg, context=context, coarse_boundary=mode,
|
||||||
|
refinements=[bounds])
|
||||||
context.activate.assert_not_called()
|
context.activate.assert_not_called()
|
||||||
# Both exact channel limits and the original periodic two-cell margin
|
# Both exact channel limits and the original periodic two-cell margin
|
||||||
# must reach context activation, with no allocation or device required.
|
# must reach context activation, with no allocation or device required.
|
||||||
@@ -102,7 +103,8 @@ class FaultGuardsCPU(unittest.TestCase):
|
|||||||
("periodic", (2, 2, 6, 5))):
|
("periodic", (2, 2, 6, 5))):
|
||||||
with self.subTest(mode=mode, bounds=bounds):
|
with self.subTest(mode=mode, bounds=bounds):
|
||||||
with self.assertRaisesRegex(RuntimeError, "validated before CUDA"):
|
with self.assertRaisesRegex(RuntimeError, "validated before CUDA"):
|
||||||
implementation.FixedPatchStepper(cfg, bounds, context=context, coarse_boundary=mode)
|
implementation.FixedPatchStepper(cfg, context=context, coarse_boundary=mode,
|
||||||
|
refinements=[bounds])
|
||||||
|
|
||||||
def fake_backend(self):
|
def fake_backend(self):
|
||||||
backend = PeriodicPatchStepper.__new__(PeriodicPatchStepper)
|
backend = PeriodicPatchStepper.__new__(PeriodicPatchStepper)
|
||||||
@@ -154,12 +156,12 @@ class FaultGuardsCPU(unittest.TestCase):
|
|||||||
context = Mock(activate=nullcontext, sm_arch="sm_70")
|
context = Mock(activate=nullcontext, sm_arch="sm_70")
|
||||||
with patch.object(implementation, "HALO", 2):
|
with patch.object(implementation, "HALO", 2):
|
||||||
with self.assertRaisesRegex(RuntimeError, "four-cell"):
|
with self.assertRaisesRegex(RuntimeError, "four-cell"):
|
||||||
PeriodicPatchStepper(cfg, (4, 4, 12, 12), context=context)
|
PeriodicPatchStepper(cfg, context=context, refinements=[(4, 4, 12, 12)])
|
||||||
p = implementation.FixedPatch2D.from_config(cfg, (4, 4, 12, 12))
|
p = implementation.FixedPatch2D.from_config(cfg, (4, 4, 12, 12))
|
||||||
with patch.object(cuda, "Stream"), patch.object(implementation.FixedPatch2D, "from_config",
|
with patch.object(cuda, "Stream"), patch.object(implementation.FixedPatch2D, "from_config",
|
||||||
return_value=replace(p, tau_coarse=.9)):
|
return_value=replace(p, tau_coarse=.9)):
|
||||||
with self.assertRaisesRegex(RuntimeError, "omega/tau"):
|
with self.assertRaisesRegex(RuntimeError, "omega/tau"):
|
||||||
PeriodicPatchStepper(cfg, p.bounds, context=context)
|
PeriodicPatchStepper(cfg, context=context, refinements=[p.bounds])
|
||||||
module = Mock()
|
module = Mock()
|
||||||
module.get_global.return_value = (Mock(), 16)
|
module.get_global.return_value = (Mock(), 16)
|
||||||
with patch.object(cuda, "Stream"), patch.object(compiler, "generate_config"), \
|
with patch.object(cuda, "Stream"), patch.object(compiler, "generate_config"), \
|
||||||
@@ -167,7 +169,7 @@ class FaultGuardsCPU(unittest.TestCase):
|
|||||||
patch.object(compiler, "load_module", return_value=module), \
|
patch.object(compiler, "load_module", return_value=module), \
|
||||||
patch.object(cuda, "memcpy_htod") as upload:
|
patch.object(cuda, "memcpy_htod") as upload:
|
||||||
with self.assertRaisesRegex(RuntimeError, "layout mismatch"):
|
with self.assertRaisesRegex(RuntimeError, "layout mismatch"):
|
||||||
PeriodicPatchStepper(cfg, p.bounds, context=context)
|
PeriodicPatchStepper(cfg, context=context, refinements=[p.bounds])
|
||||||
upload.assert_not_called()
|
upload.assert_not_called()
|
||||||
|
|
||||||
|
|
||||||
@@ -241,7 +243,7 @@ class NormalBuildGPU(unittest.TestCase):
|
|||||||
max_error = max_bc_error = 0.0
|
max_error = max_bc_error = 0.0
|
||||||
with CudaContext(0) as context:
|
with CudaContext(0) as context:
|
||||||
with patch.object(compiler, "generate_config", side_effect=record_config):
|
with patch.object(compiler, "generate_config", side_effect=record_config):
|
||||||
backend = implementation.FixedPatchStepper(cfg, bounds, context=context,
|
backend = implementation.FixedPatchStepper(cfg, context=context, refinements=[bounds],
|
||||||
coarse_boundary="slot_reservoir")
|
coarse_boundary="slot_reservoir")
|
||||||
with backend:
|
with backend:
|
||||||
self.assertEqual(len(generated), 2)
|
self.assertEqual(len(generated), 2)
|
||||||
@@ -311,7 +313,8 @@ class NormalBuildGPU(unittest.TestCase):
|
|||||||
for a in (initial.coarse_f, initial.fine_f)))
|
for a in (initial.coarse_f, initial.fine_f)))
|
||||||
max_pop = max_drift = max_moment = 0.0
|
max_pop = max_drift = max_moment = 0.0
|
||||||
with CudaContext(0) as context, PeriodicPatchStepper(
|
with CudaContext(0) as context, PeriodicPatchStepper(
|
||||||
LBMConfig(nx=16, ny=16, viscosity=.1), (4, 4, 12, 12), context=context) as backend:
|
LBMConfig(nx=16, ny=16, viscosity=.1), context=context,
|
||||||
|
refinements=[(4, 4, 12, 12)]) as backend:
|
||||||
backend.initialize(*postcollision(state, spec, maps))
|
backend.initialize(*postcollision(state, spec, maps))
|
||||||
before = totals(backend.download(), maps)
|
before = totals(backend.download(), maps)
|
||||||
for step in range(1, 9):
|
for step in range(1, 9):
|
||||||
@@ -342,7 +345,7 @@ class NormalBuildGPU(unittest.TestCase):
|
|||||||
fine_mask[4:-4, 4:-4] = True
|
fine_mask[4:-4, 4:-4] = True
|
||||||
initial[1][:, ~fine_mask] = np.nan
|
initial[1][:, ~fine_mask] = np.nan
|
||||||
expected = scalar_interval(*[a.astype(np.float64) for a in initial], bounds)
|
expected = scalar_interval(*[a.astype(np.float64) for a in initial], bounds)
|
||||||
with CudaContext(0) as context, PeriodicPatchStepper(cfg, bounds, context=context) as backend:
|
with CudaContext(0) as context, PeriodicPatchStepper(cfg, context=context, refinements=[bounds]) as backend:
|
||||||
self.assertEqual(backend.patch.fine_shape, (14, 16))
|
self.assertEqual(backend.patch.fine_shape, (14, 16))
|
||||||
p = backend.patch
|
p = backend.patch
|
||||||
allocated = 2 * 9 * (17*13+16*14) * 4 + sum(a.nbytes for a in
|
allocated = 2 * 9 * (17*13+16*14) * 4 + sum(a.nbytes for a in
|
||||||
|
|||||||
@@ -84,13 +84,13 @@ class CoupledGPU(unittest.TestCase):
|
|||||||
|
|
||||||
cases = (("dense_unshifted", False, {}),
|
cases = (("dense_unshifted", False, {}),
|
||||||
("blocked_shifted", True,
|
("blocked_shifted", True,
|
||||||
dict(base_block=(4, 4), fine_block=(6, 6))))
|
dict(level_blocks=[(4, 4), (6, 6)])))
|
||||||
with CudaContext(0) as context:
|
with CudaContext(0) as context:
|
||||||
for label, shifted, storage in cases:
|
for label, shifted, storage in cases:
|
||||||
with self.subTest(storage=label):
|
with self.subTest(storage=label):
|
||||||
cfg = LBMConfig(nx=16, ny=16, viscosity=.0192,
|
cfg = LBMConfig(nx=16, ny=16, viscosity=.0192,
|
||||||
ddf_shifting=shifted)
|
ddf_shifting=shifted)
|
||||||
with FixedPatchStepper(cfg, (4, 4, 12, 12), context=context,
|
with FixedPatchStepper(cfg, context=context, refinements=[(4, 4, 12, 12)],
|
||||||
**storage) as backend:
|
**storage) as backend:
|
||||||
self.assertAlmostEqual(backend.patch.tau_coarse, spec.tau_coarse)
|
self.assertAlmostEqual(backend.patch.tau_coarse, spec.tau_coarse)
|
||||||
self.assertAlmostEqual(backend.patch.tau_fine, spec.tau_fine)
|
self.assertAlmostEqual(backend.patch.tau_fine, spec.tau_fine)
|
||||||
@@ -148,7 +148,7 @@ class CoupledGPU(unittest.TestCase):
|
|||||||
maps = ref.build_maps(spec)
|
maps = ref.build_maps(spec)
|
||||||
with CudaContext(0) as context:
|
with CudaContext(0) as context:
|
||||||
with PeriodicPatchStepper(LBMConfig(nx=16, ny=16, viscosity=.1),
|
with PeriodicPatchStepper(LBMConfig(nx=16, ny=16, viscosity=.1),
|
||||||
(4, 4, 12, 12), context=context) as backend:
|
context=context, refinements=[(4, 4, 12, 12)]) as backend:
|
||||||
backend.initialize(*postcollision(ref.make_state(spec), spec, maps))
|
backend.initialize(*postcollision(ref.make_state(spec), spec, maps))
|
||||||
coarse, fine = backend._levels
|
coarse, fine = backend._levels
|
||||||
|
|
||||||
@@ -187,7 +187,7 @@ class CoupledGPU(unittest.TestCase):
|
|||||||
|
|
||||||
with CudaContext(0) as context:
|
with CudaContext(0) as context:
|
||||||
with patch.object(compiler, "compile_kernel", audit_compile):
|
with patch.object(compiler, "compile_kernel", audit_compile):
|
||||||
backend = PeriodicPatchStepper(cfg, (4, 4, 12, 12), context=context)
|
backend = PeriodicPatchStepper(cfg, context=context, refinements=[(4, 4, 12, 12)])
|
||||||
with backend:
|
with backend:
|
||||||
# Production allocations: four DDF arrays and four compact tables.
|
# Production allocations: four DDF arrays and four compact tables.
|
||||||
device_bytes = 2 * 9 * (16**2 + 24**2) * 4
|
device_bytes = 2 * 9 * (16**2 + 24**2) * 4
|
||||||
@@ -270,7 +270,7 @@ class CoupledGPU(unittest.TestCase):
|
|||||||
backend.download()
|
backend.download()
|
||||||
|
|
||||||
# Compile and execute the actual non-audited entry as well: one step.
|
# Compile and execute the actual non-audited entry as well: one step.
|
||||||
with PeriodicPatchStepper(cfg, (4, 4, 12, 12), context=context) as plain:
|
with PeriodicPatchStepper(cfg, context=context, refinements=[(4, 4, 12, 12)]) as plain:
|
||||||
rest = postcollision(ref.make_state(spec), spec, maps)
|
rest = postcollision(ref.make_state(spec), spec, maps)
|
||||||
plain.initialize(*rest)
|
plain.initialize(*rest)
|
||||||
plain.step()
|
plain.step()
|
||||||
|
|||||||
@@ -41,8 +41,9 @@ def mocked(objects, jets, fine_block):
|
|||||||
patch.object(compiler, "load_module", return_value=module), \
|
patch.object(compiler, "load_module", return_value=module), \
|
||||||
patch.object(cuda, "mem_alloc", side_effect=lambda size: Mock()), \
|
patch.object(cuda, "mem_alloc", side_effect=lambda size: Mock()), \
|
||||||
patch.object(cuda, "memcpy_htod", htod):
|
patch.object(cuda, "memcpy_htod", htod):
|
||||||
backend = FixedPatchStepper(config("periodic"), BOUNDS, context=context,
|
backend = FixedPatchStepper(config("periodic"), context=context, refinements=[BOUNDS],
|
||||||
fine_objects=objects, fine_block=fine_block, jets=jets)
|
level_blocks=[None, fine_block], level_objects=[(), tuple(objects)],
|
||||||
|
level_jets=[(), tuple(jets)])
|
||||||
return backend, htod
|
return backend, htod
|
||||||
|
|
||||||
|
|
||||||
@@ -149,8 +150,9 @@ class JetStepperCPU(unittest.TestCase):
|
|||||||
def test_jet_overlapping_legacy_aperture_rejected_before_cuda(self):
|
def test_jet_overlapping_legacy_aperture_rejected_before_cuda(self):
|
||||||
with patch.object(cuda, "Stream", side_effect=AssertionError("CUDA touched")):
|
with patch.object(cuda, "Stream", side_effect=AssertionError("CUDA touched")):
|
||||||
with self.assertRaisesRegex(ValueError, "SurfaceActuation"):
|
with self.assertRaisesRegex(ValueError, "SurfaceActuation"):
|
||||||
FixedPatchStepper(config("periodic"), BOUNDS, context=Mock(),
|
FixedPatchStepper(config("periodic"), context=Mock(), refinements=[BOUNDS],
|
||||||
fine_objects=[circle(actuation(SPEED))], jets=[jet()])
|
level_objects=[(), (circle(actuation(SPEED)),)],
|
||||||
|
level_jets=[(), (jet(),)])
|
||||||
|
|
||||||
|
|
||||||
def run(mode, fine_block, *, objects, jets, switch=None):
|
def run(mode, fine_block, *, objects, jets, switch=None):
|
||||||
@@ -158,8 +160,9 @@ def run(mode, fine_block, *, objects, jets, switch=None):
|
|||||||
cfg = config(mode)
|
cfg = config(mode)
|
||||||
patch_ = FixedPatch2D.from_config(cfg, BOUNDS)
|
patch_ = FixedPatch2D.from_config(cfg, BOUNDS)
|
||||||
with CudaContext(0) as context, FixedPatchStepper(
|
with CudaContext(0) as context, FixedPatchStepper(
|
||||||
cfg, BOUNDS, context=context, coarse_boundary=mode, fine_objects=objects,
|
cfg, context=context, coarse_boundary=mode, refinements=[BOUNDS],
|
||||||
fine_block=fine_block, jets=jets) as backend:
|
level_blocks=[None, fine_block], level_objects=[(), tuple(objects)],
|
||||||
|
level_jets=[(), tuple(jets)]) as backend:
|
||||||
backend.initialize(state(NY, NX, 1), state(*patch_.fine_shape, 2))
|
backend.initialize(state(NY, NX, 1), state(*patch_.fine_shape, 2))
|
||||||
if switch is None:
|
if switch is None:
|
||||||
backend.step(STEPS)
|
backend.step(STEPS)
|
||||||
|
|||||||
@@ -42,8 +42,9 @@ class RefinementMRTGPU(unittest.TestCase):
|
|||||||
collision="MRT", ddf_shifting=shifted)
|
collision="MRT", ddf_shifting=shifted)
|
||||||
reference = None
|
reference = None
|
||||||
for block in ((32, 48), (8, 8), (4, 1)):
|
for block in ((32, 48), (8, 8), (4, 1)):
|
||||||
with FixedPatchStepper(cfg, (8, 6, 40, 26), context=context, coarse_boundary=boundary,
|
with FixedPatchStepper(cfg, context=context, coarse_boundary=boundary,
|
||||||
base_block=block, fine_block=(8, 8), fine_objects=(body,)) as backend:
|
refinements=[(8, 6, 40, 26)], level_blocks=[block, (8, 8)],
|
||||||
|
level_objects=[(), (body,)]) as backend:
|
||||||
backend.initialize(*[state(*level.shape[1:]) for level in backend._levels])
|
backend.initialize(*[state(*level.shape[1:]) for level in backend._levels])
|
||||||
backend.step(8)
|
backend.step(8)
|
||||||
raw = backend._download_raw()
|
raw = backend._download_raw()
|
||||||
@@ -63,8 +64,8 @@ class RefinementMRTGPU(unittest.TestCase):
|
|||||||
results = {}
|
results = {}
|
||||||
layouts = ((None, None), *((base, FINE_BLOCK) for base in (None, *BASE_BLOCKS)))
|
layouts = ((None, None), *((base, FINE_BLOCK) for base in (None, *BASE_BLOCKS)))
|
||||||
for base_block, fine_block in layouts:
|
for base_block, fine_block in layouts:
|
||||||
with FixedPatchStepper(cfg, BOUNDS, context=context, fine_block=fine_block,
|
with FixedPatchStepper(cfg, context=context, refinements=[BOUNDS],
|
||||||
base_block=base_block) as backend:
|
level_blocks=[base_block, fine_block]) as backend:
|
||||||
backend.initialize(*[fixture.state(*level.shape[1:], seed) for seed, level in enumerate(backend._levels)])
|
backend.initialize(*[fixture.state(*level.shape[1:], seed) for seed, level in enumerate(backend._levels)])
|
||||||
backend.step(4)
|
backend.step(4)
|
||||||
results[base_block, fine_block] = raw(backend)
|
results[base_block, fine_block] = raw(backend)
|
||||||
@@ -75,9 +76,9 @@ class RefinementMRTGPU(unittest.TestCase):
|
|||||||
def test_shifted_all_blocked_three_level_mrt_smoke(self):
|
def test_shifted_all_blocked_three_level_mrt_smoke(self):
|
||||||
"""Per-level shear rate omega_l = 1/(3*2**l*nu + 1/2); finite ACTIVE leaves."""
|
"""Per-level shear rate omega_l = 1/(3*2**l*nu + 1/2); finite ACTIVE leaves."""
|
||||||
cfg = LBMConfig(nx=16, ny=16, viscosity=.1, collision="MRT", ddf_shifting=True)
|
cfg = LBMConfig(nx=16, ny=16, viscosity=.1, collision="MRT", ddf_shifting=True)
|
||||||
kw = dict(fine_block=(4, 4), base_block=(4, 4), child=(8, 8, 16, 16), child_block=(4, 4))
|
kw = dict(refinements=[(4, 4, 12, 12), (8, 8, 16, 16)], level_blocks=[(4, 4)] * 3)
|
||||||
with CudaContext(0) as context:
|
with CudaContext(0) as context:
|
||||||
with FixedPatchStepper(cfg, (4, 4, 12, 12), context=context, **kw) as backend:
|
with FixedPatchStepper(cfg, context=context, **kw) as backend:
|
||||||
self.assertEqual(len(backend._level_cfgs), 3)
|
self.assertEqual(len(backend._level_cfgs), 3)
|
||||||
for level, level_cfg in enumerate(backend._level_cfgs):
|
for level, level_cfg in enumerate(backend._level_cfgs):
|
||||||
checked = replace(level_cfg)
|
checked = replace(level_cfg)
|
||||||
|
|||||||
@@ -26,6 +26,12 @@ FACE = ((4, 4, 8, 12), (12, 4, 16, 12))
|
|||||||
S1 = ((4, 4, 12, 12), (20, 4, 28, 12))
|
S1 = ((4, 4, 12, 12), (20, 4, 28, 12))
|
||||||
|
|
||||||
|
|
||||||
|
def levels(bounds, blocks=(None, None), objects=(), jets=(), **rest):
|
||||||
|
"""Two-level constructor keywords: one L1 rectangle or set, per-level blocks, L1 bodies/Jets."""
|
||||||
|
return dict(refinements=[bounds], level_blocks=list(blocks),
|
||||||
|
level_objects=[(), tuple(objects)], level_jets=[(), tuple(jets)], **rest)
|
||||||
|
|
||||||
|
|
||||||
def level_fine(patch_set, windows):
|
def level_fine(patch_set, windows):
|
||||||
"""Level-wide fine array with each patch window filled from `windows`."""
|
"""Level-wide fine array with each patch window filled from `windows`."""
|
||||||
out = np.full((9, *patch_set.fine_shape), np.nan, np.float32)
|
out = np.full((9, *patch_set.fine_shape), np.nan, np.float32)
|
||||||
@@ -45,21 +51,21 @@ class MultipatchCPU(unittest.TestCase):
|
|||||||
def test_rejections_before_cuda(self):
|
def test_rejections_before_cuda(self):
|
||||||
cfg = config("periodic")
|
cfg = config("periodic")
|
||||||
context = object() # never activated: every case must fail first
|
context = object() # never activated: every case must fail first
|
||||||
for kw in (dict(), dict(fine_block=(8, 4)), dict(base_block=(4, 4)),
|
for kw in (dict(), dict(blocks=(None, (8, 4))), dict(blocks=((4, 4), None)),
|
||||||
dict(fine_block=(8, 4), base_block=(4, 4), fine_objects=[circle()]),
|
dict(blocks=((4, 4), (8, 4)), objects=[circle()]),
|
||||||
dict(fine_block=(5, 4), base_block=(4, 4))):
|
dict(blocks=((4, 4), (5, 4)))):
|
||||||
with self.subTest(kw=kw), self.assertRaises(ValueError):
|
with self.subTest(kw=kw), self.assertRaises(ValueError):
|
||||||
FixedPatchStepper(cfg, ((4, 4, 8, 12), (14, 4, 18, 12)), context=context, **kw)
|
FixedPatchStepper(cfg, context=context, **levels(((4, 4, 8, 12), (14, 4, 18, 12)), **kw))
|
||||||
with self.assertRaisesRegex(ValueError, "margin"):
|
with self.assertRaisesRegex(ValueError, "margin"):
|
||||||
FixedPatchStepper(cfg, ((1, 4, 8, 12), (10, 4, 14, 12)), context=context,
|
FixedPatchStepper(cfg, context=context,
|
||||||
fine_block=(8, 4), base_block=(4, 4))
|
**levels(((1, 4, 8, 12), (10, 4, 14, 12)), blocks=((4, 4), (8, 4))))
|
||||||
from CelerisLab.body.jets import Jet, Parallel, Tube
|
from CelerisLab.body.jets import Jet, Parallel, Tube
|
||||||
cfg32 = LBMConfig(nx=32, ny=16, viscosity=.1)
|
cfg32 = LBMConfig(nx=32, ny=16, viscosity=.1)
|
||||||
span = Jet(Tube((5., 8.), 0., 22., .6), Parallel(0.), amplitude=0.)
|
span = Jet(Tube((5., 8.), 0., 22., .6), Parallel(0.), amplitude=0.)
|
||||||
with self.assertRaisesRegex(ValueError, "one jet"): # same obj_id cannot bypass it
|
with self.assertRaisesRegex(ValueError, "one jet"): # same obj_id cannot bypass it
|
||||||
FixedPatchStepper(cfg32, ((2, 2, 14, 14), (18, 2, 30, 14)), context=context,
|
FixedPatchStepper(cfg32, context=context,
|
||||||
fine_block=(4, 4), base_block=(4, 4),
|
**levels(((2, 2, 14, 14), (18, 2, 30, 14)), blocks=((4, 4), (4, 4)),
|
||||||
fine_objects=[body(8., 8.), body(24., 8.)], jets=[span])
|
objects=[body(8., 8.), body(24., 8.)], jets=[span]))
|
||||||
|
|
||||||
|
|
||||||
class MultipatchGPU(unittest.TestCase):
|
class MultipatchGPU(unittest.TestCase):
|
||||||
@@ -67,7 +73,7 @@ class MultipatchGPU(unittest.TestCase):
|
|||||||
|
|
||||||
def run_steps(self, context, cfg, bounds, coarse, fine, **kw):
|
def run_steps(self, context, cfg, bounds, coarse, fine, **kw):
|
||||||
out = []
|
out = []
|
||||||
with FixedPatchStepper(cfg, bounds, context=context, **kw) as backend:
|
with FixedPatchStepper(cfg, context=context, **levels(bounds, **kw)) as backend:
|
||||||
backend.initialize(coarse, fine)
|
backend.initialize(coarse, fine)
|
||||||
for step in self.STEPS:
|
for step in self.STEPS:
|
||||||
backend.step(step - backend.step_count)
|
backend.step(step - backend.step_count)
|
||||||
@@ -82,7 +88,7 @@ class MultipatchGPU(unittest.TestCase):
|
|||||||
p = FixedPatch2D.from_config(cfg, BOUNDS)
|
p = FixedPatch2D.from_config(cfg, BOUNDS)
|
||||||
s = FixedPatchSet2D.from_config(cfg, (BOUNDS,))
|
s = FixedPatchSet2D.from_config(cfg, (BOUNDS,))
|
||||||
coarse, fine = state(NY, NX, 1), state(*p.fine_shape, 2)
|
coarse, fine = state(NY, NX, 1), state(*p.fine_shape, 2)
|
||||||
kw = dict(coarse_boundary=mode, fine_block=(8, 4), base_block=(3, 4))
|
kw = dict(coarse_boundary=mode, blocks=((3, 4), (8, 4)))
|
||||||
old = self.run_steps(context, cfg, BOUNDS, coarse, fine, **kw)
|
old = self.run_steps(context, cfg, BOUNDS, coarse, fine, **kw)
|
||||||
new = self.run_steps(context, cfg, (BOUNDS,), coarse, level_fine(s, [fine]), **kw)
|
new = self.run_steps(context, cfg, (BOUNDS,), coarse, level_fine(s, [fine]), **kw)
|
||||||
for step, a, b in zip(self.STEPS, old, new):
|
for step, a, b in zip(self.STEPS, old, new):
|
||||||
@@ -99,7 +105,7 @@ class MultipatchGPU(unittest.TestCase):
|
|||||||
one = FixedPatchSet2D.from_config(cfg16, (S1[0],))
|
one = FixedPatchSet2D.from_config(cfg16, (S1[0],))
|
||||||
two = FixedPatchSet2D.from_config(cfg32, S1)
|
two = FixedPatchSet2D.from_config(cfg32, S1)
|
||||||
coarse, fine = state(16, 16, 3), state(*one.patches[0].fine_shape, 4)
|
coarse, fine = state(16, 16, 3), state(*one.patches[0].fine_shape, 4)
|
||||||
kw = dict(fine_block=(4, 4), base_block=(4, 4))
|
kw = dict(blocks=((4, 4), (4, 4)))
|
||||||
with CudaContext(0) as context:
|
with CudaContext(0) as context:
|
||||||
ref = self.run_steps(context, cfg16, (S1[0],), coarse, level_fine(one, [fine]), **kw)
|
ref = self.run_steps(context, cfg16, (S1[0],), coarse, level_fine(one, [fine]), **kw)
|
||||||
tiled = np.concatenate([coarse, coarse], axis=2)
|
tiled = np.concatenate([coarse, coarse], axis=2)
|
||||||
@@ -118,7 +124,7 @@ class MultipatchGPU(unittest.TestCase):
|
|||||||
s = FixedPatchSet2D.from_config(cfg, FACE)
|
s = FixedPatchSet2D.from_config(cfg, FACE)
|
||||||
coarse = state(16, 24, 5)
|
coarse = state(16, 24, 5)
|
||||||
fine = level_fine(s, [state(*p.fine_shape, 6 + i) for i, p in enumerate(s.patches)])
|
fine = level_fine(s, [state(*p.fine_shape, 6 + i) for i, p in enumerate(s.patches)])
|
||||||
kw = dict(fine_block=(4, 4), base_block=(4, 4))
|
kw = dict(blocks=((4, 4), (4, 4)))
|
||||||
leaf = s.fine_kind == ACTIVE
|
leaf = s.fine_kind == ACTIVE
|
||||||
support = s.fine_layout((4, 4)).owned
|
support = s.fine_layout((4, 4)).owned
|
||||||
outer = support & (s.fine_kind == OUTER_GHOST)
|
outer = support & (s.fine_kind == OUTER_GHOST)
|
||||||
@@ -164,7 +170,7 @@ class MultipatchBodiesGPU(unittest.TestCase):
|
|||||||
|
|
||||||
def run_steps(self, context, cfg, bounds, coarse, fine, switch=None, **kw):
|
def run_steps(self, context, cfg, bounds, coarse, fine, switch=None, **kw):
|
||||||
out = []
|
out = []
|
||||||
with FixedPatchStepper(cfg, bounds, context=context, **kw) as backend:
|
with FixedPatchStepper(cfg, context=context, **levels(bounds, **kw)) as backend:
|
||||||
backend.initialize(coarse, fine)
|
backend.initialize(coarse, fine)
|
||||||
for step in self.STEPS:
|
for step in self.STEPS:
|
||||||
if switch is not None and step == 8:
|
if switch is not None and step == 8:
|
||||||
@@ -182,8 +188,7 @@ class MultipatchBodiesGPU(unittest.TestCase):
|
|||||||
p = FixedPatch2D.from_config(cfg, BOUNDS)
|
p = FixedPatch2D.from_config(cfg, BOUNDS)
|
||||||
s = FixedPatchSet2D.from_config(cfg, (BOUNDS,))
|
s = FixedPatchSet2D.from_config(cfg, (BOUNDS,))
|
||||||
coarse, fine = state(NY, NX, 1), state(*p.fine_shape, 2)
|
coarse, fine = state(NY, NX, 1), state(*p.fine_shape, 2)
|
||||||
kw = dict(coarse_boundary=mode, fine_block=(8, 4), base_block=(3, 4),
|
kw = dict(coarse_boundary=mode, blocks=((3, 4), (8, 4)), objects=[circle()])
|
||||||
fine_objects=[circle()])
|
|
||||||
old = self.run_steps(context, cfg, BOUNDS, coarse, fine, **kw)
|
old = self.run_steps(context, cfg, BOUNDS, coarse, fine, **kw)
|
||||||
new = self.run_steps(context, cfg, (BOUNDS,), coarse, level_fine(s, [fine]), **kw)
|
new = self.run_steps(context, cfg, (BOUNDS,), coarse, level_fine(s, [fine]), **kw)
|
||||||
for step, a, b in zip(self.STEPS, old, new):
|
for step, a, b in zip(self.STEPS, old, new):
|
||||||
@@ -202,17 +207,17 @@ class MultipatchBodiesGPU(unittest.TestCase):
|
|||||||
two = FixedPatchSet2D.from_config(cfg32, self.PATCHES)
|
two = FixedPatchSet2D.from_config(cfg32, self.PATCHES)
|
||||||
coarse, fine = state(16, 16, 3), state(*one.patches[0].fine_shape, 4)
|
coarse, fine = state(16, 16, 3), state(*one.patches[0].fine_shape, 4)
|
||||||
jet = lambda x: Jet(Tube((x, 8.), 0., 6., .6), Parallel(0.), amplitude=.002)
|
jet = lambda x: Jet(Tube((x, 8.), 0., 6., .6), Parallel(0.), amplitude=.002)
|
||||||
kw = dict(fine_block=(4, 4), base_block=(4, 4))
|
kw = dict(blocks=((4, 4), (4, 4)))
|
||||||
with CudaContext(0) as context:
|
with CudaContext(0) as context:
|
||||||
for jets in ((), (jet(5.),)):
|
for jets in ((), (jet(5.),)):
|
||||||
ref = self.run_steps(context, cfg16, self.PATCHES[:1], coarse, level_fine(one, [fine]),
|
ref = self.run_steps(context, cfg16, self.PATCHES[:1], coarse, level_fine(one, [fine]),
|
||||||
switch=[(0, -.001)] if jets else None,
|
switch=[(0, -.001)] if jets else None,
|
||||||
fine_objects=[body(8., 8.)], jets=jets, **kw)
|
objects=[body(8., 8.)], jets=jets, **kw)
|
||||||
both = jets and (jet(5.), jet(21.))
|
both = jets and (jet(5.), jet(21.))
|
||||||
got = self.run_steps(context, cfg32, self.PATCHES, np.concatenate([coarse, coarse], 2),
|
got = self.run_steps(context, cfg32, self.PATCHES, np.concatenate([coarse, coarse], 2),
|
||||||
level_fine(two, [fine, fine]),
|
level_fine(two, [fine, fine]),
|
||||||
switch=[(0, -.001), (1, -.001)] if jets else None,
|
switch=[(0, -.001), (1, -.001)] if jets else None,
|
||||||
fine_objects=[body(8., 8., 5), body(24., 8., 5)],
|
objects=[body(8., 8., 5), body(24., 8., 5)],
|
||||||
jets=both or (), **kw)
|
jets=both or (), **kw)
|
||||||
for step, a, b in zip(self.STEPS, ref, got):
|
for step, a, b in zip(self.STEPS, ref, got):
|
||||||
label = f"jets={len(jets)} step {step}"
|
label = f"jets={len(jets)} step {step}"
|
||||||
|
|||||||
@@ -27,7 +27,16 @@ from test_refinement_blocked_base import raw
|
|||||||
|
|
||||||
CFG = LBMConfig(nx=16, ny=16, viscosity=.1)
|
CFG = LBMConfig(nx=16, ny=16, viscosity=.1)
|
||||||
L1, L2 = (4, 4, 12, 12), (8, 8, 16, 16)
|
L1, L2 = (4, 4, 12, 12), (8, 8, 16, 16)
|
||||||
KW = dict(fine_block=(4, 4), base_block=(4, 4), child=L2, child_block=(4, 4))
|
B = (4, 4)
|
||||||
|
|
||||||
|
|
||||||
|
def levels(l1=L1, l2=L2, blocks=(B, B, B), objects=((), (), ()), jets=((), (), ())):
|
||||||
|
"""Level-list keywords for the scalar L1 patch with one scalar L2 child."""
|
||||||
|
return dict(refinements=[l1, l2], level_blocks=list(blocks),
|
||||||
|
level_objects=list(objects), level_jets=list(jets))
|
||||||
|
|
||||||
|
|
||||||
|
KW = levels()
|
||||||
|
|
||||||
|
|
||||||
def child_body(spec=None):
|
def child_body(spec=None):
|
||||||
@@ -52,26 +61,29 @@ def mocked_child():
|
|||||||
patch.object(compiler, "load_module", return_value=module), \
|
patch.object(compiler, "load_module", return_value=module), \
|
||||||
patch.object(cuda, "mem_alloc", side_effect=lambda size: Mock()), \
|
patch.object(cuda, "mem_alloc", side_effect=lambda size: Mock()), \
|
||||||
patch.object(cuda, "memcpy_htod"):
|
patch.object(cuda, "memcpy_htod"):
|
||||||
return FixedPatchStepper(CFG, L1, context=context, child_objects=[child_body()],
|
return FixedPatchStepper(CFG, context=context,
|
||||||
child_jets=[child_jet()], **KW)
|
**levels(objects=((), (), (child_body(),)), jets=((), (), (child_jet(),))))
|
||||||
|
|
||||||
|
|
||||||
class ThreeLevelCPU(unittest.TestCase):
|
class ThreeLevelCPU(unittest.TestCase):
|
||||||
def test_rejections_before_cuda(self):
|
def test_rejections_before_cuda(self):
|
||||||
context = object() # never activated: every case must fail first
|
context = object() # never activated: every case must fail first
|
||||||
bad = (dict(KW, child_block=None), dict(KW, fine_block=None),
|
bad = (levels(blocks=(B, B, None)), levels(blocks=(B, None, B)),
|
||||||
dict(KW, fine_objects=[circle()]), dict(KW, child=(4, 8, 16, 16)),
|
levels(objects=((), (circle(),), ())), levels(l2=(4, 8, 16, 16)),
|
||||||
dict(KW, child_block=(5, 4)))
|
levels(blocks=(B, B, (5, 4))))
|
||||||
for kw in bad:
|
for kw in bad:
|
||||||
with self.subTest(kw=kw), self.assertRaises(ValueError):
|
with self.subTest(kw=kw), self.assertRaises(ValueError):
|
||||||
FixedPatchStepper(CFG, L1, context=context, **kw)
|
FixedPatchStepper(CFG, context=context, **kw)
|
||||||
for kw in (dict(child_objects=[child_body()]), dict(child_jets=[child_jet()]),
|
# L2 bodies/Jets without an L2 level (one entry too many), and an L2 Jet without a body.
|
||||||
dict(KW, child_jets=[child_jet()])):
|
two_level = dict(refinements=[L1], level_blocks=[None, None])
|
||||||
|
for kw in (dict(two_level, level_objects=[(), (), (child_body(),)]),
|
||||||
|
dict(two_level, level_jets=[(), (), (child_jet(),)]),
|
||||||
|
levels(jets=((), (), (child_jet(),)))):
|
||||||
with self.assertRaises(ValueError):
|
with self.assertRaises(ValueError):
|
||||||
FixedPatchStepper(CFG, L1, context=context, **kw)
|
FixedPatchStepper(CFG, context=context, **kw)
|
||||||
with self.assertRaises(ValueError): # several L1 patches + child: not yet
|
with self.assertRaises(ValueError): # several L1 patches + scalar child: not yet
|
||||||
FixedPatchStepper(LBMConfig(nx=32, ny=16, viscosity=.1), ((4, 4, 12, 12), (20, 4, 28, 12)),
|
FixedPatchStepper(LBMConfig(nx=32, ny=16, viscosity=.1), context=context,
|
||||||
context=context, **KW)
|
**levels(l1=((4, 4, 12, 12), (20, 4, 28, 12))))
|
||||||
|
|
||||||
|
|
||||||
def test_four_halo_bfl_steps_and_fresh_middle_feeds(self):
|
def test_four_halo_bfl_steps_and_fresh_middle_feeds(self):
|
||||||
@@ -80,11 +92,12 @@ class ThreeLevelCPU(unittest.TestCase):
|
|||||||
f, g = run._levels[1:]
|
f, g = run._levels[1:]
|
||||||
b = g.boundary
|
b = g.boundary
|
||||||
events, feeds = [], []
|
events, feeds = [], []
|
||||||
advance, gather = run._advance_child, run._gather_halo
|
advance, gather = run._advance, run._gather_halo
|
||||||
def record_feed(buffer, **kw):
|
def record_feed(index, buffer, **kw): # index 2: L1 hop feeds L2
|
||||||
self.assertIs(buffer, (f.current, f.spare)[len(feeds)])
|
if index == 2:
|
||||||
feeds.append(buffer)
|
self.assertIs(buffer, (f.current, f.spare)[len(feeds)])
|
||||||
advance(buffer, **kw)
|
feeds.append(buffer)
|
||||||
|
advance(index, buffer, **kw)
|
||||||
def record_halo(level, buffer, **kw):
|
def record_halo(level, buffer, **kw):
|
||||||
if level is g:
|
if level is g:
|
||||||
events.append(("halo", buffer))
|
events.append(("halo", buffer))
|
||||||
@@ -95,7 +108,7 @@ class ThreeLevelCPU(unittest.TestCase):
|
|||||||
self.assertIs(kind, g.kind)
|
self.assertIs(kind, g.kind)
|
||||||
events.append(("step", src))
|
events.append(("step", src))
|
||||||
g.kernel.side_effect = record_step
|
g.kernel.side_effect = record_step
|
||||||
with patch.object(run, "_advance_child", side_effect=record_feed), \
|
with patch.object(run, "_advance", side_effect=record_feed), \
|
||||||
patch.object(run, "_gather_halo", side_effect=record_halo):
|
patch.object(run, "_gather_halo", side_effect=record_halo):
|
||||||
run.step()
|
run.step()
|
||||||
self.assertEqual(feeds, [f.current, f.spare])
|
self.assertEqual(feeds, [f.current, f.spare])
|
||||||
@@ -105,8 +118,8 @@ class ThreeLevelCPU(unittest.TestCase):
|
|||||||
self.assertGreater(len(np.unique(b.tables["block"])), 1)
|
self.assertGreater(len(np.unique(b.tables["block"])), 1)
|
||||||
# Negative control: reusing L1's old source at the midpoint must fail.
|
# Negative control: reusing L1's old source at the midpoint must fail.
|
||||||
feeds.clear()
|
feeds.clear()
|
||||||
with patch.object(run, "_advance_child", side_effect=lambda buffer, **kw:
|
with patch.object(run, "_advance", side_effect=lambda index, buffer, **kw:
|
||||||
record_feed(f.current, **kw)):
|
record_feed(index, f.current if index == 2 else buffer, **kw)):
|
||||||
with self.assertRaises(AssertionError):
|
with self.assertRaises(AssertionError):
|
||||||
run.step()
|
run.step()
|
||||||
run.close()
|
run.close()
|
||||||
@@ -155,7 +168,7 @@ class ThreeLevelGPU(unittest.TestCase):
|
|||||||
def test_equilibrium_is_kept_on_every_level(self):
|
def test_equilibrium_is_kept_on_every_level(self):
|
||||||
from CelerisLab.cuda.context import CudaContext
|
from CelerisLab.cuda.context import CudaContext
|
||||||
feq = np.asarray(compute_feq_d2q9(1.0, .03, -.02), np.float32)[:, None, None]
|
feq = np.asarray(compute_feq_d2q9(1.0, .03, -.02), np.float32)[:, None, None]
|
||||||
with CudaContext(0) as ctx, FixedPatchStepper(CFG, L1, context=ctx, **KW) as run:
|
with CudaContext(0) as ctx, FixedPatchStepper(CFG, context=ctx, **KW) as run:
|
||||||
shapes = ((16, 16), run.patch.fine_shape, run.child_patch.fine_shape)
|
shapes = ((16, 16), run.patch.fine_shape, run.child_patch.fine_shape)
|
||||||
run.initialize(*(np.broadcast_to(feq, (9, *s)).copy() for s in shapes))
|
run.initialize(*(np.broadcast_to(feq, (9, *s)).copy() for s in shapes))
|
||||||
run.step(8)
|
run.step(8)
|
||||||
@@ -168,15 +181,16 @@ class ThreeLevelGPU(unittest.TestCase):
|
|||||||
|
|
||||||
def test_nonequilibrium_masks_and_fresh_middle_feeds(self):
|
def test_nonequilibrium_masks_and_fresh_middle_feeds(self):
|
||||||
from CelerisLab.cuda.context import CudaContext
|
from CelerisLab.cuda.context import CudaContext
|
||||||
with CudaContext(0) as ctx, FixedPatchStepper(CFG, L1, context=ctx, **KW) as run:
|
with CudaContext(0) as ctx, FixedPatchStepper(CFG, context=ctx, **KW) as run:
|
||||||
p1, p2 = run.patch, run.child_patch
|
p1, p2 = run.patch, run.child_patch
|
||||||
run.initialize(state(16, 16, 1), state(*p1.fine_shape, 2), state(*p2.fine_shape, 3))
|
run.initialize(state(16, 16, 1), state(*p1.fine_shape, 2), state(*p2.fine_shape, 3))
|
||||||
f = run._levels[1]
|
f = run._levels[1]
|
||||||
feeds, original = [], run._advance_child
|
feeds, original = [], run._advance
|
||||||
def record(buffer, **kw):
|
def record(index, buffer, **kw): # index 2: L1 hop feeds L2
|
||||||
feeds.append(int(buffer))
|
if index == 2:
|
||||||
original(buffer, **kw)
|
feeds.append(int(buffer))
|
||||||
with patch.object(run, "_advance_child", side_effect=record):
|
original(index, buffer, **kw)
|
||||||
|
with patch.object(run, "_advance", side_effect=record):
|
||||||
cur, spare = int(f.current), int(f.spare)
|
cur, spare = int(f.current), int(f.spare)
|
||||||
run.step(1)
|
run.step(1)
|
||||||
self.assertEqual(feeds, [cur, spare]) # current G, then the new G of hop 1
|
self.assertEqual(feeds, [cur, spare]) # current G, then the new G of hop 1
|
||||||
@@ -203,8 +217,9 @@ class ThreeLevelBodyGPU(unittest.TestCase):
|
|||||||
CFG, velocity=0., wall_normal_velocity=.001, wall_slot_width=4,
|
CFG, velocity=0., wall_normal_velocity=.001, wall_slot_width=4,
|
||||||
y_wall_bc="on_site_velocity", top_wall_bc="reservoir")
|
y_wall_bc="on_site_velocity", top_wall_bc="reservoir")
|
||||||
with CudaContext(0) as ctx, FixedPatchStepper(
|
with CudaContext(0) as ctx, FixedPatchStepper(
|
||||||
cfg, L1, context=ctx, coarse_boundary=mode, child_objects=[child_body(spec)],
|
cfg, context=ctx, coarse_boundary=mode,
|
||||||
child_jets=jets, **dict(KW, child_block=block)) as run:
|
**levels(blocks=(B, B, block), objects=((), (), (child_body(spec),)),
|
||||||
|
jets=((), (), tuple(jets)))) as run:
|
||||||
run.initialize(*(state(*level.shape[1:], i + 1) for i, level in enumerate(run._levels)))
|
run.initialize(*(state(*level.shape[1:], i + 1) for i, level in enumerate(run._levels)))
|
||||||
snapshots = []
|
snapshots = []
|
||||||
for stop in (0, 1, 2, 4, 8):
|
for stop in (0, 1, 2, 4, 8):
|
||||||
|
|||||||
@@ -78,10 +78,10 @@ class ThreeLevelMultipatchGPU(unittest.TestCase):
|
|||||||
def run_case(self, ctx, cfg=CFG, parents=PARENTS, children=CHILDREN,
|
def run_case(self, ctx, cfg=CFG, parents=PARENTS, children=CHILDREN,
|
||||||
mode='periodic', blocks=((4, 4), (4, 4)), objects=(), drive=(), switch=False,
|
mode='periodic', blocks=((4, 4), (4, 4)), objects=(), drive=(), switch=False,
|
||||||
scalar_child=None):
|
scalar_child=None):
|
||||||
kwargs = dict(child_rectangles_in_parent=children) if scalar_child is None else dict(child=scalar_child)
|
child = children if scalar_child is None else scalar_child
|
||||||
with FixedPatchStepper(config(cfg, mode), parents, context=ctx, coarse_boundary=mode,
|
with FixedPatchStepper(config(cfg, mode), context=ctx, coarse_boundary=mode,
|
||||||
base_block=(4, 4), fine_block=blocks[0], child_block=blocks[1],
|
refinements=[parents, child], level_blocks=[(4, 4), blocks[0], blocks[1]],
|
||||||
child_objects=objects, child_jets=drive, **kwargs) as run:
|
level_objects=[(), (), objects], level_jets=[(), (), drive]) as run:
|
||||||
frame = frames(run)
|
frame = frames(run)
|
||||||
run.initialize(*(physical_state(level.shape[1:], *f)
|
run.initialize(*(physical_state(level.shape[1:], *f)
|
||||||
for level, f in zip(run._levels, frame)))
|
for level, f in zip(run._levels, frame)))
|
||||||
|
|||||||
@@ -26,9 +26,8 @@ FP64_ATOL = 3e-6
|
|||||||
|
|
||||||
|
|
||||||
def make(ctx):
|
def make(ctx):
|
||||||
return FixedPatchStepper(CFG, PARENTS, context=ctx, base_block=(4, 4),
|
return FixedPatchStepper(CFG, context=ctx, refinements=[PARENTS, A],
|
||||||
fine_block=(4, 4), child_block=(4, 4),
|
level_blocks=[(4, 4)] * 3)
|
||||||
child_rectangles_in_parent=A)
|
|
||||||
|
|
||||||
|
|
||||||
def initial(run, uniform):
|
def initial(run, uniform):
|
||||||
|
|||||||
@@ -136,8 +136,8 @@ class ShiftedJetsGPU(unittest.TestCase):
|
|||||||
Parallel(0.),amplitude=.013)
|
Parallel(0.),amplitude=.013)
|
||||||
for rho in (.99,1.01):
|
for rho in (.99,1.01):
|
||||||
with self.subTest(rho=rho),CudaContext(0) as ctx:
|
with self.subTest(rho=rho),CudaContext(0) as ctx:
|
||||||
with FixedPatchStepper(cfg,(8,6,24,18),context=ctx,base_block=(4,4),fine_block=(4,4),
|
with FixedPatchStepper(cfg,context=ctx,refinements=[(8,6,24,18)],level_blocks=[(4,4)]*2,
|
||||||
fine_objects=(obj,),jets=(whole,),observe_raw_exchange=True) as run:
|
level_objects=[(),(obj,)],level_jets=[(),(whole,)],observe_raw_exchange=True) as run:
|
||||||
run._initialize_raw(initial(run,rho,u=.013,v=0.))
|
run._initialize_raw(initial(run,rho,u=.013,v=0.))
|
||||||
expected=run._download_raw();ledger=Ledger(self,run,1)
|
expected=run._download_raw();ledger=Ledger(self,run,1)
|
||||||
self.assertTrue(run._level_boundaries[1].tables['aperture'].all())
|
self.assertTrue(run._level_boundaries[1].tables['aperture'].all())
|
||||||
@@ -153,7 +153,8 @@ class ShiftedJetsGPU(unittest.TestCase):
|
|||||||
obj=circle((16.,12.),2.15);j=drive((16.,12.),2.15)
|
obj=circle((16.,12.),2.15);j=drive((16.,12.),2.15)
|
||||||
for rho in (.99,1.01):
|
for rho in (.99,1.01):
|
||||||
with self.subTest(rho=rho),CudaContext(0) as ctx,ExitStack() as owned:
|
with self.subTest(rho=rho),CudaContext(0) as ctx,ExitStack() as owned:
|
||||||
settings=dict(bounds=(8,6,24,18),context=ctx,base_block=(4,4),fine_block=(4,4),fine_objects=(obj,),jets=(j,))
|
settings=dict(context=ctx,refinements=[(8,6,24,18)],level_blocks=[(4,4)]*2,
|
||||||
|
level_objects=[(),(obj,)],level_jets=[(),(j,)])
|
||||||
measured=owned.enter_context(FixedPatchStepper(cfg,observe_raw_exchange=True,**settings))
|
measured=owned.enter_context(FixedPatchStepper(cfg,observe_raw_exchange=True,**settings))
|
||||||
plain=owned.enter_context(FixedPatchStepper(cfg,**settings))
|
plain=owned.enter_context(FixedPatchStepper(cfg,**settings))
|
||||||
measured._initialize_raw(initial(measured,rho));plain._initialize_raw(initial(plain,rho))
|
measured._initialize_raw(initial(measured,rho));plain._initialize_raw(initial(plain,rho))
|
||||||
@@ -186,8 +187,9 @@ class ShiftedJetsGPU(unittest.TestCase):
|
|||||||
parents=((4,4,20,28),(24,4,44,28));a=((16,16,32,40),(56,16,72,40));b=(a[0],(60,16,76,40))
|
parents=((4,4,20,28),(24,4,44,28));a=((16,16,32,40),(56,16,72,40));b=(a[0],(60,16,76,40))
|
||||||
obj=circle((12.,14.),.8);j=drive((12.,14.),.8)
|
obj=circle((12.,14.),.8);j=drive((12.,14.),.8)
|
||||||
with CudaContext(0) as ctx,ExitStack() as owned:
|
with CudaContext(0) as ctx,ExitStack() as owned:
|
||||||
old=owned.enter_context(FixedPatchStepper(cfg,parents,context=ctx,base_block=(4,4),fine_block=(4,4),
|
old=owned.enter_context(FixedPatchStepper(cfg,context=ctx,refinements=[parents,a],
|
||||||
child_block=(4,4),child_rectangles_in_parent=a,child_objects=(obj,),child_jets=(j,),observe_raw_exchange=True))
|
level_blocks=[(4,4)]*3,level_objects=[(),(),(obj,)],level_jets=[(),(),(j,)],
|
||||||
|
observe_raw_exchange=True))
|
||||||
old._initialize_raw(initial(old,.99));ledger=Ledger(self,old,2)
|
old._initialize_raw(initial(old,.99));ledger=Ledger(self,old,2)
|
||||||
for speed in (.002,-.001):old.set_jet_amplitude(0,speed,level=2);ledger.step()
|
for speed in (.002,-.001):old.set_jet_amplitude(0,speed,level=2);ledger.step()
|
||||||
before=old._download_raw();count=old.step_count
|
before=old._download_raw();count=old.step_count
|
||||||
|
|||||||
@@ -22,9 +22,8 @@ B=((20,16,36,40),)
|
|||||||
|
|
||||||
|
|
||||||
def make(ctx):
|
def make(ctx):
|
||||||
return FixedPatchStepper(CFG,PARENTS,context=ctx,base_block=(4,4),
|
return FixedPatchStepper(CFG,context=ctx,refinements=[PARENTS,A],
|
||||||
fine_block=(4,4),child_block=(4,4),
|
level_blocks=[(4,4)]*3)
|
||||||
child_rectangles_in_parent=A)
|
|
||||||
|
|
||||||
|
|
||||||
def initial(run):
|
def initial(run):
|
||||||
|
|||||||
@@ -0,0 +1,222 @@
|
|||||||
|
"""Steady DFG 2D-1 (Re 20): refined and uniform runs against the official reference intervals.
|
||||||
|
|
||||||
|
Not a full benchmark certification. Declared deviations from the official setup:
|
||||||
|
pressure-NEQ outlet (``neq_extrap``) instead of do-nothing, local Zou-He inlet.
|
||||||
|
Geometry, inflow profile, initial state, refined layout and observation reuse the
|
||||||
|
pinned Re100 runner (``run_refined_dfg``) and ``re100_helpers`` unchanged; only the
|
||||||
|
lattice viscosity is set for Re 20 (nu = U_lattice * D / 20 at the root level).
|
||||||
|
|
||||||
|
Units. The helpers use scaled DFG units with mean inflow speed 1, so
|
||||||
|
Cd = 2 Fx / (rho U^2 D) and Cl = 2 Fy / (rho U^2 D) are scale-free, and
|
||||||
|
``pressure_probes`` returns dp / (rho U^2). The official p_diff = p(0.15, 0.2) -
|
||||||
|
p(0.25, 0.2) uses U = 0.2 m/s, rho = 1, so p_diff = dp * 0.04. Both are reported;
|
||||||
|
only p_diff is compared with the official interval. Forces use the existing sign
|
||||||
|
convention: F is the force of the fluid on the cylinder, i.e. the refined raw
|
||||||
|
exchange impulse (window ledger, ``total.impulse``) or the uniform ``read_force``,
|
||||||
|
with x along the inflow and y up from the bottom wall. Cd must be positive, and the
|
||||||
|
official Cl is positive (centre 0.20 below the centreline 0.205), so a flipped sign
|
||||||
|
shows up as Cl outside its interval.
|
||||||
|
|
||||||
|
Sampling. One sample every SAMPLE_TSTAR (t* = U t / D; 0.25 s), taken at the end of
|
||||||
|
a completed root step with all levels synchronized; the step index is recorded. Cd
|
||||||
|
and Cl are means over the sample interval (window exchange ledger refined, per-batch
|
||||||
|
forces uniform), which filters acoustic and step-parity oscillation; p_diff is the
|
||||||
|
end-of-interval value at the exact surface points.
|
||||||
|
|
||||||
|
Steady rule (our engineering choice, frozen before any run; not official). Over the
|
||||||
|
trailing WINDOW_TSTAR (t* 50..60 inclusive, 21 samples), for each of Cd, Cl and
|
||||||
|
p_diff: range (max - min) <= 10 % and |least-squares slope * window| <= 2 % of the
|
||||||
|
width of its official interval. Absolute limits, so the small Cl is never a divisor;
|
||||||
|
the slope term bounds slow monotone drift that the range alone would pass. If the
|
||||||
|
rule fails at TSTAR_MAX the run reports "not steady" and gives no interval verdict;
|
||||||
|
limits are never relaxed after a run. The verdict uses the window mean, and the
|
||||||
|
distance of each mean to its nearest interval edge is reported (negative outside).
|
||||||
|
"""
|
||||||
|
|
||||||
|
import argparse
|
||||||
|
import json
|
||||||
|
import math
|
||||||
|
import os
|
||||||
|
from pathlib import Path
|
||||||
|
import sys
|
||||||
|
import time
|
||||||
|
from tempfile import TemporaryDirectory
|
||||||
|
|
||||||
|
import numpy as np
|
||||||
|
|
||||||
|
HERE = Path(__file__).resolve().parent
|
||||||
|
sys.path.insert(0, str(HERE))
|
||||||
|
import run_refined_dfg as rr # noqa: E402
|
||||||
|
|
||||||
|
RE = 20.0
|
||||||
|
U_PHYS = 0.2 # m/s mean inflow; rho = 1
|
||||||
|
TSTAR_MAX = 60.0 # 30 s physical
|
||||||
|
SAMPLE_TSTAR = 0.5 # 0.25 s
|
||||||
|
WINDOW_TSTAR = 10.0 # trailing 5 s, 21 samples
|
||||||
|
# Schaefer & Turek (1996), 2D-1 lower/upper bounds.
|
||||||
|
BANDS = dict(cd=(5.57, 5.59), cl=(0.0104, 0.0110), p_diff=(0.1172, 0.1176))
|
||||||
|
STEADY_RANGE = {k: (hi - lo) / 10 for k, (lo, hi) in BANDS.items()}
|
||||||
|
STEADY_SLOPE = {k: (hi - lo) / 50 for k, (lo, hi) in BANDS.items()}
|
||||||
|
DEVIATIONS = ("pressure-NEQ outlet (neq_extrap), not do-nothing", "local Zou-He inlet")
|
||||||
|
|
||||||
|
_re100_config = rr.config
|
||||||
|
|
||||||
|
|
||||||
|
def config(h, diameter, collision="SRT", jet_scenario="none"):
|
||||||
|
"""The pinned Re100 configuration with the lattice viscosity set for Re 20."""
|
||||||
|
if jet_scenario != "none":
|
||||||
|
raise ValueError("DFG 2D-1 runs have no Jets")
|
||||||
|
cfg, body, p = _re100_config(h, diameter, collision, jet_scenario)
|
||||||
|
nu = p["mean_speed"] * p["diameter"] / RE
|
||||||
|
cfg["physics"]["viscosity"] = nu
|
||||||
|
return cfg, body, dict(p, viscosity=nu, re=RE)
|
||||||
|
|
||||||
|
|
||||||
|
def lattice_parameters(diameter, speed=rr.SPEED):
|
||||||
|
nu = speed * diameter / RE
|
||||||
|
return dict(viscosity=nu, tau=0.5 + 3 * nu, steps=math.ceil(TSTAR_MAX * diameter / speed),
|
||||||
|
interval=round(SAMPLE_TSTAR * diameter / speed))
|
||||||
|
|
||||||
|
|
||||||
|
def sample(impulse, n, diameter, dp):
|
||||||
|
den = rr.SPEED**2 * diameter / 2
|
||||||
|
return dict(cd=float(impulse[0] / n / den), cl=float(impulse[1] / n / den),
|
||||||
|
dp_scaled=float(dp), p_diff=float(dp) * U_PHYS**2)
|
||||||
|
|
||||||
|
|
||||||
|
def summarize(rows):
|
||||||
|
"""Steady rule over the trailing window, then the interval verdict (or none)."""
|
||||||
|
if not rows or rows[-1]["tstar"] < TSTAR_MAX - 1e-9:
|
||||||
|
return dict(status="INCOMPLETE", steady=False, verdict=None)
|
||||||
|
window = [r for r in rows if r["tstar"] >= TSTAR_MAX - WINDOW_TSTAR - 1e-9]
|
||||||
|
t = np.array([r["tstar"] for r in window])
|
||||||
|
ranges = {k: max(r[k] for r in window) - min(r[k] for r in window) for k in BANDS}
|
||||||
|
drifts = {k: abs(np.polyfit(t, [r[k] for r in window], 1)[0]) * WINDOW_TSTAR for k in BANDS}
|
||||||
|
steady = all(ranges[k] <= STEADY_RANGE[k] and drifts[k] <= STEADY_SLOPE[k] for k in BANDS)
|
||||||
|
final = {k: float(np.mean([r[k] for r in window])) for k in BANDS}
|
||||||
|
edge = {k: min(final[k] - BANDS[k][0], BANDS[k][1] - final[k]) for k in BANDS}
|
||||||
|
result = dict(window_samples=len(window), ranges=ranges, drifts=drifts,
|
||||||
|
range_limits=STEADY_RANGE, slope_limits=STEADY_SLOPE, steady=steady,
|
||||||
|
window_mean=final, edge_distance=edge, bands=BANDS,
|
||||||
|
deviations=DEVIATIONS, cd_positive=final["cd"] > 0)
|
||||||
|
if not steady:
|
||||||
|
return dict(result, status="NOT_STEADY", verdict=None)
|
||||||
|
inside = {k: BANDS[k][0] <= final[k] <= BANDS[k][1] for k in BANDS}
|
||||||
|
return dict(result, status="WITHIN_INTERVALS" if all(inside.values()) else "OUTSIDE_INTERVALS",
|
||||||
|
verdict=inside)
|
||||||
|
|
||||||
|
|
||||||
|
def healthy(row):
|
||||||
|
return row["max_mach"] <= 0.2 and row["rho_min"] >= 0.5 and row["rho_max"] <= 1.5
|
||||||
|
|
||||||
|
|
||||||
|
def run_case(a, h, case):
|
||||||
|
from contextlib import ExitStack
|
||||||
|
from CelerisLab.cuda.context import CudaContext
|
||||||
|
from CelerisLab.lbm.descriptors import FLUID
|
||||||
|
from CelerisLab.lbm.refinement_stepper import FixedPatchStepper
|
||||||
|
from CelerisLab.simulation import Simulation
|
||||||
|
|
||||||
|
refined = case == "refined"
|
||||||
|
cfgdict, bodydict, p = config(h, 40 if refined else 80, a.collision)
|
||||||
|
lp = lattice_parameters(p["diameter"])
|
||||||
|
rows = []
|
||||||
|
with ExitStack() as stack:
|
||||||
|
if refined:
|
||||||
|
cfg, pair, body, host = rr.host_geometry(a.source, h, a.collision)
|
||||||
|
context = stack.enter_context(CudaContext(0))
|
||||||
|
backend = stack.enter_context(FixedPatchStepper(
|
||||||
|
cfg, 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
|
||||||
|
from CelerisLab.lbm.descriptors import SOLID
|
||||||
|
masks = [channel_masks(pair.coarse_shape)[0] & ~pair.covered,
|
||||||
|
(pair.fine_kind == ACTIVE)
|
||||||
|
& ((host.flags.reshape(pair.fine_shape) & SOLID) == 0)]
|
||||||
|
backend.initialize(rr.initial_state(pair.coarse_shape, (0.0, 0.0), 1.0, root=True),
|
||||||
|
rr.initial_state(pair.fine_shape, pair.fine_origin, 0.5))
|
||||||
|
probe_p = dict(p, center=[(80.5 - pair.fine_origin[0]) / 0.5 - 0.5,
|
||||||
|
(81.0 - pair.fine_origin[1]) / 0.5 - 0.5], radius=40.0)
|
||||||
|
else:
|
||||||
|
tmp = Path(stack.enter_context(TemporaryDirectory()))
|
||||||
|
(tmp / "lbm.json").write_text(json.dumps(cfgdict))
|
||||||
|
(tmp / "body.json").write_text(json.dumps(bodydict))
|
||||||
|
sim = stack.enter_context(Simulation(str(tmp / "lbm.json"), str(tmp / "body.json"),
|
||||||
|
device_id=0))
|
||||||
|
sim.initialize()
|
||||||
|
probe_p = p
|
||||||
|
fluid = (sim.field.flag.reshape(p["ny"], p["nx"]) & FLUID) != 0
|
||||||
|
begin = 0
|
||||||
|
while begin < lp["steps"]:
|
||||||
|
rr.check_deadline(a.deadline)
|
||||||
|
n = min(lp["interval"], lp["steps"] - begin)
|
||||||
|
if refined:
|
||||||
|
impulse = rr.advance_refined_interval(backend, n, a.deadline, "window")
|
||||||
|
fields = [rr.macros(g) for g in backend.download()]
|
||||||
|
rho, ux, uy = fields[1]
|
||||||
|
fluid = masks[1]
|
||||||
|
vals = [tuple(v[m] for v in f) for m, f in zip(masks, fields)]
|
||||||
|
else:
|
||||||
|
impulse, done = np.zeros(2), 0
|
||||||
|
while done < n:
|
||||||
|
batch = min(100, n - done)
|
||||||
|
sim.run(batch)
|
||||||
|
impulse += sim.read_force(0).astype(np.float64) * batch
|
||||||
|
done += batch
|
||||||
|
m = sim.get_macroscopic()
|
||||||
|
rho, ux, uy = [np.asarray(m[k], np.float64).reshape(p["ny"], p["nx"])
|
||||||
|
for k in ("rho", "ux", "uy")]
|
||||||
|
vals = [(rho[fluid], ux[fluid], uy[fluid])]
|
||||||
|
begin += n
|
||||||
|
row = dict(step=begin, tstar=begin * rr.SPEED / p["diameter"],
|
||||||
|
**sample(impulse, n, p["diameter"],
|
||||||
|
h.pressure_probes(rho, fluid, probe_p)["dp"]),
|
||||||
|
rho_min=float(min(v[0].min() for v in vals)),
|
||||||
|
rho_max=float(max(v[0].max() for v in vals)),
|
||||||
|
max_mach=float(max(np.sqrt(3 * (v[1]**2 + v[2]**2)).max() for v in vals)))
|
||||||
|
rr.ensure_finite(row)
|
||||||
|
rows.append(row)
|
||||||
|
if not healthy(row):
|
||||||
|
break
|
||||||
|
summary = summarize(rows) if healthy(rows[-1]) else dict(status="UNHEALTHY", steady=False,
|
||||||
|
verdict=None)
|
||||||
|
return dict(case=case, collision=a.collision, lattice=lp, rows=rows, **summary)
|
||||||
|
|
||||||
|
|
||||||
|
def plan(collision="SRT"):
|
||||||
|
return dict(re=RE, collision=collision, tstar_max=TSTAR_MAX, sample_tstar=SAMPLE_TSTAR,
|
||||||
|
window_tstar=WINDOW_TSTAR, bands=BANDS, range_limits=STEADY_RANGE, slope_limits=STEADY_SLOPE,
|
||||||
|
deviations=DEVIATIONS, pressure_scale=U_PHYS**2,
|
||||||
|
refined_root=lattice_parameters(40), refined_fine_tau=0.5 + 3 * 2 * rr.SPEED * 40 / RE,
|
||||||
|
uniform=lattice_parameters(80),
|
||||||
|
label="compared against the official reference bands (non-canonical neq_extrap outlet, zou_he_local inlet); not a full benchmark certification")
|
||||||
|
|
||||||
|
|
||||||
|
def main():
|
||||||
|
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
|
||||||
|
parser.add_argument("--case", choices=["refined", "uniform", "both"], default="refined")
|
||||||
|
parser.add_argument("--collision", choices=["SRT", "MRT"], default="SRT")
|
||||||
|
parser.add_argument("--source", type=Path, default=rr.DEFAULT_SOURCE)
|
||||||
|
parser.add_argument("--output", type=Path, required=True)
|
||||||
|
parser.add_argument("--plan", action="store_true", help="Write the frozen plan; no CUDA")
|
||||||
|
parser.add_argument("--max-wall-seconds", type=float)
|
||||||
|
a = parser.parse_args()
|
||||||
|
a.source = a.source.resolve()
|
||||||
|
a.output.mkdir(parents=True, exist_ok=False)
|
||||||
|
(a.output / "plan.json").write_text(json.dumps(plan(a.collision), indent=2, allow_nan=False))
|
||||||
|
if a.plan:
|
||||||
|
return
|
||||||
|
if not a.max_wall_seconds or a.max_wall_seconds <= 0 or not os.environ.get("CUDA_VISIBLE_DEVICES"):
|
||||||
|
raise SystemExit("GPU run needs --max-wall-seconds > 0 and explicit CUDA_VISIBLE_DEVICES")
|
||||||
|
h, _ = rr.helpers(a.source)
|
||||||
|
rr.config = config # host_geometry builds its root configuration through this name
|
||||||
|
a.deadline = time.monotonic() + a.max_wall_seconds
|
||||||
|
cases = ["refined", "uniform"] if a.case == "both" else [a.case]
|
||||||
|
results = [run_case(a, h, case) for case in cases]
|
||||||
|
(a.output / "result.json").write_text(json.dumps(results, indent=2, allow_nan=False))
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
main()
|
||||||
@@ -74,7 +74,25 @@ def cv(g, fluid, origin, rectangle, nu, h=0.5):
|
|||||||
Cauchy stress from centred velocity gradients, NOT postcollision non-equilibrium.
|
Cauchy stress from centred velocity gradients, NOT postcollision non-equilibrium.
|
||||||
Rectangle faces lie on cell edges; fluid mask excludes the staircase cylinder.
|
Rectangle faces lie on cell edges; fluid mask excludes the staircase cylinder.
|
||||||
"""
|
"""
|
||||||
rho, mom, vel = moments(g)
|
return _cv_quantities(*moments(g), fluid, origin, rectangle, nu, h)
|
||||||
|
|
||||||
|
|
||||||
|
def cv_from_macros(rho, ux, uy, fluid, origin, rectangle, nu, h=0.5):
|
||||||
|
"""Same CV calculation from public macros, in one common length/time frame.
|
||||||
|
|
||||||
|
``origin`` is the lower cell edge, ``h`` the cell width, and ``nu`` uses
|
||||||
|
that frame. Returns [mass, Px, Py] inventory and outward total flux.
|
||||||
|
Crop fields/mask together and translate origin before calling if desired.
|
||||||
|
No boundary-exchange observation enters this independent estimator.
|
||||||
|
"""
|
||||||
|
rho = np.asarray(rho, np.float64)
|
||||||
|
if rho.ndim != 2 or any(np.shape(v) != rho.shape for v in (ux, uy, fluid)):
|
||||||
|
raise ValueError("CV macros and fluid mask must have matching 2D shapes")
|
||||||
|
vel = np.asarray([ux, uy], np.float64)
|
||||||
|
return _cv_quantities(rho, rho[None] * vel, vel, fluid, origin, rectangle, nu, h)
|
||||||
|
|
||||||
|
|
||||||
|
def _cv_quantities(rho, mom, vel, fluid, origin, rectangle, nu, h):
|
||||||
x0, y0, x1, y1 = np.rint((np.array(rectangle) - np.tile(origin, 2)) / h).astype(int)
|
x0, y0, x1, y1 = np.rint((np.array(rectangle) - np.tile(origin, 2)) / h).astype(int)
|
||||||
np.testing.assert_allclose(
|
np.testing.assert_allclose(
|
||||||
np.array([x0, y0, x1, y1]) * h + np.tile(origin, 2), rectangle, atol=1e-12
|
np.array([x0, y0, x1, y1]) * h + np.tile(origin, 2), rectangle, atol=1e-12
|
||||||
@@ -261,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,
|
||||||
):
|
):
|
||||||
|
|||||||
@@ -17,8 +17,109 @@ HERE = Path(__file__).resolve().parent
|
|||||||
DEFAULT_SOURCE = HERE.parents[1]
|
DEFAULT_SOURCE = HERE.parents[1]
|
||||||
BOUNDS = (40, 24, 320, 140)
|
BOUNDS = (40, 24, 320, 140)
|
||||||
BASE_BLOCK = (2, 881) # Exact 166 x 881 domain; no geometric padding.
|
BASE_BLOCK = (2, 881) # Exact 166 x 881 domain; no geometric padding.
|
||||||
FINE_BLOCK = (8, 8) # 240 x 568 including four fine halo cells.
|
FINE_BLOCK = (8, 8) # Wide 240 x 568 or compact 168 x 168, including fine halos.
|
||||||
SPEED = 0.01
|
SPEED = 0.01
|
||||||
|
JET_PEAK = 0.001
|
||||||
|
JET_WINDOWS = [(t, t + 10) for t in range(250, 300, 10)]
|
||||||
|
CV_CONTOURS = np.array([(48., 44., 160., 120.), (44., 36., 180., 128.)])
|
||||||
|
PLACEMENTS = {"wide": BOUNDS, "compact": (48, 48, 128, 128)}
|
||||||
|
COMPACT_CV_CONTOURS = np.array([(52., 52., 112., 112.), (50., 50., 120., 120.)])
|
||||||
|
|
||||||
|
|
||||||
|
def selected_cases(selection="both", uniform_diameter=80):
|
||||||
|
return [(case, diameter) for case, diameter in (("uniform", uniform_diameter), ("refined", 40))
|
||||||
|
if selection in ("both", case)]
|
||||||
|
|
||||||
|
|
||||||
|
def uniform_origin(diameter):
|
||||||
|
h = 40 / diameter
|
||||||
|
return (.5 - .5*h, 1 - h)
|
||||||
|
|
||||||
|
|
||||||
|
def cv_contours(refined, diameter, placement="wide"):
|
||||||
|
contours = CV_CONTOURS if placement == "wide" else COMPACT_CV_CONTOURS
|
||||||
|
return contours if refined else contours + [20/diameter, 0., 20/diameter, 0.]
|
||||||
|
|
||||||
|
|
||||||
|
def cv_selected(step, diameter, mode):
|
||||||
|
return mode == "pilot" or round(290 * diameter / SPEED) <= step <= round(300 * diameter / SPEED)
|
||||||
|
|
||||||
|
|
||||||
|
def cv_snapshot(rho, ux, uy, fluid, origin, refined, begin, n, diameter, impulse, placement="wide"):
|
||||||
|
"""Cropped public macros only; all inventories, fluxes and impulses use root units."""
|
||||||
|
from run_jet_circle_cv import cv_from_macros
|
||||||
|
|
||||||
|
rectangles = cv_contours(refined, diameter, placement)
|
||||||
|
h_cell = .5 if refined else 40 / diameter
|
||||||
|
origin = np.asarray(origin, dtype=float)
|
||||||
|
x0, y0, x1, y1 = np.rint((rectangles[-1] - np.tile(origin, 2)) / h_cell).astype(int)
|
||||||
|
selection = np.s_[y0-2:y1+2, x0-2:x1+2]
|
||||||
|
cropped_origin = origin + h_cell * np.array([x0-2, y0-2])
|
||||||
|
fields = [v[selection] for v in (rho, ux, uy, fluid)]
|
||||||
|
values = [cv_from_macros(*fields, cropped_origin, rect, .004, h=h_cell)
|
||||||
|
for rect in rectangles]
|
||||||
|
h_native = 1.0 if refined else 40 / diameter
|
||||||
|
return dict(step=begin+n, tstar=(begin+n)*SPEED/diameter,
|
||||||
|
time_root=(begin+n)*h_native, interval_start_root=begin*h_native,
|
||||||
|
interval_dt_root=n*h_native,
|
||||||
|
interval_impulse_root=(np.asarray(impulse)*h_native**2).tolist(),
|
||||||
|
inventory=[inventory.tolist() for inventory, _ in values],
|
||||||
|
outward_flux=[flux.tolist() for _, flux in values])
|
||||||
|
|
||||||
|
|
||||||
|
def public_jets(center, radius, scenario):
|
||||||
|
"""Same physical apertures; caller supplies its public geometry frame."""
|
||||||
|
if scenario == "none":
|
||||||
|
return ()
|
||||||
|
from CelerisLab.body.jets import Jet, Sector, Radial
|
||||||
|
|
||||||
|
peak = 0.0 if scenario == "zero" else JET_PEAK
|
||||||
|
return tuple(
|
||||||
|
Jet(Sector(center, angle, math.pi / 12, radius * 1.005),
|
||||||
|
Radial(center, inward=False), "parabolic", amplitude)
|
||||||
|
for angle, amplitude in ((math.pi / 2, peak), (3 * math.pi / 2, -peak))
|
||||||
|
)
|
||||||
|
|
||||||
|
|
||||||
|
def jet_interval(handle, scenario, begin, n, diameter):
|
||||||
|
"""Apply a reversal only at a completed interval boundary, before advancing."""
|
||||||
|
if scenario != "none":
|
||||||
|
boundaries = [round(t * diameter / SPEED) for t in (250, 260, 270, 280, 290, 300, 305)]
|
||||||
|
n = min([n] + [step - begin for step in boundaries if step > begin])
|
||||||
|
if scenario != "reverse":
|
||||||
|
return n, None
|
||||||
|
switch = round(300 * diameter / SPEED)
|
||||||
|
if begin < switch:
|
||||||
|
return min(n, switch - begin), None
|
||||||
|
if begin == switch:
|
||||||
|
handle.set_jet_amplitude(0, -JET_PEAK)
|
||||||
|
handle.set_jet_amplitude(1, JET_PEAK)
|
||||||
|
return n, dict(step=begin, tstar=300.0, amplitudes=[-JET_PEAK, JET_PEAK])
|
||||||
|
return n, None
|
||||||
|
|
||||||
|
|
||||||
|
def jet_diagnostics(rows, scenario):
|
||||||
|
"""Raw interval-weighted diagnostics only; no driven-flow qualification gate."""
|
||||||
|
windows = JET_WINDOWS + ([(300, 305)] if scenario == "reverse" else [])
|
||||||
|
result = []
|
||||||
|
for start, end in windows:
|
||||||
|
selected = [r for r in rows if start <= r["tstar_force"] < end]
|
||||||
|
if not selected:
|
||||||
|
continue
|
||||||
|
if any(2 * r["tstar_force"] - r["tstar"] < start - 1e-9
|
||||||
|
or r["tstar"] > end + 1e-9 for r in selected):
|
||||||
|
raise ValueError("Jet diagnostic interval crosses a window boundary")
|
||||||
|
weights = np.array([2 * (r["tstar"] - r["tstar_force"]) for r in selected])
|
||||||
|
record = dict(start_tstar=start, end_tstar=end, samples=len(selected),
|
||||||
|
covered_tstar=float(weights.sum()),
|
||||||
|
complete=bool(np.isclose(weights.sum(), end - start, rtol=0, atol=1e-9)))
|
||||||
|
for key in ("cd", "cl"):
|
||||||
|
values = np.array([r[key] for r in selected])
|
||||||
|
record[key] = dict(mean=float(np.average(values, weights=weights)),
|
||||||
|
min=float(values.min()), max=float(values.max()),
|
||||||
|
rms=float(np.sqrt(np.average(values**2, weights=weights))))
|
||||||
|
result.append(record)
|
||||||
|
return result
|
||||||
|
|
||||||
|
|
||||||
def helpers(source):
|
def helpers(source):
|
||||||
@@ -39,26 +140,34 @@ def helpers(source):
|
|||||||
return h, periodic
|
return h, periodic
|
||||||
|
|
||||||
|
|
||||||
def config(h, diameter, collision="SRT"):
|
def config(h, diameter, collision="SRT", jet_scenario="none"):
|
||||||
cfg, body, p = h.make_config(diameter, SPEED, collision, "neq_extrap", "zou_he_local")
|
cfg, body, p = h.make_config(diameter, SPEED, collision, "neq_extrap", "zou_he_local")
|
||||||
cfg["method"]["outlet"]["srt_neq_damp"] = 0.5
|
cfg["method"]["outlet"]["srt_neq_damp"] = 0.5
|
||||||
|
if jet_scenario != "none":
|
||||||
|
if collision != "MRT":
|
||||||
|
raise ValueError("Public Jet scenarios require MRT")
|
||||||
|
cfg["method"]["ddf_shifting"] = False
|
||||||
return cfg, body, p
|
return cfg, body, p
|
||||||
|
|
||||||
|
|
||||||
def plan(h, collision="SRT", observation_mode="last_base_step"):
|
def plan(h, collision="SRT", observation_mode="last_base_step", jet_scenario="none", uniform_diameter=80, placement="wide"):
|
||||||
_, _, c = config(h, 40, collision)
|
_, _, c = config(h, 40, collision, jet_scenario)
|
||||||
_, _, f = config(h, 80, collision)
|
_, _, f = config(h, uniform_diameter, collision, jet_scenario)
|
||||||
x0, y0, x1, y1 = BOUNDS
|
bounds = PLACEMENTS[placement]
|
||||||
|
x0, y0, x1, y1 = bounds
|
||||||
fine_active = 4 * (x1 - x0) * (y1 - y0)
|
fine_active = 4 * (x1 - x0) * (y1 - y0)
|
||||||
coarse_uncovered = c["nx"] * c["ny"] - fine_active // 4
|
coarse_uncovered = c["nx"] * c["ny"] - fine_active // 4
|
||||||
return dict(
|
return dict(
|
||||||
status="prepared_not_run",
|
status="prepared_not_run",
|
||||||
collision=collision,
|
collision=collision,
|
||||||
|
jet_scenario=jet_scenario,
|
||||||
|
ddf_shifting=jet_scenario == "none",
|
||||||
observation_mode=observation_mode,
|
observation_mode=observation_mode,
|
||||||
root_gpu_gates_required=True,
|
root_gpu_gates_required=True,
|
||||||
root=c,
|
root=c,
|
||||||
uniform=f,
|
uniform=f,
|
||||||
bounds_root_edge=list(BOUNDS),
|
bounds_root_edge=list(bounds),
|
||||||
|
fine_origin_root_edge=[x0 - 2, y0 - 2],
|
||||||
physical_patch_m=[
|
physical_patch_m=[
|
||||||
(x0 - 0.5) * c["dx"],
|
(x0 - 0.5) * c["dx"],
|
||||||
(y0 - 1) * c["dx"],
|
(y0 - 1) * c["dx"],
|
||||||
@@ -78,19 +187,31 @@ def plan(h, collision="SRT", observation_mode="last_base_step"):
|
|||||||
physical_viscosity_m2_s=0.001,
|
physical_viscosity_m2_s=0.001,
|
||||||
finest_dx_m=f["dx"],
|
finest_dx_m=f["dx"],
|
||||||
finest_dt_s=f["dt"],
|
finest_dt_s=f["dt"],
|
||||||
|
refined_finest_dx_m=c["dx"]/2,
|
||||||
|
refined_finest_dt_s=c["dt"]/2,
|
||||||
approximate_leaf_cell_ratio=(coarse_uncovered + fine_active)
|
approximate_leaf_cell_ratio=(coarse_uncovered + fine_active)
|
||||||
/ (f["nx"] * f["ny"]),
|
/ (f["nx"] * f["ny"]),
|
||||||
approximate_collision_work_ratio=(coarse_uncovered + 2 * fine_active)
|
approximate_collision_work_ratio=(coarse_uncovered + 2 * fine_active)
|
||||||
/ (2 * f["nx"] * f["ny"]),
|
/ ((uniform_diameter/40) * f["nx"] * f["ny"]),
|
||||||
cost_caveat="Geometry-only estimates include ghosts/solids; exclude block halos, transfers, observation and launch overhead. Not measured speedup.",
|
cost_caveat="Geometry-only estimates include ghosts/solids; exclude block halos, transfers, observation and launch overhead. Not measured speedup.",
|
||||||
sampling_offset="For origin (38,22), fine physical x=(j+75.5)*dx80 versus uniform i*dx80: half-fine-cell x offset. Fine physical y=(k+42.5)*dx80 equals uniform (l-.5)*dx80 at l=k+43: y samples align. Body, wall and source planes coincide.",
|
sampling_offset="Uniform nodes map to root edges X=.5+i*(40/D), Y=1+(j-.5)*(40/D). Refined centers are fine_origin_root_edge+(index+.5)*.5. Body, wall and source planes coincide; compare observables, not pointwise arrays.",
|
||||||
outlet=(
|
outlet=(
|
||||||
"SRT pressure NEQ, all nine fneq damped by .5, no backflow clamp; noncanonical DFG outlet"
|
"SRT pressure NEQ, all nine fneq damped by .5, no backflow clamp; noncanonical DFG outlet"
|
||||||
if collision == "SRT" else
|
if collision == "SRT" else
|
||||||
"MRT pressure NEQ, unknowns q2/6/8 extrapolated; no backflow clamp; noncanonical DFG outlet"
|
"MRT pressure NEQ, unknowns q2/6/8 extrapolated; no backflow clamp; noncanonical DFG outlet"
|
||||||
),
|
),
|
||||||
modes={"pilot_tstar": 5.0, "full_tstar": 300.0},
|
modes={"pilot_tstar": 5.0, "full_tstar": 305.0 if jet_scenario == "reverse" else 300.0},
|
||||||
observation_dense_tstar=0.02,
|
observation_dense_tstar=0.02,
|
||||||
|
**(dict(jets=dict(
|
||||||
|
uniform_origin_node=f["center"], refined_origin_root_edge=[80.5, 81.0],
|
||||||
|
angles_rad=[math.pi / 2, 3 * math.pi / 2], half_width_rad=math.pi / 12,
|
||||||
|
radial_extent_over_radius=[0.0, 1.005],
|
||||||
|
field="Radial(outward)", profile="parabolic", condition="velocity",
|
||||||
|
initial_amplitudes=[0.0, 0.0] if jet_scenario == "zero" else [JET_PEAK, -JET_PEAK],
|
||||||
|
reversal_tstar=300.0 if jet_scenario == "reverse" else None,
|
||||||
|
diagnostic_windows_tstar=JET_WINDOWS + ([(300, 305)] if jet_scenario == "reverse" else []),
|
||||||
|
transfer="constant", driven_qualification="not assessed",
|
||||||
|
)) if jet_scenario != "none" else {}),
|
||||||
)
|
)
|
||||||
|
|
||||||
|
|
||||||
@@ -126,7 +247,7 @@ def initial_state(shape, origin, spacing, height=164.0, speed=SPEED, root=False)
|
|||||||
return w * (1 + 3 * cu + 4.5 * cu * cu - 1.5 * velocity * velocity)
|
return w * (1 + 3 * cu + 4.5 * cu * cu - 1.5 * velocity * velocity)
|
||||||
|
|
||||||
|
|
||||||
def host_geometry(source, h, collision="SRT"):
|
def host_geometry(source, h, collision="SRT", jet_scenario="none", placement="wide"):
|
||||||
"""Production donor/transfer and complete cut-link checks, without CUDA."""
|
"""Production donor/transfer and complete cut-link checks, without CUDA."""
|
||||||
from CelerisLab.config import load_lbm_config
|
from CelerisLab.config import load_lbm_config
|
||||||
from CelerisLab.lbm.refinement import FixedPatch2D, prepare_fine_boundary
|
from CelerisLab.lbm.refinement import FixedPatch2D, prepare_fine_boundary
|
||||||
@@ -139,12 +260,12 @@ def host_geometry(source, h, collision="SRT"):
|
|||||||
from CelerisLab.body.geometry.circle import CircleGeometry
|
from CelerisLab.body.geometry.circle import CircleGeometry
|
||||||
from CelerisLab.body.objects import SimObject
|
from CelerisLab.body.objects import SimObject
|
||||||
|
|
||||||
cfgdict, _, _ = config(h, 40, collision)
|
cfgdict, _, _ = config(h, 40, collision, jet_scenario)
|
||||||
with TemporaryDirectory() as tmp:
|
with TemporaryDirectory() as tmp:
|
||||||
p = Path(tmp) / "cfg.json"
|
p = Path(tmp) / "cfg.json"
|
||||||
p.write_text(json.dumps(cfgdict))
|
p.write_text(json.dumps(cfgdict))
|
||||||
cfg = load_lbm_config(str(p))
|
cfg = load_lbm_config(str(p))
|
||||||
pair = FixedPatch2D.from_config(cfg, BOUNDS)
|
pair = FixedPatch2D.from_config(cfg, PLACEMENTS[placement])
|
||||||
layout = BlockLayout2D.build(cfg.ny, cfg.nx, *BASE_BLOCK)
|
layout = BlockLayout2D.build(cfg.ny, cfg.nx, *BASE_BLOCK)
|
||||||
validate_channel_config(cfg, [BASE_BLOCK, FINE_BLOCK])
|
validate_channel_config(cfg, [BASE_BLOCK, FINE_BLOCK])
|
||||||
targets = blocked_base_tables(pair, layout, np.argsort(pair.coalesce_coarse))[1]
|
targets = blocked_base_tables(pair, layout, np.argsort(pair.coalesce_coarse))[1]
|
||||||
@@ -153,18 +274,41 @@ def host_geometry(source, h, collision="SRT"):
|
|||||||
body = SimObject(
|
body = SimObject(
|
||||||
0, geometry=CircleGeometry(80.5, 81.0, 20.0), center=(80.5, 81.0), radius=20.0
|
0, geometry=CircleGeometry(80.5, 81.0, 20.0), center=(80.5, 81.0), radius=20.0
|
||||||
)
|
)
|
||||||
host = prepare_fine_boundary(cfg, pair, (body,), _shifted_blocked=True)
|
host = prepare_fine_boundary(
|
||||||
|
cfg, pair, (body,), jets=public_jets((80.5, 81.0), 20.0, jet_scenario),
|
||||||
|
_shifted_blocked=jet_scenario == "none",
|
||||||
|
)
|
||||||
return cfg, pair, body, host
|
return cfg, pair, body, host
|
||||||
|
|
||||||
|
|
||||||
def verify_source(source, collision="SRT", observation_mode="last_base_step"):
|
def verify_source(source, collision="SRT", observation_mode="last_base_step", jet_scenario="none", observe_cv=False):
|
||||||
if collision not in ("SRT", "MRT"):
|
if collision not in ("SRT", "MRT"):
|
||||||
raise ValueError("Matched collision must be SRT or MRT")
|
raise ValueError("Matched collision must be SRT or MRT")
|
||||||
if observation_mode not in ("last_base_step", "window"):
|
if observation_mode not in ("last_base_step", "window"):
|
||||||
raise ValueError("Unknown refined observation mode")
|
raise ValueError("Unknown refined observation mode")
|
||||||
|
if observe_cv and jet_scenario == "none":
|
||||||
|
raise ValueError("--observe-cv requires an explicit public Jet scenario")
|
||||||
name = ("source_manifest_window.json" if observation_mode == "window" else
|
name = ("source_manifest_window.json" if observation_mode == "window" else
|
||||||
"source_manifest.json" if collision == "SRT" else "source_manifest_mrt.json")
|
"source_manifest.json" if collision == "SRT" else "source_manifest_mrt.json")
|
||||||
expected = json.loads((HERE / "data/refined_dfg" / name).read_text())
|
expected = json.loads((HERE / "data/refined_dfg" / name).read_text())
|
||||||
|
if jet_scenario != "none":
|
||||||
|
if collision != "MRT" or observation_mode != "window":
|
||||||
|
raise ValueError("Public Jet scenarios require MRT and --exchange-window")
|
||||||
|
import subprocess
|
||||||
|
sys.path.insert(0, str(HERE))
|
||||||
|
from source_provenance import checkout_provenance
|
||||||
|
|
||||||
|
paths = set(expected["sha256"])
|
||||||
|
if observe_cv:
|
||||||
|
paths.add("tests/validation/run_jet_circle_cv.py")
|
||||||
|
paths.update(subprocess.check_output(
|
||||||
|
["git", "-C", str(source), "ls-files", "src"], text=True).splitlines())
|
||||||
|
return dict(
|
||||||
|
source_capture="current checkout, not historical DFG qualification",
|
||||||
|
**checkout_provenance(source), observation_mode=observation_mode,
|
||||||
|
sha256={name: hashlib.sha256((source / name).read_bytes()).hexdigest()
|
||||||
|
for name in sorted(paths)},
|
||||||
|
)
|
||||||
for name, digest in expected["sha256"].items():
|
for name, digest in expected["sha256"].items():
|
||||||
if hashlib.sha256((source / name).read_bytes()).hexdigest() != digest:
|
if hashlib.sha256((source / name).read_bytes()).hexdigest() != digest:
|
||||||
raise RuntimeError("Source mismatch: " + name)
|
raise RuntimeError("Source mismatch: " + name)
|
||||||
@@ -219,29 +363,32 @@ def run_case(a, h, periodic, case):
|
|||||||
from contextlib import ExitStack
|
from contextlib import ExitStack
|
||||||
|
|
||||||
refined = case == "refined"
|
refined = case == "refined"
|
||||||
cfgdict, bodydict, p = config(h, 40 if refined else 80, a.collision)
|
cfgdict, bodydict, p = config(h, 40 if refined else a.uniform_diameter, a.collision, a.jet_scenario)
|
||||||
cap = 5.0 if a.mode == "pilot" else 300.0
|
cap = 5.0 if a.mode == "pilot" else (305.0 if a.jet_scenario == "reverse" else 300.0)
|
||||||
max_steps = math.ceil(cap * p["diameter"] / SPEED)
|
max_steps = math.ceil(cap * p["diameter"] / SPEED)
|
||||||
rows = []
|
rows = []
|
||||||
healthy = True
|
healthy = True
|
||||||
step_seconds = 0.0
|
step_seconds = 0.0
|
||||||
|
cv_seconds, cv_samples = 0.0, 0
|
||||||
|
amplitude_changes = []
|
||||||
started = time.monotonic()
|
started = time.monotonic()
|
||||||
check_deadline(a.deadline)
|
check_deadline(a.deadline)
|
||||||
dest = a.output / case
|
dest = a.output / case
|
||||||
dest.mkdir()
|
dest.mkdir()
|
||||||
with ExitStack() as stack:
|
with ExitStack() as stack:
|
||||||
|
cv_out = stack.enter_context((dest / "cv_history.jsonl").open("w")) if a.observe_cv else None
|
||||||
if refined:
|
if refined:
|
||||||
cfg, pair, body, host = host_geometry(a.source, h, a.collision)
|
cfg, pair, body, host = host_geometry(a.source, h, a.collision, a.jet_scenario, a.placement)
|
||||||
context = stack.enter_context(CudaContext(0))
|
context = stack.enter_context(CudaContext(0))
|
||||||
backend = stack.enter_context(
|
backend = stack.enter_context(
|
||||||
FixedPatchStepper(
|
FixedPatchStepper(
|
||||||
cfg,
|
cfg,
|
||||||
BOUNDS,
|
|
||||||
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,)],
|
||||||
|
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 {}),
|
||||||
)
|
)
|
||||||
@@ -274,6 +421,9 @@ def run_case(a, h, periodic, case):
|
|||||||
sim = stack.enter_context(
|
sim = stack.enter_context(
|
||||||
Simulation(str(tmp / "lbm.json"), str(tmp / "body.json"), device_id=0)
|
Simulation(str(tmp / "lbm.json"), str(tmp / "body.json"), device_id=0)
|
||||||
)
|
)
|
||||||
|
for index, jet in enumerate(public_jets(p["center"], p["radius"], a.jet_scenario)):
|
||||||
|
if sim.add_jet(jet) != index:
|
||||||
|
raise RuntimeError("Unexpected public Jet registration index")
|
||||||
sim.initialize()
|
sim.initialize()
|
||||||
probe_p = p
|
probe_p = p
|
||||||
fluid = (sim.field.flag.reshape(p["ny"], p["nx"]) & FLUID) != 0
|
fluid = (sim.field.flag.reshape(p["ny"], p["nx"]) & FLUID) != 0
|
||||||
@@ -290,6 +440,10 @@ def run_case(a, h, periodic, case):
|
|||||||
else 0.5
|
else 0.5
|
||||||
)
|
)
|
||||||
n = min(max(1, round(width * p["diameter"] / SPEED)), max_steps - begin)
|
n = min(max(1, round(width * p["diameter"] / SPEED)), max_steps - begin)
|
||||||
|
n, change = jet_interval(backend if refined else sim, a.jet_scenario,
|
||||||
|
begin, n, p["diameter"])
|
||||||
|
if change is not None:
|
||||||
|
amplitude_changes.append(change)
|
||||||
impulse = np.zeros(2)
|
impulse = np.zeros(2)
|
||||||
tick = time.monotonic()
|
tick = time.monotonic()
|
||||||
if refined:
|
if refined:
|
||||||
@@ -359,6 +513,19 @@ def run_case(a, h, periodic, case):
|
|||||||
/ SPEED,
|
/ SPEED,
|
||||||
**h.pressure_probes(rho, fluid, probe_p),
|
**h.pressure_probes(rho, fluid, probe_p),
|
||||||
)
|
)
|
||||||
|
if a.jet_scenario != "none":
|
||||||
|
row.update(step_start=begin, tstar_start=begin * SPEED / p["diameter"],
|
||||||
|
interval_steps=n, impulse_x=float(impulse[0]),
|
||||||
|
impulse_y=float(impulse[1]))
|
||||||
|
if a.observe_cv and cv_selected(begin+n, p["diameter"], a.mode):
|
||||||
|
tick = time.monotonic()
|
||||||
|
record = cv_snapshot(rho, ux, uy, fluid,
|
||||||
|
pair.fine_origin if refined else uniform_origin(p["diameter"]),
|
||||||
|
refined, begin, n, p["diameter"], impulse, a.placement)
|
||||||
|
cv_out.write(json.dumps(record, allow_nan=False) + "\n")
|
||||||
|
cv_out.flush()
|
||||||
|
cv_samples += 1
|
||||||
|
cv_seconds += time.monotonic() - tick
|
||||||
check_deadline(a.deadline)
|
check_deadline(a.deadline)
|
||||||
ensure_finite(row)
|
ensure_finite(row)
|
||||||
rows.append(row)
|
rows.append(row)
|
||||||
@@ -402,14 +569,24 @@ def run_case(a, h, periodic, case):
|
|||||||
steps=begin,
|
steps=begin,
|
||||||
startup_seconds=startup,
|
startup_seconds=startup,
|
||||||
step_seconds=step_seconds,
|
step_seconds=step_seconds,
|
||||||
|
observation_and_overhead_seconds=time.monotonic() - started - startup - step_seconds,
|
||||||
wall_seconds=time.monotonic() - started,
|
wall_seconds=time.monotonic() - started,
|
||||||
force="raw stationary-body link momentum reaction, per-unit-depth; average over entire observation interval; normalized in each base lattice",
|
force="raw stationary-body link momentum reaction, per-unit-depth; average over entire observation interval; normalized in each base lattice",
|
||||||
mass_units="rho_reference * m^2 per unit depth",
|
mass_units="rho_reference * m^2 per unit depth",
|
||||||
flux_units="rho_reference * m^2/s per unit depth",
|
flux_units="rho_reference * m^2/s per unit depth",
|
||||||
pressure="postcollision end-sample; physical pressure difference / (rho_reference * 1 m/s squared)",
|
pressure="postcollision end-sample; physical pressure difference / (rho_reference * 1 m/s squared)",
|
||||||
suite_validated=False,
|
suite_validated=False,
|
||||||
**periodic.assess(rows),
|
**(periodic.assess(rows) if a.jet_scenario in ("none", "zero") else
|
||||||
|
dict(periodic=False, checks={}, cycles=[])),
|
||||||
)
|
)
|
||||||
|
if a.jet_scenario != "none":
|
||||||
|
result.update(jet_diagnostic_windows=jet_diagnostics(rows, a.jet_scenario),
|
||||||
|
amplitude_changes=amplitude_changes,
|
||||||
|
pressure_classification=("DFG reference verdict retained, including pressure"
|
||||||
|
if a.jet_scenario == "zero" else "diagnostic only; no official DFG reference gate"))
|
||||||
|
if a.observe_cv:
|
||||||
|
result.update(cv_observation_seconds=cv_seconds, cv_samples=cv_samples,
|
||||||
|
cv_qualification="not assessed; scalar observations only")
|
||||||
if not healthy:
|
if not healthy:
|
||||||
result["periodic"] = False
|
result["periodic"] = False
|
||||||
reference = json.loads(
|
reference = json.loads(
|
||||||
@@ -425,7 +602,8 @@ def run_case(a, h, periodic, case):
|
|||||||
else (
|
else (
|
||||||
"pilot_complete"
|
"pilot_complete"
|
||||||
if a.mode == "pilot"
|
if a.mode == "pilot"
|
||||||
else ("periodic" if result["periodic"] else "incomplete_periodicity")
|
else ("driven_diagnostics_complete" if a.jet_scenario in ("fixed", "reverse") else
|
||||||
|
"periodic" if result["periodic"] else "incomplete_periodicity")
|
||||||
)
|
)
|
||||||
)
|
)
|
||||||
(dest / "summary.json").write_text(json.dumps(result, indent=2, allow_nan=False))
|
(dest / "summary.json").write_text(json.dumps(result, indent=2, allow_nan=False))
|
||||||
@@ -464,27 +642,39 @@ def check_deadline(deadline):
|
|||||||
)
|
)
|
||||||
|
|
||||||
|
|
||||||
def verify_pilot(path, manifest, collision="SRT", observation_mode="last_base_step"):
|
def verify_pilot(path, manifest, collision="SRT", observation_mode="last_base_step", jet_scenario="none", observe_cv=False,
|
||||||
|
case_selection="both", uniform_diameter=80, placement="wide"):
|
||||||
if path is None:
|
if path is None:
|
||||||
raise ValueError(
|
raise ValueError(
|
||||||
"Full comparison requires --pilot-results from a completed matched pilot"
|
"Full comparison requires --pilot-results from a completed matched pilot"
|
||||||
)
|
)
|
||||||
previous = read_finite_json(path / "plan.json")
|
previous = read_finite_json(path / "plan.json")
|
||||||
|
options = dict(case_selection=(case_selection, "both"), uniform_diameter=(uniform_diameter, 80), placement=(placement, "wide"))
|
||||||
|
if any(previous.get(k, default) != expected for k, (expected, default) in options.items()):
|
||||||
|
raise ValueError("Pilot case, resolution or placement differs")
|
||||||
|
if previous.get("observe_cv", False) != observe_cv:
|
||||||
|
raise ValueError("Pilot CV observation mode differs")
|
||||||
|
if previous.get("jet_scenario", "none") != jet_scenario:
|
||||||
|
raise ValueError("Pilot Jet scenario differs")
|
||||||
if previous.get("observation_mode") != observation_mode:
|
if previous.get("observation_mode") != observation_mode:
|
||||||
raise ValueError("Pilot observation mode differs")
|
raise ValueError("Pilot observation mode differs")
|
||||||
if previous.get("collision") != collision:
|
if previous.get("collision") != collision:
|
||||||
raise ValueError("Pilot collision differs")
|
raise ValueError("Pilot collision differs")
|
||||||
if previous["source_manifest"] != manifest or previous["bounds_root_edge"] != list(
|
if previous["source_manifest"] != manifest or previous["bounds_root_edge"] != list(
|
||||||
BOUNDS
|
PLACEMENTS[placement]
|
||||||
):
|
):
|
||||||
raise ValueError("Pilot source or frozen geometry differs")
|
raise ValueError("Pilot source or frozen geometry differs")
|
||||||
if previous.get("runner_sha256") != runner_hash():
|
if previous.get("runner_sha256") != runner_hash():
|
||||||
raise ValueError("Pilot runner differs")
|
raise ValueError("Pilot runner differs")
|
||||||
calibrated_seconds = 0.0
|
calibrated_seconds = 0.0
|
||||||
for case, diameter in (("uniform", 80), ("refined", 40)):
|
for case, diameter in selected_cases(case_selection, uniform_diameter):
|
||||||
summary = read_finite_json(path / case / "summary.json")
|
summary = read_finite_json(path / case / "summary.json")
|
||||||
if (
|
if (
|
||||||
summary.get("observation_mode") != observation_mode
|
any(summary.get(k, default) != expected for k, (expected, default) in options.items())
|
||||||
|
or summary.get("observe_cv", False) != observe_cv
|
||||||
|
or (observe_cv and summary.get("cv_samples") != 250)
|
||||||
|
or summary.get("jet_scenario", "none") != jet_scenario
|
||||||
|
or summary.get("observation_mode") != observation_mode
|
||||||
or summary.get("collision") != collision
|
or summary.get("collision") != collision
|
||||||
or summary.get("case") != case
|
or summary.get("case") != case
|
||||||
or summary.get("mode") != "pilot"
|
or summary.get("mode") != "pilot"
|
||||||
@@ -537,7 +727,10 @@ def verify_pilot(path, manifest, collision="SRT", observation_mode="last_base_st
|
|||||||
raise ValueError("Unhealthy pilot observations")
|
raise ValueError("Unhealthy pilot observations")
|
||||||
ready = read_finite_json(path / case / "ready.json")
|
ready = read_finite_json(path / case / "ready.json")
|
||||||
if (
|
if (
|
||||||
ready.get("observation_mode") != observation_mode
|
any(ready.get(k, default) != expected for k, (expected, default) in options.items())
|
||||||
|
or ready.get("observe_cv", False) != observe_cv
|
||||||
|
or ready.get("jet_scenario", "none") != jet_scenario
|
||||||
|
or ready.get("observation_mode") != observation_mode
|
||||||
or ready.get("collision") != collision
|
or ready.get("collision") != collision
|
||||||
or ready.get("case") != case
|
or ready.get("case") != case
|
||||||
or ready.get("mode") != "pilot"
|
or ready.get("mode") != "pilot"
|
||||||
@@ -555,9 +748,9 @@ def verify_pilot(path, manifest, collision="SRT", observation_mode="last_base_st
|
|||||||
or not 0 < stepping <= wall
|
or not 0 < stepping <= wall
|
||||||
):
|
):
|
||||||
raise ValueError("Invalid pilot calibration timings")
|
raise ValueError("Invalid pilot calibration timings")
|
||||||
# Full physical duration is 60 times pilot; dense pilot sampling makes
|
# Full duration is 60 (or 61 with reversal) times pilot; dense sampling makes
|
||||||
# this conservative for the sparser early full observations. Not a guarantee.
|
# this conservative for the sparser early full observations. Not a guarantee.
|
||||||
calibrated_seconds += startup + 60 * (wall - startup)
|
calibrated_seconds += startup + (61 if jet_scenario == "reverse" else 60) * (wall - startup)
|
||||||
return 3 * calibrated_seconds
|
return 3 * calibrated_seconds
|
||||||
|
|
||||||
|
|
||||||
@@ -566,6 +759,13 @@ def main():
|
|||||||
parser.add_argument("--exchange-window", action="store_true",
|
parser.add_argument("--exchange-window", action="store_true",
|
||||||
help="Opt in to refined window-ledger observations on the pinned candidate")
|
help="Opt in to refined window-ledger observations on the pinned candidate")
|
||||||
parser.add_argument("--collision", choices=["SRT", "MRT"], default="SRT")
|
parser.add_argument("--collision", choices=["SRT", "MRT"], default="SRT")
|
||||||
|
parser.add_argument("--case", choices=["both", "uniform", "refined"], default="both")
|
||||||
|
parser.add_argument("--uniform-diameter", type=int, choices=[80, 160], default=80)
|
||||||
|
parser.add_argument("--placement", choices=list(PLACEMENTS), default="wide")
|
||||||
|
parser.add_argument("--jet-scenario", choices=["none", "zero", "fixed", "reverse"],
|
||||||
|
default="none", help="Opt in to public unshifted MRT Jets; reverse switches at t*=300 and ends at 305")
|
||||||
|
parser.add_argument("--observe-cv", action="store_true",
|
||||||
|
help="Record independent cropped-macro CV samples during pilot or full t*=290..300")
|
||||||
parser.add_argument("--source", type=Path, default=DEFAULT_SOURCE)
|
parser.add_argument("--source", type=Path, default=DEFAULT_SOURCE)
|
||||||
parser.add_argument("--output", type=Path, required=True)
|
parser.add_argument("--output", type=Path, required=True)
|
||||||
parser.add_argument("--mode", choices=["plan", "pilot", "full"], default="plan")
|
parser.add_argument("--mode", choices=["plan", "pilot", "full"], default="plan")
|
||||||
@@ -577,15 +777,26 @@ def main():
|
|||||||
help="Required explicit campaign wall-time ceiling for GPU execution",
|
help="Required explicit campaign wall-time ceiling for GPU execution",
|
||||||
)
|
)
|
||||||
a = parser.parse_args()
|
a = parser.parse_args()
|
||||||
|
if a.uniform_diameter == 160 and a.case != "uniform":
|
||||||
|
raise ValueError("D160 requires --case uniform; no matched-resolution claim")
|
||||||
|
if a.placement == "compact" and a.case != "refined":
|
||||||
|
raise ValueError("Compact placement requires --case refined")
|
||||||
|
if (a.uniform_diameter != 80 or a.placement != "wide") and a.jet_scenario == "none":
|
||||||
|
raise ValueError("Resolution/placement variants require an explicit public Jet scenario")
|
||||||
a.source = a.source.resolve()
|
a.source = a.source.resolve()
|
||||||
a.observation_mode = "window" if a.exchange_window else "last_base_step"
|
a.observation_mode = "window" if a.exchange_window else "last_base_step"
|
||||||
manifest = verify_source(a.source, a.collision, a.observation_mode)
|
manifest = verify_source(a.source, a.collision, a.observation_mode, a.jet_scenario, a.observe_cv)
|
||||||
h, periodic = helpers(a.source)
|
h, periodic = helpers(a.source)
|
||||||
from source_provenance import checkout_provenance
|
from source_provenance import checkout_provenance
|
||||||
|
|
||||||
a.provenance = checkout_provenance(a.source)
|
a.provenance = checkout_provenance(a.source)
|
||||||
|
a.provenance.update(jet_scenario=a.jet_scenario, ddf_shifting=a.jet_scenario == "none")
|
||||||
|
a.provenance.update(case_selection=a.case, uniform_diameter=a.uniform_diameter, placement=a.placement)
|
||||||
|
if a.observe_cv:
|
||||||
|
a.provenance["observe_cv"] = True
|
||||||
calibration = (
|
calibration = (
|
||||||
verify_pilot(a.pilot_results, manifest, a.collision, a.observation_mode)
|
verify_pilot(a.pilot_results, manifest, a.collision, a.observation_mode, a.jet_scenario, a.observe_cv,
|
||||||
|
a.case, a.uniform_diameter, a.placement)
|
||||||
if a.mode == "full" else None
|
if a.mode == "full" else None
|
||||||
)
|
)
|
||||||
if a.mode != "plan" and (
|
if a.mode != "plan" and (
|
||||||
@@ -602,17 +813,31 @@ def main():
|
|||||||
if a.output.exists() and any(a.output.iterdir()):
|
if a.output.exists() and any(a.output.iterdir()):
|
||||||
raise ValueError("Output must be empty/new")
|
raise ValueError("Output must be empty/new")
|
||||||
a.output.mkdir(parents=True, exist_ok=True)
|
a.output.mkdir(parents=True, exist_ok=True)
|
||||||
specification = plan(h, a.collision, a.observation_mode)
|
specification = plan(h, a.collision, a.observation_mode, a.jet_scenario, a.uniform_diameter, a.placement)
|
||||||
specification.update(
|
specification.update(
|
||||||
source_manifest=manifest,
|
source_manifest=manifest,
|
||||||
**a.provenance,
|
**a.provenance,
|
||||||
gates=periodic.GATES,
|
gates=periodic.GATES if a.jet_scenario in ("none", "zero") else None,
|
||||||
reference_gates=periodic.REFERENCE_GATES,
|
reference_gates=periodic.REFERENCE_GATES if a.jet_scenario in ("none", "zero") else None,
|
||||||
runner_sha256=runner_hash(),
|
runner_sha256=runner_hash(),
|
||||||
wall_time_budget_seconds=budget,
|
wall_time_budget_seconds=budget,
|
||||||
full_pilot_calibration_seconds=calibration,
|
full_pilot_calibration_seconds=calibration,
|
||||||
)
|
)
|
||||||
host_geometry(a.source, h, a.collision)
|
if a.observe_cv:
|
||||||
|
specification["cv_observation"] = dict(
|
||||||
|
full_tstar=[290, 300], pilot_tstar=[.02, 5], spacing_tstar=.02,
|
||||||
|
refined_contours_root=cv_contours(True, 40, a.placement).tolist(),
|
||||||
|
uniform_contours_root=cv_contours(False, a.uniform_diameter, a.placement).tolist(),
|
||||||
|
uniform_grid_origin_root=uniform_origin(a.uniform_diameter),
|
||||||
|
refined_grid_origin_root=specification["fine_origin_root_edge"],
|
||||||
|
cell_width_root={"uniform": 40/a.uniform_diameter, "refined": .5},
|
||||||
|
viscosity_root=.004, components=["mass", "Px", "Py"],
|
||||||
|
units="root lattice per unit depth; outward flux per root time",
|
||||||
|
interval="Impulse belongs to the interval ending at each snapshot; first retained endpoint (pilot .02, full 290) supplies initial inventory only: exclude its preceding impulse",
|
||||||
|
qualification="not assessed; trapezoidal integration and time-coarsening are offline",
|
||||||
|
)
|
||||||
|
if a.case != "uniform":
|
||||||
|
host_geometry(a.source, h, a.collision, a.jet_scenario, a.placement)
|
||||||
(a.output / "plan.json").write_text(json.dumps(specification, indent=2))
|
(a.output / "plan.json").write_text(json.dumps(specification, indent=2))
|
||||||
if a.mode == "plan":
|
if a.mode == "plan":
|
||||||
return 0
|
return 0
|
||||||
@@ -621,8 +846,9 @@ def main():
|
|||||||
"GPU execution blocked: root GPU gates approval and explicit device selection required"
|
"GPU execution blocked: root GPU gates approval and explicit device selection required"
|
||||||
)
|
)
|
||||||
results = []
|
results = []
|
||||||
|
cases = selected_cases(a.case, a.uniform_diameter)
|
||||||
a.deadline = time.monotonic() + budget
|
a.deadline = time.monotonic() + budget
|
||||||
for case in ("uniform", "refined"):
|
for case, _ in cases:
|
||||||
try:
|
try:
|
||||||
result = run_case(a, h, periodic, case)
|
result = run_case(a, h, periodic, case)
|
||||||
except TimeoutError as exc:
|
except TimeoutError as exc:
|
||||||
@@ -650,7 +876,12 @@ def main():
|
|||||||
status="pilot_only" if a.mode == "pilot" else "incomplete",
|
status="pilot_only" if a.mode == "pilot" else "incomplete",
|
||||||
matched_case_pass=False,
|
matched_case_pass=False,
|
||||||
)
|
)
|
||||||
if len(results) == 2 and all(r["healthy"] and r["periodic"] for r in results):
|
if a.jet_scenario in ("fixed", "reverse"):
|
||||||
|
comparison.update(status=("pilot_only" if a.mode == "pilot" else "driven_diagnostics_complete")
|
||||||
|
if len(results) == len(cases) and all(r["healthy"] for r in results) else "invalid_state",
|
||||||
|
qualification="not assessed; execution completion is not physical acceptance",
|
||||||
|
jet_diagnostic_windows={r["case"]: r["jet_diagnostic_windows"] for r in results})
|
||||||
|
if a.case == "both" and len(results) == 2 and all(r["healthy"] and r["periodic"] for r in results):
|
||||||
comparison.update(
|
comparison.update(
|
||||||
status="periodic_comparison",
|
status="periodic_comparison",
|
||||||
refined_vs_uniform=periodic.compare(
|
refined_vs_uniform=periodic.compare(
|
||||||
@@ -660,14 +891,20 @@ def main():
|
|||||||
comparison["matched_case_pass"] = comparison["refined_vs_uniform"][
|
comparison["matched_case_pass"] = comparison["refined_vs_uniform"][
|
||||||
"reference_agreement"
|
"reference_agreement"
|
||||||
]
|
]
|
||||||
|
if a.case != "both":
|
||||||
|
comparison.update(status="single_case_" + results[0]["status"],
|
||||||
|
own_reference_comparison=results[0].get("reference_comparison"))
|
||||||
(a.output / "comparison.json").write_text(
|
(a.output / "comparison.json").write_text(
|
||||||
json.dumps(comparison, indent=2, allow_nan=False)
|
json.dumps(comparison, indent=2, allow_nan=False)
|
||||||
)
|
)
|
||||||
return (
|
return (
|
||||||
0
|
0
|
||||||
if len(results) == 2
|
if len(results) == len(cases)
|
||||||
and all(r["healthy"] for r in results)
|
and all(r["healthy"] for r in results)
|
||||||
and (a.mode == "pilot" or comparison["matched_case_pass"])
|
and (a.mode == "pilot" or comparison["matched_case_pass"]
|
||||||
|
or a.jet_scenario in ("fixed", "reverse")
|
||||||
|
or (a.case != "both" and results[0]["periodic"]
|
||||||
|
and results[0].get("reference_comparison", {}).get("reference_agreement", False)))
|
||||||
else 2
|
else 2
|
||||||
)
|
)
|
||||||
|
|
||||||
|
|||||||
@@ -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),
|
||||||
|
|||||||
@@ -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)]
|
||||||
|
|||||||
Reference in new issue
Block a user