Convolution on cells of different sizes

A 48 × 48 m domain, cut into blocks of 4 × 4 cells, the same way FDS uses blocks of 16 × 16 × 16 in 3D.

The colours show a made-up temperature: a fire next to the house (bottom middle), a plume rising and leaning right, and a small hot spot (right of the fire) that only the 1 m cells can resolve.

The sizes meet in three ways: 1 m next to 2 m, 2 m next to 4 m, and 1 m directly next to 4 m (a jump of 4×). Every approach below has to handle all three.

Cut every cell into 1 m pixels, copying the value into each one, then run a normal CNN on a 48 × 48 image.

Good

• Standard image CNN, nothing custom.

Catch

• Most pixels are copies: they hold no information FDS computed, and the network spends nearly all its compute on them.
• In 3D the ratio is far worse, since each size jump costs 8×, not 4×: 0.25 m everywhere is ~168 M cells, against 1–4 M real FDS cells. That is about 1,300 GiB of activations per training step.
• The loss would ask the model for fine detail that the labels don't contain.

Average the small cells into 4 m pixels and run a normal CNN on a 12 × 12 image.

Good

• Standard CNN, tiny.

Catch

• The hot spot next to the house is averaged away. In the real problem, the heat on the house walls is decided at exactly that scale.
• It is still useful as the coarse level of a U-Net (approach C or D), not as the whole model.

Keep FDS's blocks as they are. Each block is a small regular image at its own cell size. Before every conv layer, wrap each block in a one-cell halo filled from its neighbours, converted to this block's cell size:

After that, every block is just a 6 × 6 image (right), whatever its cell size. All blocks of the same shape are stacked into one batch and run through one ordinary conv2d (conv3d in 3D). The cell size goes in as an extra channel.

Good

• Keeps every real FDS cell and nothing else; the halo is rebuilt each layer and thrown away.
• Dense convs on GPU tensor cores, and no per-neighbour tensors to store. In 3D, about 13–33 GiB per step for the gas (estimate), against ~110–215 for a GNN.
• Which cells fill each halo cell is fixed per scene, so it is precomputed once as a gather map.

Catch

• The halo map is custom code: one gather per layer.
• The kernel reaches 1 cell, so 1 m in a fine block and 4 m in a coarse one. Reach over distance comes from coarse U-Net levels, not from this layer.

Layers L = 3

What this means

• Reach per layer is one local cell: 1 m among the 1 m cells and 4 m among the 4 m cells. FDS chose small cells where things change fast, so the network looks closer exactly where detail matters.
• Crossing into a bigger-cell region, reach in metres grows faster. Crossing into a smaller-cell region, the averaged halo hands over a summary of several small cells at once.
• Plain average and copy are fixed rules. Since features are not physical quantities, they can be swapped for learned transfers: a stride-2 conv from fine to coarse and a transposed conv from coarse to fine. That costs a few weights per size pair, and the conservation step (refluxing) is unchanged.
• Going 25 m in one 0.5 s step would take 25 layers among 1 m cells. That is what the coarse U-Net levels are for: pool to 4 m and 16 m grids, take a few layers there, and bring the result back.

One layer, in code

for layer in layers:
    halo = gather(features, halo_map)  # copy or average
    x = pad_with(features, halo)       # (n_blocks, C, 6, 6)
    features = act(norm(conv(x)))     # one batched conv

Group all cells of one size into one rectangle (its bounding box) and treat each rectangle as one image, with a ghost ring filled the same way as C's halo. The coarsest level covers the whole domain, including under the finer patches.

Good

• Few, large images: fewer conv calls and fewer halo cells than C.
• The coarse level is already a full-domain image, which is the first level of the U-Net.

Catch

• If one size's cells don't form a rectangle (an L-shape, say), the bounding box contains padding. In FDS that depends on how box-shaped each scene's refinement is.

Skip the blocks. For every cell, place the 3 × 3 kernel at the cell's own size and look up what sits under each of the 9 positions, with the same rule as C (copy, average or boundary). Libraries such as spconv, TorchSparse and MinkowskiEngine do this with hash tables, and octree CNNs (O-CNN) do it on quadtrees and octrees.

Good

• No halo storage; works for any layout.

Catch

• Most sparse-conv libraries assume one cell size per level, so the cross-size averaging is still ours to write.
• Gathers are slower than C's dense block convs. C does the same thing, grouped into regular blocks.

Each cell is a node, and each pair of cells sharing a face is an edge, whatever their sizes. A layer computes a message on every edge with a small MLP, then each node sums its incoming messages.

Good

• Handles any sizes and any shapes with no special rules. A big cell simply has more neighbours.
• The natural fit for walls and vegetation particles, which are not on a grid.

Catch

• Training stores a hidden vector on every edge, per layer. In 3D a cell has about 6 face edges, which is why activation memory is about 6–8× a CNN on the same cells (~110–215 GiB per step vs ~13–33).
• Scatter and gather are memory-bound: slower than dense convs on a GPU.

Define the kernel as a function of physical offset in metres. Every cell centre within R metres is a neighbour, weighted by a small network applied to the offset (as in KPConv and continuous convolutions).

Radius R = 3.0 m

Good

• One rule for any sizes, positions or point clouds.

Catch

• The neighbour count swings with cell size: a radius that suits a 4 m cell sweeps in dozens of 1 m cells near the house.
• Each neighbour pair stores an intermediate tensor, as in a GNN, so memory is at least as high.

The model updates each cell by what flows through its faces: new amount = old amount + inflow − outflow. If every face's flow is counted once, as outflow on one side and inflow on the other, nothing appears or vanishes.

Where a 2 m cell meets two 1 m cells, the big cell's single face lines up with two small faces. If each side computes its own flux, they disagree, and the difference leaks.

Refluxing is the standard fix in adaptive-mesh CFD. The pairing of each big face with its small faces is fixed per scene, so it is precomputed alongside the halo map. It applies in the same way to C, D and E.