Point-Cloud Surrogates for Aerodynamics: DoMINO

The job: predict aerodynamics straight from a shape

Give the model a car and ask: what does the air do around it? That is the whole task.

Designers iterate on shapes constantly — a slightly lower roofline, a different mirror, a reshaped rear. Each change alters drag, lift, and cooling. The gold-standard way to check is CFD, a physics simulation that computes the airflow over the body. It is accurate, but slow and heavy. Running it for every candidate design is a bottleneck.

DoMINO's job is to replace that per-design simulation with a fast prediction. The geometry arrives as an STL file or a point cloud — a set of points sampled on the surface of the car, which for a real vehicle can be millions of points. From that shape alone, the model predicts two kinds of answers:

• Surface quantities — the pressure pushing on the body and the wall shear stress (the drag the moving air exerts along the skin) at points on the car itself.
• Volume fields — the velocity and pressure of the air in the space around the car, including the wake trailing behind it.

The goal is a surrogate that is fast, accurate, and — importantly — scalable, so it works on full-resolution production geometry, not just a toy simplified into a coarse grid.

Why point clouds, not a fixed grid or mesh

Older surrogates often force the geometry onto a rigid voxel grid (like 3D pixels) or a carefully built mesh. Both add friction: a grid blurs fine detail unless it is very fine (and then it is huge), and a mesh has to be constructed and cleaned for each new shape.

A point cloud sidesteps this. It comes straight out of CAD or an STL export, it can represent any shape without special preparation, and it never squeezes the car into a rigid box of cells. What you sample is what you feed in.

But point clouds bring two real challenges the model has to handle:

• They are unordered and enormous. There is no natural row-and-column layout, and there can be millions of points. The model cannot assume a fixed grid position for anything.
• The answer at a point depends on two very different scales at once. The flow at one spot is shaped both by nearby surface detail (a sharp edge, a mirror) and by the whole body's shape (is this a boxy SUV or a low sports car?). The model must respect both without drowning in point count.

DoMINO's design is essentially an answer to that second point: keep a compact picture of the whole shape, and combine it with a local, detailed picture around wherever you are asking.

The big idea: local problems, anchored by global shape

Instead of solving the entire flow field in one giant shot, DoMINO answers one query point at a time — and each answer is anchored to a summary of the full geometry.

You can point at any single location — on the car's surface or out in the air — and ask DoMINO for the solution there, on its own. That independence is what the word "decomposable" means: the big problem is broken into many small, local ones that can be solved separately, yet each one still "knows" about the whole car through a shared global context.

Concretely, the model works in three stages:

1. Global multi-scale geometry encoder. Look at the whole point cloud and compress it into a compact global latent — a summary of the overall shape, captured at several scales.
2. Local geometry + dynamic stencil. For the query point you care about, gather its local neighborhood (a small subregion) and build a computational stencil — a set of nearby points used to estimate how the field behaves right there.
3. Aggregation network. Fuse the global latent, the local geometry, and the nearby flow information into a single predicted field value at that point.

Stage 1 — encoding the whole shape at many scales

The first stage reads the entire point cloud and compresses it into a global latent — a compact set of numbers that stands in for "the shape of this car." The important word is multi-scale.

Think about what determines airflow. Some of it is set by broad shape: is the rear a smooth fastback that lets air reattach, or a sharp notchback that separates the flow? Some of it is set by finer features: the exact curve of a fender, the gap around a mirror, the crease along a door.

Multi-scale simply means the encoder looks at the geometry through several "zoom levels" at once. A coarse level captures the overall silhouette; finer levels capture the smaller bumps and edges. If it only looked coarsely, it would miss detail that matters for drag; if it only looked finely, it would lose the big-picture context that governs the wake. By keeping several scales together, the global latent carries both the forest and the trees.

Because this summary is produced once for the whole geometry, every later query point can reuse it. That shared context is what lets each local answer still account for the rest of the car — including long-range effects that a purely local view could never see.

Stage 2 — local geometry and a dynamic stencil

Now zoom in to a single query point. Stage 2 does two things: it gathers the local subregion — the patch of geometry immediately around that point — and it builds a computational stencil.

A stencil is an old idea from classical CFD solvers. To estimate how a field (say pressure) changes at a location, a solver looks at a small set of neighbor points and compares values across them. That little set of neighbors is the stencil; it is how the solver "feels" the local gradients that physics cares about.

DoMINO borrows the concept but makes it dynamic: instead of a fixed hand-designed pattern, the network constructs the stencil on the fly from whatever neighbors are actually near the query point in the cloud. This keeps two things true at once — the local view respects physical locality (flow is influenced most by what is close), and it works for point clouds that have no fixed grid to hang a stencil on.

Stage 3 — aggregation, and why it scales

The final stage is the aggregation network. It takes the pieces assembled so far — the local geometry around the point and the stencil-based flow information from its neighbors — and combines them, together with the shared global latent, into the high-fidelity prediction at that point.

This division of labor is what makes DoMINO scale. Because each point is solved locally against a shared global context, the model never has to hold the entire flow field in one enormous computation. It is mesh-free — no simulation mesh to build — and it can be pushed to very large geometries by simply evaluating more query points.

The two halves cover complementary physics:

• The global latent carries long-range shape effects — how the overall body redirects flow, where the wake forms — that a purely local model could never infer.
• The local stencils respect physical locality — the fact that the field at a point is set mostly by its immediate surroundings and their gradients.

This is where the name pays off. "Iterative Neural Operator" reflects that DoMINO is doing operator learning — learning the map from geometry to flow field — but applied point by point, so the same learned operator is evaluated across the whole domain rather than in a single monolithic pass. Decomposable (per point), multi-scale (Stage 1), iterative operator (evaluated everywhere): the name is the method.

In practice — inputs, outputs, and where it lives

Putting it together, here is what you feed in and what you get back.

DoMINO has been validated on a realistic production mid-size SUV from General Motors — a genuine engineering geometry, not a simplified test body. It ships as part of the NVIDIA PhysicsNeMo framework, and for teams that want inference without training from scratch, it is packaged as the DoMINO-Automotive-Aero NIM microservice.

References