The job: aerodynamics, fast, over big geometries
Before you ship a car shape to a wind tunnel or an overnight CFD run, you want to screen dozens or hundreds of candidate designs quickly. That is the job of a surrogate: a neural network that takes a 3D geometry and predicts what a full computational fluid dynamics (CFD) solver would have produced — but in a fraction of a second instead of hours.
For FIGConvUNet the concrete outputs are the ones aerodynamicists care about:
- the pressure field on the surface of the body — where the air pushes hard and where it pulls;
- the velocity field of the air around the body;
- and the single number that summarizes all of it, the drag coefficient.
The catch is scale. These geometries are not toy shapes. They arrive as large 3D meshes or point clouds — anywhere from about 100,000 points for a simplified body up to roughly 1,000,000 points for a full car. A method that is elegant on a thousand points but chokes on a million is not useful here. So the whole design problem is: keep the accuracy of a grid-based convolutional model, but make it affordable at a million points.
Why a plain 3D convnet is too expensive
Convolutions love grids. So the obvious move is to drop the car into a 3D grid of little boxes (voxels) and run 3D convolutions over it. The trouble is what that grid costs.
Say the grid has resolution R boxes along each side. Then the number of boxes is R × R × R = R³. Convolution work scales with the number of boxes, so it scales like R³ — cubic in the resolution. That has a brutal consequence:
Double the resolution, and you do eight times the work. Going from 100 to 200 boxes per side turns one million voxels into eight million. To resolve the fine details of a car's surface you need a high resolution — and at high resolution a dense 3D grid becomes infeasible to store and to convolve.
There is a second problem that is easy to miss. Drag depends on the whole shape at once. Air that separates behind the rear of the car is affected by what happened over the hood far upstream. So the network needs a global receptive field — every output point has to be able to "see" the entire geometry. In an ordinary convnet, each layer only looks at a small local neighborhood, so reaching global scale means stacking many, many layers. That piles more cost on top of the already-cubic grid.
FIGConvUNet is built to defeat both problems at once: shrink the grid cost below cubic, and get a global reach cheaply.
The three ideas of FIGConv
FIGConv is really three tricks stacked together. Here they are stated plainly; the following sections unpack the first two.
(a) Factorized implicit grids
Instead of one dense, full-resolution 3D grid, FIGConv approximates the high-resolution domain with a small set of lower-dimensional, "implicit" grids. "Implicit" means the fine grid is represented compactly — it is never stored as one giant dense cube. Together these few compact grids stand in for a very fine grid, so you get high effective resolution without ever storing or convolving a dense 3D cube.
(b) Global convolution via 2D reparameterization
FIGConv re-expresses the 3D grid as a set of 2D planes and runs cheap 2D convolutions on them. Crucially, these convolutions are arranged so they still reach across the whole domain — a global receptive field — instead of only a local patch. This is the trick that drops the cost from cubic to quadratic.
(c) A U-shaped architecture (U-Net)
All of that lives inside a U-Net: an encoder that progressively downsamples, a decoder that upsamples back, and skip connections that carry fine detail straight across. The U shape lets the model gather and integrate information across many scales — local surface detail and whole-car context together.
Factorized implicit grids, in plain words
"Implicit" is the word that trips people up, so start there. An explicit grid is a full dense array: every voxel gets a stored value, all R³ of them. An implicit grid is one you can query wherever you like, but that is represented compactly — you do not pay to store or process a giant dense cube.
Now the "factorized" part. Rather than lean on a single fine grid, FIGConv uses a small collection of coarser grids, each placed a little differently — at different resolutions, and shifted by different offsets in space. No one of these grids is fine enough on its own. But together, because they cover the domain from slightly different angles, they can pin down features far smaller than any single grid's spacing.
Think of laying several coarse rulers over the same object, each nudged by a fraction of a tick. No single ruler resolves the fine marks — but overlaying them, their combined marks land almost everywhere. A handful of cheap coarse grids, offset from one another, approximate one very expensive fine grid. That is the "high effective resolution without the dense cube" idea in a sentence.
The payoff: you keep the fine detail the surface pressure needs, but the memory and compute stay tied to a few small grids rather than one enormous dense one. This is what breaks the storage side of the cubic trap.
Global convolution by folding 3D into 2D
Compact grids fix storage. But convolving in 3D is still the expensive part, and we still need a global reach. FIGConv's second trick handles both: it folds the 3D grid into stacks of 2D planes and convolves those instead.
Concretely, the 3D volume is projected/factorized onto sets of 2D planes aligned with the coordinate planes — one stack looking down the XY face, one the YZ face, one the XZ face. Each plane is convolved cheaply in two dimensions. Because the planes span the full extent of the domain, a 2D convolution across a plane already reaches from one side of the car to the other — that is the global receptive field, obtained without stacking dozens of layers. The three stacks are then recombined so the model still sees the full 3D structure.
Complexity drops to O(N²) instead of the O(N³) of dense 3D neural CFD. Here N is the scale of the grid — roughly the number of boxes along a side, or equivalently how finely the points are resolved. Dense 3D convolution grows like N cubed because it fills a full cube of voxels; folding into 2D planes grows like N squared because each plane is two-dimensional. That one exponent is the difference between "runs on a million-point car" and "does not."
The U-Net wrapper and what comes out
The factorized implicit grids and the 2D global convolutions are the engine. The U-Net is the chassis that holds them and turns internal features into the fields you asked for.
A U-Net has two halves joined at the bottom. The encoder repeatedly downsamples, compressing the geometry into coarser, more abstract representations that capture whole-car context. The decoder then upsamples step by step back to full resolution, reconstructing the detailed output field. Between matching levels run skip connections — direct shortcuts that hand fine-grained detail from the encoder straight to the decoder, so sharp features are not lost in the round trip. The net effect is that local detail and global context are integrated together, which is exactly what drag prediction needs.
What comes out the far end:
- the pressure on the surface of the body, point by point;
- the drag coefficient, the scalar summary of aerodynamic resistance;
- and the surrounding velocity fields.
Results and where it fits
FIGConvUNet was validated on two standard automotive benchmarks: the Ahmed body (a simplified reference shape, around 100,000 points) and DrivAerNet (a realistic dataset based on the Volkswagen DrivAer body, around 1,000,000 points).
On the DrivAerNet benchmark for drag prediction, FIGConvUNet reached:
- R² = 0.95 for drag — a tight fit between predicted and true drag;
- a 40% improvement in relative mean-squared error over the previous state of the art;
- and a 70% improvement in absolute mean-squared error over the previous state of the art.
It is available as an example in NVIDIA PhysicsNeMo (the figconvnet example), so you can run and adapt it rather than reimplement it from the paper.
How the trick compares to its neighbors
FIGConvUNet is one of three broad families of CFD surrogates for large geometries. They differ mainly in how they let each output point gather information from the rest of the body:
| Approach | Core trick | Reach |
|---|---|---|
| FIGConvUNet (convolutional) |
Grid convolution — fold 3D into factorized 2D planes, convolve globally | Global, at O(N²) |
| DoMINO (point cloud) |
Local stencils — gather from nearby points around each query location | Local neighborhoods |
| Transolver (transformer) |
Slice-attention — group points into physical "slices" and attend across them | Global via attention |
Same goal, three different bets on geometry: FIGConvUNet bets on grid convolution (structure you convolve over), DoMINO bets on local point stencils (mesh-free neighborhoods), and Transolver bets on slice-attention (learned physical groupings). Pick by data shape, resolution needs, and how global the physics is.
References
Factorized Implicit Global Convolution for Automotive Computational Fluid Dynamics Prediction. arXiv:2502.04317.
NVIDIA PhysicsNeMo — Factorized Implicit Global Convolution Network (FIGConvNet) (documentation / example).
DrivAerNet — automotive aerodynamics benchmark dataset (based on the Volkswagen DrivAer body).