PhysicsNeMo-Mesh: GPU-Native Meshes and Simulation Cases for Physics AI

Peter D. Sharpe; Corey Adams; Negin Sobhani; Sanjay Choudhry

physics.comp-phOct 29, 2026

PhysicsNeMo-Mesh: GPU-Native Meshes and Simulation Cases for Physics AI

Authors: Peter D. Sharpe, Corey Adams, Negin Sobhani, Sanjay Choudhry

Organizations: NVIDIA Corporation

Abstract

PhysicsNeMo-Mesh is the mesh module of the open-source PhysicsNeMo library. It provides mesh processing similar to PyVista, but on the GPU, in batches, and inside PyTorch's automatic differentiation. Like xarray for unstructured meshes, it attaches semantics to data: fields on points, cells, and whole meshes have names and shapes, and a simulation case keeps the complete PDE problem specification, including boundary conditions and their prescribed values. It addresses three problems that plague machine learning for physical simulation. First, GPU utilization is bottlenecked by I/O, because samples are very large relative to the compute per forward pass. Second, because traditional preprocessing is expensive, it is necessarily done once, during curation, rather than differently for each model and workflow at the point of use. Finally, advanced equivariant and mesh-native architectures require information that curation ordinarily discards. Fast GPU mesh processing makes it practical to preprocess at the point of use: on one GB200 GPU, mesh operations run $6.2\text{--}1{,}068\times$ faster than VTK with 72 threads, and loading a whole case is $8.0\text{--}88\times$ faster than reading its VTK files ( $8.0\times$ when both read the same fields). Overlapped with training, this preprocessing costs $2.1\%$ of throughput for a $127\,\text{ms}$ Transolver step. So one dataset serves many models and workflows: in PhysicsNeMo's public recipe, one stored DrivAerML dataset feeds Transolver, GeoTransolver, and GLOBE. PhysicsNeMo-Mesh combines the speed of an intermediate array store with the flexibility of an archival format such as VTK. When shapes and wall conditions both vary, per-boundary conditions cut a heat-conduction error from $87\%$ to $6\text{--}9\%$ . And by keeping field ranks and named boundaries, it retains the semantic structure that next-generation architectures will need.

Figures & tables

Figure 1: One Mesh class for all four manifold dimensions, so each operation is written once: points ( Mesh[0, 3] ), line segments ( Mesh[1, 3] ), triangles ( Mesh[2, 3] ), and tetrahedra ( Mesh[3, 3] ). Each holds points, simplicial cells, and named fields.

PyVista (VTK, CPU)	PhysicsNeMo-Mesh (GPU)	Speedup
car.transform(R, ...)	car.rotate(a, "z", ...)	6.2 $\times$
car.reflect(n).append_polydata(car)	Mesh.merge([car, car.transform(M)])	76 $\times$
car.extract_cells(ids)	car.slice_cells(mask)	968 $\times$ b
car.compute_normals(...)	car.cell_normals	12 $\times$
pts.compute_implicit_distance(car)	signed_distance_field(car, pts)	350 $\times$
car.fill_holes(size)	fill_holes(car)	20 $\times$ b

Table 1: Matching PyVista and PhysicsNeMo-Mesh calls, with GB200 speedups over VTK’s

72

-thread backend on Grace CPUs.

b

: different by design;

d

: VTK and NumPy; warm: locator reused.

Figure 2: An AirfRANS case ( Bonnet et al., 2022 ) as a DomainMesh : the interior mesh, the named airfoil and freestream boundaries, and the freestream velocity $U_{\infty}$ in global_data .

Dataset	VTK read	+ conversion	PhysicsNeMo-Mesh	Speedup	VTK	PhysicsNeMo-Mesh	Ratio
	Cold load of one case				Size on disk [GB]
