FireNet-2Hz: the design as it stands, and why

FDS splits space into blocks of cubic cells, with small cells near the house. Production output stores corner values, so the model works on corners. A 16³-cell block is a 17³ corner grid, which the halo pads to 19³.

Inside a block every cell has the same size, so the 3×3×3 kernel runs as usual. Before each native layer, each block's halo is filled from its neighbours, converted to this block's spacing:

• Same size or coarser neighbour: trilinear interpolation in the neighbour. Where the points line up, this is an exact copy.
• Finer neighbour: φV-weighted average of the fine corners inside this corner's box.
• Outside the domain: the first layer gets free-stream values (ambient gas, the wind, and the nearest corner's statics). Deeper layers get a learned fill, one for open sides and one for the ground.

How it runs changed. The halo and the interior gather are one sparse matrix product per layer, P = A x, whose backward is Aᵀ g. This avoids the atomics and the slow sort-based scatter that the first code spent much of its time in. Short-row products go through a small Triton kernel.

Pick a halo corner.

Alternatives (OctNet, mixed depth, graphs) are compared in convolution on cells of different sizes. Mixed depth is a separate follow-up (SCI-6238). Refreshing the halo only every second layer was tested and dropped: it was ×1.12–1.18 slower and changed the output by 10%.

Gas (on every corner)

Δ vs absolute. Slow, transported fields are predicted as a change. Fast or on/off fields (heat release, radiation, fluxes, burning rate) are predicted outright.

Units. Each field is put through asinh or log before the network sees it, for example asinh((T − 20 °C)/50 K) and asinh(HRRPUV / 100 kW/m³). Each output is in units of that field's spread on the training runs.

Dropped. Pressure is a low-Mach diagnostic. Radiation emission is mostly a function of T, and G carries the radiation target. The draft listed this as open; it is now settled.

Floors, no ceilings. Straight-through clamps keep T, Z, HRRPUV, q_inc and burning rate physical while still passing gradient. G is positive by construction through the log.

FDS solves each wall cell as its own 1-D heat-conduction problem, coupled to its neighbours only through the gas. So the head is pointwise, with no face-to-face convolutions.

It reads the same decoder features that produce the gas at t + Δt, so the walls see the model's own next-step gas.

Fluxes use FDS's own identity, so net flux always agrees with its parts:

PMMA burning: learned, behind a hard ignition gate changed. The draft leaned toward building in the scenario's burning curve. The code instead learns the burning rate from the face's features and memory. A PMMA face may burn only once its predicted wall temperature has reached 371 °C at this or an earlier step, and it then stays ignited. Ignition causality therefore holds by construction, and the curve does not have to be hard-coded per deck.

Faces across block boundaries new. A solid cell in one FDS mesh block next to a gas cell in the neighbouring block now makes a face, kept with its gas cell as FDS keeps it. On one run this added 2,905 faces, every one on a face centre FDS stores. Without them, house walls that start on a block boundary were missing.

Forcing (fireline, ignitors, wind, Δt) is read at the frame that ends the step. Earlier modular models read their boundary inputs one step late and needed a post-processing shift to fix it.

Δt is an input because FDS writes at the first step past each 0.5 s mark (for example 1.01 s).

No absolute time. FDS is time-invariant given state and forcing. A clock input would invite shortcuts like "the structure burns at 60 s" that don't transfer to new scenes. The fireline channel is the deck's ramp times the fireline's density, which is forcing, not a clock. What FDS keeps but doesn't write lives in face memory: the ignited flag, incident energy since ignition, and cumulative net heat (the dose).

Wind rotation was not built not in the design. The draft proposed turning each scene by one of the 8 grid symmetries so that the wind points within 0–45° of +x. The current code does not do this. Wind enters as u, v in the scene's own frame, from the deck's speed and direction ramps at every frame.

The draft planned a 1 → 20-step curriculum on one scene, then long rollouts up to 400 steps. That plan is replaced:

• H = 2 prefix for 150k optimizer steps on 4 GPUs. Windows are 2 steps long and start anywhere in 0–200 s.
• Pushforward from step 30k, on half the windows: n ≤ 20 steps without gradient from an FDS state, then an H-step window with gradient. n is capped at 20 because pushforward rollouts vary in length, and on 4 GPUs every step waits for the longest one.
• Fork A continues the prefix at H = 3, then H = 4, for 40k steps each. Fork B (longer unrolls) and fork C (input noise instead of pushforward, the cheap baseline that pushforward must beat) are deferred to SCI-6250. Both fork from the saved H = 2 checkpoint.
• Learning rate: linear warmup, then cosine decay to a floor. Gradients are clipped at norm 1. The learning rate is scaled down during pushforward. Steps with non-finite gradients are skipped; 100 skips mark the run as diverged.
• Why short windows: with no activation checkpointing, a 2-step window costs about 0.16 s and 4 GPUs see many scenes. The single-scene path keeps the old curriculum for overfit checks.

About 98% of the heat leaves through the open boundaries, so an exact energy budget can't close from 0.5 s snapshots. Instead the model's totals are compared with FDS's, on 16 m blocks and over the whole domain:

• The penalty compares both the level of each total and its change over the step.
• τ = 0 in plain windows: from a true state FDS is bit-repeatable, so any mismatch is error. In pushforward, τ is FDS's own spread: 0.24 for 16 m blocks and 0.10 for the domain.
• Per-vapour fuel release is now a term, as the draft proposed. Each vapour has one source, so this match is exact.
• The penalty is switched on by a flag. Once the gas term improves by less than 1% per 2k windows, its weight ramps 0 → 0.1 over 2k windows.

How FER is computed

• Production's point set. FER is the mean point FER over every boundary point of the cells that meet the main-building footprint. That set includes faces buried between two solid house voxels, which carry about 0 flux: 55–75% of the cells, so production FER is roughly half of the exterior-face FER. We keep that dilution instead of correcting it, so our numbers compare like with like. PLF = min(FER, 1.5) / 1.5.
• FDS's corner rule, both ways. FDS writes each boundary corner as the mean of the exposed wall cells around it. Prep inverts that rule to recover FDS's native per-face values, which become the training targets. The earlier target, the mean of a face's 4 corners, was a smoothed version: its 90th percentile was 5–17% off on hot faces. Corners rebuilt from the recovered values match the stored ones to ≤ 1.5·10⁻⁴. Eval then pushes the model's face values through the same rule. An alternative vertex-id rule was tested and was worse (−7 to −36%).
• Closing the gap. Adding the cross-block faces and the ground strip brought FDS through our path from 0.4–24% under production to within 0.0–1.6% on the 9 runs, and within 1.4% on 4 unseen runs.

Adopted

• bf16 U-Net: ×1.44–1.56 faster per H = 2 window and ×1.2 per no-grad rollout step, measured on 20 validation runs. FER and field error match fp32 to within the noise of turning TF32 off.
• Triton CSR kernel for the short-row sparse products (halo, its transpose, unpool): exact; 3–5% faster per training window and 10% per no-grad step.
• 4 windows per GPU, balanced by size (--slots 4), for an effective batch of 16 on 4 GPUs. Each scene visit draws 16 runs and sorts them by corner count into 4 size tiers. Each GPU gets one run per tier, and runs are swapped within tiers until the largest per-GPU total stops falling. Ranks then wait 0.1% of the time (4–6% before), with an imbalance of 1.006. The largest gradient norm fell from 42.9k to 2.1k, and no step was non-finite. Since rank waiting was small, most of the speed-up is bf16 and Triton.

Rejected, with the measurement

• bf16 state: fuel mass drifted −0.16% on every run; FER worse on 14 of 20 runs.
• Pre-padded layout (blocks stored with their halo): exact but ×1.38–1.54 slower. Convolutions, not gathers, dominate the native stack (weight gradient 28%, input gradient 17%, forward 10%, CSR halo 9%).
• Halo every second layer: ×1.12–1.18 slower, and the output differs by 10%.
• Linearity splits (first layer with statics precomputed; decoder without the concat): exact, but slower in eager mode.
• Earlier (single GPU): convolution as 27 shifted matmuls (slower than cuDNN), a Triton gather-GEMM halo conv, selective activation checkpointing, and CUDA-graph capture of a window (−1.5%; the step was GPU-bound).