FireNet-2Hz: how the model steps a fire forward

FireNet-2Hz is a neural network that learns to reproduce a fire simulation (FDS) around a house, one 0.5 s step at a time. This page shows what the model reads, what it predicts, how it is trained, and what the first test must show. It is a draft design: items marked open still need a decision.

Short version.
  1. The model is a convolutional U-Net on FDS's own voxel blocks. Blocks of different cell sizes talk through a one-cell halo.
  2. It predicts the gas (temperature, velocity, mixture fraction, radiation, heat release) and, through a small per-face network, the burning surfaces and the heat flux on the house.
  3. Fireline, ignitors and wind come from the scenario file and go in as forcing, read at the time being predicted.
  4. The loss rewards fire where FDS has fire and punishes false fire. Conservation is a soft penalty on heat and mass totals, not an exact constraint.
  5. Training starts on 1-step windows, grows to 20 steps (10 s), then to full 200 s rollouts scored on house dose and totals.

One step: state at t → state at t + 0.5 s

Every input is either fixed geometry, forcing from the scenario file, or something the model itself produced one step earlier. Anything else could not be supplied during a rollout.

predicted and fed back derived from predictions forcing from the scenario static geometry and materials
State at t Gas corners: T, U, V, W, Z, G, HRRPUV Faces: wall temperature, fluxes, burning rate, fuel mass, memory Z = mixture fraction, G = radiation Static Gas: cell size, gas fraction, height above ground, wall area, vegetation Faces: normal, area, surface type, material properties (never IDs) Forcing at t + Δt Fireline heat source (first 20 s) Ignitor surface area (held at 696 °C) Wind u, v (whole domain) Actual Δt / 0.5 s No absolute time Halo U-Net (3×3×3 convs, residual, LayerNorm, GELU) native corners 32 ch · 2 layers native 32 ch · 2 layers 4 m 128 ch · 4 layers 4 m 128 ch · 4 layers 16 m 256 ch · 2 layers 16 m 256 ch · 2 layers 64 m 256 ch · 2 layers pool: volume- weighted mean unpool: copy skip Gas head → gas at t + Δt Change (Δ): T, U, V, W, Z Absolute: G, HRRPUV Floors: T ≥ min, Z, G, HRRPUV ≥ 0 Zero-initialised: starts as "no change" Face head (small MLP, one per face) Reads decoder features at its gas cell → wall T, convective flux, incident flux, burning rate Derived: radiative and net flux (FER), fuel mass (can only go down) fed back as the next state

Level depths follow measured transport: hot gas moves 3–7 m per 0.5 s step (median), up to 6–25 m at the 99th percentile, so one step can cross many native cells. The 4 m and 16 m levels carry that reach; 64 m covers the whole 128–204 m domain.

The grid: FDS's blocks, corner values, and a one-cell halo

this block's corners halo: copy (same size) halo: average (finer) halo: interpolate (coarser) halo: free stream (outside)

Click or hover a coloured halo corner to see which neighbour values fill it.

FDS splits space into blocks of cubic cells; blocks near the house use small cells. The production output stores corner values, so the model works on corners: a 16³-cell block is a 17³ corner grid, padded to 19³ by the halo.

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

  • Same size: copy the neighbour's corner.
  • Finer neighbour: volume-weighted average of the fine corners inside this corner's box.
  • Coarser neighbour: trilinear interpolation. It equals a copy where corners line up; elsewhere a copy would put a step into the halo.
  • Outside the domain (open on four sides and the top): free-stream values in layer 1, a learned fill deeper down.

Cell size is an input channel, so the same weights know whether a step is 0.5 m or 2 m. Fully solid corners stay in the grid at ambient and are masked out of every loss.

Pick a halo corner.

More on the alternatives (OctNet, mixed depth, graphs): convolution on cells of different sizes.

What is predicted, derived, or dropped

Gas (on every corner)

TEMPERATURE · ΔU, V, W · ΔMIXTURE FRACTION · Δ INTEGRATED INTENSITY (G) · absoluteHRRPUV · absolute DENSITY from T (ideal gas) PRESSURERADIATION EMISSION