DrivAerML	$388.7\text{\,}\mathrm{s}$	$403.5\text{\,}\mathrm{s}$	$4.44\text{\,}\mathrm{s}$	88 $\times$	49.7	6.3	7.9
HiLiftAeroML	$113.7\text{\,}\mathrm{s}$ †	$271.8\text{\,}\mathrm{s}$ ‡	$14.23\text{\,}\mathrm{s}$	8.0 $\times$	107.3	20.0	5.4
SHIFT-SUV	$67.5\text{\,}\mathrm{s}$	$71.3\text{\,}\mathrm{s}$	$1.21\text{\,}\mathrm{s}$	56 $\times$	4.4	1.6	2.7

Table 2: Cold load of one case (interior and boundary), median of three from local NVMe on one machine. VTK is timed reading ( pv.read ) and with conversion to Mesh ; the speedup uses the read alone. For DrivAerML and SHIFT-SUV, VTK reads whole files while the copies keep only the physics fields.

\dagger

: VTK reads only the physics fields (full files:

136.0\text{\,}\mathrm{s}

\ddagger

: with

13\text{\,}\mathrm{s}

of cleaning ( Section A.2 ).

Figure 3: The GPU is faster on every operation except field transfer with a reused locator (

0.96\times

), with a median speedup of

198\times

on the DrivAerML car surface. Bars show the speedup of one GB200 GPU over a

72

-thread Grace CPU baseline (the fastest batch VTK filter, or NumPy/pyacvd where VTK lacks an equivalent) across all operations in Table 3 .

Figure 4: Overlap hides most of the preprocessing for the

127\text{\,}\mathrm{m}\mathrm{s}

step (

2.1\%

cost through the DataLoader) and none for the launch-bound

23\text{\,}\mathrm{m}\mathrm{s}

step (

35\%

), because kernel launches saturate the host thread ( Section 4.4 ). Bars show the throughput reduction of configurations B–D relative to configuration A for both model sizes ( Table 5 ).

Figure 5: Two orders of the same four stages. A conventional pipeline preprocesses on the CPU and then stores model-specific arrays. With a stored DomainMesh , the mesh is stored first and each model’s features are computed on the GPU at training time, so the stored dataset does not depend on the model.

Figure 6: One stored case, three models. (a) The DomainMesh the recipe’s pipeline builds from one stored DrivAerML case: the interior, the named boundary mesh, and the reference freestream conditions in global_data . (b) The forward_kwargs blocks of the three surface-model configurations in the PhysicsNeMo unified external-aerodynamics recipe (two long paths are wrapped for display). Each entry extracts a field from the DomainMesh in (a), so all three models share a single DrivAerML dataset. GLOBE’s reference_lengths are constants, in units of the scaled positions, that set the length scales of its multiscale kernels: a reference length L_ref and a turbulent boundary-layer thickness delta_turb .

Figure 7: Only the per-boundary conditions keep the error low as the wall conditions vary. Each panel is one architecture. Markers are medians over eight training seeds of the mean relative

L_{2}

error on 200 unseen geometries, and bars span the seeds. The gray curve is the lowest expected error that any model seeing only the geometry can reach (zero at

\sigma=0

Figure 8: Three unseen geometries at $\sigma=1$ (rows), with Transolver predictions (seed 0). Teal walls have a fixed temperature (Dirichlet), and gold walls a prescribed heat flux (Neumann). Without the conditions, the model returns one field per geometry, whatever the wall conditions are: a faded copy of the nominal pattern that the conditions vary around. Under relative error, which weighs small fields more, that faded copy scores better on average than the nominal pattern itself ( Section B.3 ). The global vector of five wall summaries recovers the broad pattern in the first two rows but not in the third, and the per-boundary conditions recover the field in all three. Each row has its own color scale. The rows are the test geometries at the 20th, 50th, and 80th percentiles of the shape deformation, chosen before training.

Figure 9: Flattening named fields into one array of columns. The Mesh keeps each field’s name and trailing shape, so scalars and vectors stay distinct; in the flat array, only the column order says which columns form a vector.

Figure 10: One flagged rotate call is a change of frame; the angle of attack is unchanged. The airfoil, the velocity field, and $U_{\infty}$ in global_data turn together by $0.1\text{\,}\mathrm{r}\mathrm{a}\mathrm{d}$ .

Appendix figures & tables4 assets

Supplementary material from the paper’s appendix.

Appendix

Operation	CPU	GPU	Speedup	Peak GPU [GB]
DrivAerML car surface, 17,684,913 triangles
Linear subdivision, one level	$11.1\text{\,}\mathrm{s}$	$10.4\text{\,}\mathrm{m}\mathrm{s}$	1,068	6.8
Subset by tag b	$400\text{\,}\mathrm{m}\mathrm{s}$	$413\text{\,}\mathrm{\SIUnitSymbolMicro}$	968	1.4
Remesh to 200,000 points a	$29.4\text{\,}\mathrm{s}$	$46.0\text{\,}\mathrm{m}\mathrm{s}$	639	2.0
Area-weighted sampling, $10^{6}$ points a	$1.3\text{\,}\mathrm{s}$	$2.4\text{\,}\mathrm{m}\mathrm{s}$	550	2.0
Loop subdivision, one level	$24.8\text{\,}\mathrm{s}$	$46.7\text{\,}\mathrm{m}\mathrm{s}$	531	12.6

Appendix

Table 3: All

23

operations: the minimum time on

72

Grace CPU threads and on one GB200, the speedup, and the peak GPU memory, which includes the resident input mesh.

a

: the CPU baseline is not VTK (NumPy for sampling, pyacvd for remeshing).

b

: the two sides compute different quantities by design (see text).

c

: the input is a triangle soup of the car with every vertex unshared.

Operation	Mesh	Largest size	GPU time	CPU time	Peak GPU [GB]
Area-weighted sampling, $10^{6}$ points a	Triangles	336M	$33.4\text{\,}\mathrm{m}\mathrm{s}$	$23.5\text{\,}\mathrm{s}$	32
Cell normals	Triangles	336M	$32.0\text{\,}\mathrm{m}\mathrm{s}$	$432\text{\,}\mathrm{m}\mathrm{s}$	27
Field transfer, $10^{6}$ queries	Tetrahedra	384M	$489\text{\,}\mathrm{m}\mathrm{s}$	–	153
Gradient (least squares)	Tetrahedra	257M	$352\text{\,}\mathrm{m}\mathrm{s}$	$3.7\text{\,}\mathrm{s}$	58

Appendix

Table 4: The largest size of each size sweep on one GB200, with the GPU time, the VTK (or

a

: NumPy) time with the

72

-thread VTK backend, and the peak GPU memory. Gradient failed at the next size,

384

M tetrahedra, on an int32 element-count limit inside torch.unique .

	6.0M parameters		1.7M parameters
Configuration	Steps/s	Cost	Steps/s	Cost
A: precomputed features (no augmentation)	7.87	–	46.33	–
B: on the fly, serial	7.41	5.9%	32.95	28.9%
C: on the fly, DataLoader	7.70	2.1%	30.07	35.1%
D: on the fly, DataLoader, cached geometry	7.73	1.8%	29.92	35.4%
Training step alone [ms]	127.0		22.6

Appendix

Table 5: Training throughput of a surface Transolver with per-step preprocessing on one GB200 (median of three repetitions; cost relative to configuration A, which does no augmentation). The larger model is the recipe’s surface model; the smaller is a reduced

1.7

M-parameter model (four layers, width 192). Preprocessing alone takes

9.9\text{\,}\mathrm{m}\mathrm{s}

per sample, including the host-to-device copy.

Model	$\sigma$	Floor	Geometry only	+ global BC vector	+ per-boundary BC
Transolver	0	0.000	0.009 (0.008–0.010)	0.009 (0.008–0.010)	0.011 (0.010–0.011)
	0.1	0.112	0.113 (0.113–0.115)	0.087 (0.079–0.101)	0.042 (0.037–0.046)
	0.25	0.277	0.278 (0.277–0.280)	0.144 (0.139–0.152)	0.050 (0.048–0.054)
	0.5	0.526	0.529 (0.527–0.532)	0.251 (0.241–0.263)	0.066 (0.063–0.075)
	1	0.850	0.866 (0.863–0.867)	0.457 (0.440–0.462)	0.094 (0.067–0.108)
	2	0.967	0.980 (0.978–0.982)	0.542 (0.529–0.558)	0.100 (0.079–0.194)

Appendix

Table 6: Geometry and boundary conditions both vary. Mean interior relative

L_{2}

error on 200 unseen geometries: medians over eight seeds, with the range over seeds in parentheses. Floor: the lowest expected error of any predictor that sees only the geometry.

GPU Acceleration

GPU acceleration uses parallel processors, specialized kernels, and memory-aware systems to speed computation across AI and scientific workloads.

See all 174 papers

Mesh Field Theory: Port-Hamiltonian Formulation of Mesh-Based Physics
May 1, 2026Satoshi Noguchi, Yoshinobu KawaharaDynamical Systems Scientific ML
Center for Mathematical Science and Advanced Technology, JAMSTEC · Center for Advanced Intelligence Project, RIKEN · Graduate School of Information Science and Technology, The University of Osaka.
Gen2Physics: Grounding Generated 3D Meshes in Physics via Multi-View Material Decomposition
Aug 24, 2026Mauro Comi, Jordi Serrano Berbel, Kevis-Kokitsi Maninis +23D Asset Generation
Google DeepMind · University of Bristol · Google Research
Mesh-Native Tokenisation: Retrofitting Foundation Models to Unstructured Data
Oct 8, 2026Georg Maierhofer, Miles Cranmer, Payel MukhopadhyayPhysical Foundation Models Convolutional Neural Networks
University of Cambridge

May 1, 2026J/K move · Enter open · S save

Mesh Field Theory: Port-Hamiltonian Formulation of Mesh-Based Physics

Satoshi Noguchi, Yoshinobu Kawahara

Center for Mathematical Science and Advanced Technology, JAMSTEC · Center for Advanced Intelligence Project, RIKEN · Graduate School of Information Science and Technology, The University of Osaka.

Dynamical Systems Scientific ML Physics-Informed ML Port-Hamiltonian Systems Physics-Based Simulation

Open paper AskPDF arXiv

We present Mesh Field Theory (MeshFT) and its neural realization, MeshFT-Net: a structure-preserving framework for mesh-based continuum physics that cleanly separates the physics' topological structure from its metric structure. Imposing minimal physical principles (locality, permutation equivariance, orientation covariance, and energy balance/dissipation inequality), we prove a reduction theorem for mesh-based physics. Under these conditions, the physical dynamics admit a local factorization into a port-Hamiltonian form: the conservative interconnection is fixed uniquely by mesh topology, whereas metric effects enter only through constitutive relations and dissipation. This reduction clarifies what must be fixed and what should be learned, directly informing MeshFT-Net's design. Across evaluations on analytic and realistic datasets, physics-consistency tests, and out-of-distribution validation, MeshFT-Net achieves near-zero energy drift and strong physical fidelity (correct dispersion and momentum conservation) along with robust extrapolation and high data efficiency. By eliminating non-physical degrees of freedom and learning only metric-dependent structure, MeshFT provides a principled inductive bias for stable, faithful, and data-efficient learning-based physical simulation.

Abstract

GPU Acceleration

Explore similar work

Mesh Field Theory: Port-Hamiltonian Formulation of Mesh-Based Physics

Gen2Physics: Grounding Generated 3D Meshes in Physics via Multi-View Material Decomposition

Mesh-Native Tokenisation: Retrofitting Foundation Models to Unstructured Data