Δ vs absolute. Slow, transported fields are predicted as a change. Fast or on/off fields (heat release, radiation, fluxes, burning rate) are predicted outright: an earlier model's flux "off" state was only fixed by that switch.

Dropped: pressure is a low-Mach diagnostic that dominated an earlier model's loss; radiation emission is mostly a function of T and soot, and G carries the radiation target. open

Floors, no ceilings. Straight-through clamps keep T, Z, G, HRRPUV and burning rate physical while still passing gradient. No upper caps: a 1,400 °C cap once made a stability check impossible to fail.

Where the combustion heat comes from

Ground surface fuel (grass, pine needles): median 77% Ground surface fuel77% PMMA buildings: median 23% PMMA buildings23% Vegetation particles: median 0.16% Vegetation particles0.16% Median share per run, 280 production runs

So vegetation particles are skipped, and the model predicts the two real fuels: the ground surface fuel and the PMMA faces. The fireline and ignitor particles are prescribed by the scenario and enter as forcing.

Faces (from the boundary output)

FieldMain house (inert)PMMA buildingsGround fuel
Wall temperaturestatic (ambient)predicted Δpredicted Δ
Convective heat fluxpredictedpredictedpredicted (low weight)
Incident heat fluxpredictedpredictedpredicted (low weight)
Radiative heat fluxderivedderivedderived
Total (net) heat fluxderived: the FER quantityderivedderived
Burning rate–predicted ≥ 0predicted ≥ 0
Fuel mass–integrated, never increasesintegrated, never increases

Teal: predicted and fed back. Blue: derived from predictions. Gray: fixed.

Faces: a list with a per-face head open

gas cell next to the face wall face (house, PMMAor ground fuel) 2D sketch: 8 corners in 3D gather + 4 m, 16 m features 2-layer MLP, 128 wide wall Tconvective flux burning rateincident flux + face's own state and memory scatter: mean wall T, fuel release per volume (wood vapour, MMA) for the next step

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: no face-to-face convolutions.

It reads the same decoder features that produce gas at t + Δt, so the walls see the model's own next-step gas. That is the coupling order that worked best in the earlier modular models.

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

q_rad = ε · (q_inc − σ T_w⁴)
q_net = q_conv + q_rad   ← FER
m ← max(m − Δt · ṁ″ · A, 0)

PMMA burning: either learned from memory features (an ignited flag once the wall reaches 371 °C, and incident energy since ignition), or built in as the scenario's burning curve scaled by incident flux. Leaning built in. open

Cost: about 1.4 GiB extra working memory on the largest scene (254k faces); FLOPs negligible next to the convolutions.

Wind rotation: snap to 0–45°, pass the rest as input open

Every scene is turned so the wind blows roughly along +x. Turning by an arbitrary angle would resample FDS's axis-aligned blocks and break the block layout and face IDs.

Instead the model uses one of the 8 exact symmetries of the square grid (a quarter turn, optionally followed by swapping x and y). Cells are cubic in every production scene, so these are lossless and map back exactly for FER. The leftover 0–45° goes in through the wind u, v channels.

Wind direction varies by about 1.5° within a run, so one snap per scene suffices.

Forcing and time: read forcing at the step being predicted

t − Δt t t + Δt state forcing predicted state old forcing earlier models: one step late

Forcing (fireline, ignitors, wind, Δt) is read at t + Δt, or averaged over 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 (for example 1.01 s).

No absolute time. open FDS is time-invariant given state and forcing; a clock input invites "the structure burns at 60 s" shortcuts that don't transfer to new scenes. What FDS keeps but doesn't write (heat stored inside solids) lives in face memory: cumulative net heat (also the dose), and for PMMA the ignited flag and incident energy since ignition.

Loss: fire where FDS has fire, and no false fire

Every term is divided by a running average of its own size, so weights below are relative importances. Starting values are first-pass guesses.

Short windows (1 → 20 steps, 10 s)

  • Gas and faces: Huber per corner or face, extra weight where either FDS or the model is hot (T > ambient + 50 K), so the fire set carries about half the weight. Missing fire and false fire both cost.
  • Overlap (4 m, 16 m): how much the hot regions overlap at block scale, so a plume one cell off is not punished like a missing one.
  • House exceedance: whether each house face is above 40 kW/m², and time above it.
  • No asymmetric weights: a 3:1 asymmetry alone once caused a heat runaway.

Long rollouts (up to the full 200 s)

  • Past 10 s, fine-scale gas decorrelates even between two FDS runs, so there are no per-corner terms: they would train toward a blurred plume.
  • Instead: house dose and time above 40 kW/m², the flux distribution, total heat release, and 16 m fields, each with a dead zone at FDS's own run-to-run spread.
  • Baseline arm: input noise instead of long rollouts. Long rollouts must beat it.

Curriculum

  • K = 1 for the first 10k windows, then 2, 4, 8, 12, 16, 20 for about 3k windows each; one window per optimiser step.
  • Once K = 20, half the samples become long rollouts: run n steps without gradient from an FDS state, then a gradient window. n grows 20 → 60 → 200 → 400 (the full run); the window grows 1 → 4.
  • Window starts are drawn uniformly over 0–200 s, so every fire phase is seen.

Conservation: a soft penalty with a dead zone

Shape only: the Huber transition width here is illustrative.

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 the whole domain:

HRR = Σ φV · HRRPUV
E_s = Σ φV · ρ₀c_pT∞(1 − T∞/T)
M_Z = Σ φV · ρ(T) · Z
r = (pred − FDS) / (|FDS| + 0.01 · scene peak)
L = huber(max(0, |r| − τ))
  • τ = 0 in short windows (from a true state, FDS replays bit-for-bit). In long rollouts τ is FDS's own spread: 10% for domain heat release.
  • The penalty weight ramps 0 → 0.1 once the 1-step loss stops improving.
  • Proposed extra term: fuel released per vapour (Σ burning rate × area) against FDS's mass-loss totals. Each vapour has one source, so this match is exact. open

Memory: a 20-step window fits one H100 in fp32

Median scene: about 18 GiB gas + 1.4 GiB face head Median scene~19 GiB Largest scene: about 36 GiB gas + 1.4 GiB face head Largest scene~37 GiB 74.5 GiB usable 0

fp32 (TF32 matmuls), native cells, one H100 80 GB, checkpointing every step. Checkpointing costs about a third more compute but is unavoidable: without it a 20-step window needs 128–255 GiB.

Estimates scaled from CPU measurements; real peak memory and step time are an M1 check.

What the first test (M1: overfit one scene) must show

Read on the training scene: a full 0–200 s rollout from t = 0, plus 20-step windows from states across the run.

1Totals within FDS's run-to-run spread over the full rollout: domain heat release within 10%, 16 m within its floors.
2No late runaway: heat ratio over the last 20 s flat, last-step ratio 0.8–1.25; false-fire volume doesn't grow.
3Short windows: step-20 error below FDS's own noise floor for T, U, V, W.
4House: dose and time above 40 kW/m² within 6% of FDS; the flux identity holds exactly.
5Fire placement: hot-volume bias 0.9–1.1 at 4 m and 16 m per phase; plume heat above 20 m ≥ 0.8 of FDS (the known failure is heat aloft).
6Ignition causality: no PMMA face burns before its wall reaches 371 °C; onset within ±2 s of FDS.
7Bounds by construction: no NaN, fuel mass never increases, Z ≥ 0.
8Ablation: conservation penalty off vs on, 2 seeds each.
9Cost: measured peak memory and step time against the estimates above.

Open questions

#QuestionLeaning
1Predict T, U, V, W, Z, G, HRRPUV; drop pressure and radiation emission; derive density from T (checked on the pilot data)?yes
2Supervise heat release only through 16 m and domain totals, or also a 4 m pooled term (it is fed back)?add the 4 m term
3Faces as a list with a per-face head, rather than six face slots on every gas corner?yes
4Predict convective and incident flux, and derive radiative and net?yes
5PMMA burning learned with memory features, or built in (the scenario's burning curve scaled by incident flux)?built in
6Wind along +x by the 8 grid symmetries plus the leftover angle in the wind inputs?yes
7No absolute-time input?yes
8Fuel release per vapour as a conservation term?yes
9A hidden ground-fuel state if the boundary output doesn't cover the terrain?decide after the pilot check