betaFeedback

WorksComputer Science

SimpFlow: Transferable Pretraining for Fluid Dynamics via Simplified Physics

Abstract

Neural surrogates enable rapid fluid simulation, but learning across diverse three-dimensional (3D) geometries requires costly computational fluid dynamics (CFD) labels. We introduce SimpFlow, a pretraining approach that generates supervision from simplified physics on unlabeled geometry libraries. A source-panel potential-flow solver generates velocity and pressure fields for approximately 9,000 3D geometries, capturing geometry-induced acceleration, stagnation, and suction while omitting viscosity and separated wakes. The solver imports only a surface mesh and reuses precomputed velocity fields across inflow directions, enabling inexpensive label generation. In our benchmark, amortized labeling takes 0.111 s per example using four CPU threads. We pretrain a neural surrogate on these labels and fine-tune it on independent CFD datasets. Across five flow tasks, SimpFlow improves over training from scratch in all 24 task-budget settings. With fine-tuning fixed at 200 epochs, interpolation indicates that SimpFlow requires 35-68% fewer CFD training cases to match the error of scratch models trained at each task's largest data budget. These results demonstrate that simplified physical solutions can provide transferable supervision, offering a practical way to reduce the high-fidelity data requirements of fluid surrogates.

Figure 1. DTCHull: downstream transfer. Relative L2 versus Epoch (100 cases) and Cases (epoch 200). Scratch, LGF, GeoPT, and SimpFlow. Greater transfer gains. ≥ 4 × epoch ratio. 68.3% fewer cases.

MethodHardwares/example
SimpFlow (4k)4 CPU threads0.111
GeoPT4 CPU threads0.309
LBM1 A100 GPU135.5*

Table 1. Labeling time per example. CPU: AMD EPYC 9684X. *LBM: reported solve time amortized over four query clouds (542/4). Lower labeling cost. 64.2% less labeling time in the benchmark than our GeoPT reproduction, with lower DTCHull error at every budget. Curves from Figure 3; savings and epoch ratios use the scratch reference accuracy (Section D.2). Cost accounting and LBM source: Table 1.

Introduction

Neural surrogate models provide an alternative for rapid fluid simulation [1] (Lu et al. 2021; Li et al. 2021; Li et al. 2023; Wu et al. 2024). After training, they can predict flow fields orders of magnitude faster than classical numerical solvers, making repeated evaluations practical for design iteration across 3D geometries. Learning these models, however, requires costly CFD labels that cover diverse shapes and operating conditions. For example, a typical high-fidelity simulation requires approximately 6.1×1046.1 \times10^{4} CPU core-hours [3]. Generating sufficient training data across a broad range of geometries therefore remains a substantial cost.

Pretraining learns reusable representations from source data and can reduce the high-fidelity data needed for adaptation to a target CFD task [5, 29]. Its practical value also depends on the cost of generating the source supervision. Unlabeled geometry libraries provide broad shape coverage, but using them for flow pretraining requires supervision that is both inexpensive to generate and informative for downstream prediction.

Existing approaches provide several sources of supervision. Pretraining on PDE solution corpora, as in MPP, DPOT, and Poseidon, reuses simulated trajectories across problems [19, 8, 9]; GP-UPT and cross-domain pretraining transfer representations learned from existing CFD datasets [5, 29]. Geometry-based approaches use unlabeled shapes through auxiliary targets, including occupancy reconstruction and the synthetic geometric dynamics of GeoPT [28] (Wu et al. 2026). Multi-fidelity learning combines high-fidelity data with cheaper solutions from simplified equations or coarser discretizations [20, 22, 23] (Lu et al. 2022). Within this direction, Wong & Khoo [25] demonstrate transfer from inviscid panel solutions to RANS predictions for a fixed NACA0012 airfoil, while concurrent work by Shen et al. [24] pretrains on lattice-Boltzmann simulations of independent 3D source geometries. These studies motivate examining how inexpensive physical solves can support pretraining across diverse 3D geometries.

We introduce SimpFlow, a pretraining approach that uses simplified physics to generate flow supervision from unlabeled geometry libraries. A source-panel potential-flow solver [10] provides velocity and pressure-coefficient (CpC_p) labels on approximately 9,000 ShapeNet geometries spanning cars, airplanes, and watercraft [6]. These solutions capture geometry-induced acceleration, stagnation, and suction while omitting viscosity and separated wakes. The solver requires only a surface mesh and reuses precomputed velocity fields across inflow directions, enabling inexpensive labeling across flow conditions. We pretrain Transolver (Wu et al., 2024) on these labels and fine-tune the resulting model on independent CFD datasets.

In our labeling benchmark, the 4k-panel solver takes an amortized 0.111 s per example using four CPU threads (§ 4.1). Across five flow tasks, SimpFlow improves over training from scratch in all 24 task–budget settings. With fine-tuning fixed at 200 epochs, interpolation indicates that it requires 35–68% fewer CFD training cases to match the error of scratch models trained at each task’s largest data budget. Under the shared training protocol, it also lowers test error relative to GeoPT in 21 of the 24 settings (Figure 3).

Figure 3. Figure 3. Test relative L2L_2 across five flow benchmarks, using seed 42 and 4k-panel pretraining for SimpFlow. Top: observed budget–epoch grids; facets connect measured values without fitting. Vertical axes are logarithmic and labeled with actual errors. Middle: epoch curves at each task’s largest budget (100/100/100/100/40 cases). Bottom: budget curves at epoch 200, including 10/20/30/40 cases for volume DrivAerML. Two-dimensional axes are linear. Values are case means from one seed, without uncertainty shading. Red annotations give interpolated case savings at epoch 200 and epoch ratios at the largest budget, relative to scratch’s final-budget, epoch-200 error (Section D.2). Epoch ratios exclude pretraining and labeling costs and do not measure wall-clock speedup. Targets are surface CpC_p for AirCraft, NASA-CRM, and DrivAerML, volume vv for DTCHull, and volume [Cp,v][C_p, v] for DrivAerML. Car-Crash is analyzed separately in § 4.4. Full grids and curves are in Section D.

To examine the role of supervision content, we compare potential-flow pretraining with a Local Geometry Field (LGF) control that assigns the same output quantities using local geometric rules. We also vary the panel count within the same potential-flow model to study how numerical resolution affects labeling cost and downstream transfer.

Our contributions are:

  • We introduce SimpFlow, a pretraining pipeline that labels diverse unlabeled 3D geometries with potential-flow velocity and pressure fields, using surface meshes and reusable inflow bases to reduce labeling work.

  • We evaluate a shared initialization on five flow tasks built independently of the source geometry library, demonstrating lower test errors than scratch and lower interpolated CFD sample requirements under a fixed fine-tuning budget.

  • We examine the roles of supervision content and numerical resolution through an LGF control and a panel-resolution study, characterizing their effects on transfer performance and labeling cost.

Related Work

Neural surrogates and physics-informed learning

Neural operators learn mappings from input functions to PDE solutions, amortizing numerical simulation across a problem family. DeepONet (Lu et al., 2021) combines input-function and query-coordinate representations, while FNO (Li et al., 2021) learns integral operators in Fourier space. Attention-based approaches extend operator learning to heterogeneous inputs and spatial discretizations: GNOT [7] handles multiple input functions and irregular meshes, and Transolver (Wu et al., 2024) aggregates points into learned physical states for efficient interaction. UPT [1] processes simulations in a compact latent space, while AB-UPT [2] scales surface and volume prediction using branched operators and anchored field decoders. We use Transolver to study how inexpensive physical supervision shapes the initialization for downstream flow prediction.

Physics-informed learning incorporates physical knowledge into model training, providing additional constraints beyond observed solution data [11]. Physics-informed neural networks (PINNs) approximate PDE solutions with neural networks and construct losses from governing-equation residuals, prescribed initial and boundary conditions, and available observations [21]. Automatic differentiation supplies the derivatives needed to evaluate PDE residuals at unlabeled collocation points. Physics-informed neural operator (PINO) extends this principle to operator learning by combining coarse-resolution solution data with PDE constraints evaluated at a finer resolution (Li et al., 2024). It learns solution operators across a family of PDE instances and demonstrates prediction at resolutions beyond those of the training data.

Geometry-based pretraining

Geometry-based pretraining provides source data without physical solution labels. GeoPT (Wu et al., 2026) lifts 3D geometries with synthetic dynamics and learns flow velocity and pressure fields, using surface meshes and reusable inflow bases to reduce labeling work.

  • We evaluate a shared initialization on five flow tasks built independently of the source geometry library, demonstrating lower test errors than scratch and lower interpolated CFD sample requirements under a fixed fine-tuning budget.

  • We examine the roles of supervision content and numerical resolution through an LGF control and a panel-resolution study, characterizing their effects on transfer performance and labeling cost.

geometry-bounded trajectories; its analysis also shows that static geometry-only supervision can cause negative transfer. Zhang et al. [28] reconstruct occupancy fields to pretrain a geometry encoder, then train neural operators using its latent representations. The encoder remains frozen during downstream learning, and the geometry distributions are matched or similar between stages. Their experiments are mainly two-dimensional, alongside a three-dimensional inductor case. These methods motivate using unlabeled geometry collections for pretraining. SimpFlow derives velocity and pressure targets from simplified physical solutions on a cross-category 3D geometry library.

Simulation-based pretraining and multi-fidelity transfer

Simulation-based pretraining learns reusable representations from collections of PDE solutions. MPP (McCabe et al., [19]) shares representations across heterogeneous physical systems, while DPOT (Hao et al., [8]) uses autoregressive denoising to stabilize learning from diverse trajectories. Poseidon (Herde et al., [9]) pretrains a multiscale operator on fluid trajectories and adapts it to downstream PDE tasks, including physical systems absent from pretraining. These models rely on simulated trajectories, predominantly represented on regular grids, to support transfer across physical problems.

For CFD, GP-UPT (Bleeker et al., [5]) demonstrates transfer from DrivAerNet RANS simulations to DrivAerML high-fidelity simulations, while cross-domain pretraining (Zhou et al., [29]) pools existing 3D CFD datasets across applications. These studies transfer physical information across geometries, operating conditions, and simulation fidelities using existing CFD corpora. SimpFlow constructs its source supervision from an unlabeled geometry library without requiring an existing CFD dataset.

Multi-fidelity learning combines high-fidelity data with cheaper solutions from simplified equations or coarser discretizations ([20] (Lu et al. 2022)). Setinek et al. [22, 23] study data allocation across fidelities, with aerodynamic experiments on two-dimensional airfoils; the latter focuses on discretization and iterative-solver errors. These works examine how simulation fidelity and data allocation affect prediction performance and the cost of obtaining supervision.

Panel-based transfer provides a direct precedent: Wong & Khoo [25] pretrain networks on inviscid solutions for a fixed NACA0012 airfoil and transfer to RANS pressure and skin-friction distributions, including unseen operating conditions. Our setting extends panel-based transfer to pretraining across an unlabeled, cross-category 3D geometry library and adaptation to independently constructed CFD benchmarks.

Concurrent work by Shen et al. [24] generates low-fidelity labels on independent 3D source geometries using lattice-Boltzmann simulations and demonstrates downstream transfer. Both approaches use independent source geometries for high-fidelity adaptation. SimpFlow uses a potential-flow solver that requires only surface meshes and reuses precomputed velocity fields across inflow directions to reduce labeling work. We compare label-generation costs in § 4.1.

Method

Overview

SimpFlow pretrains a neural surrogate on potential-flow labels from an unlabeled geometry library, then fine-tunes the shared initialization separately on each downstream task and data budget (Figure 1).

Given geometry G\mathcal{G}, conditions c\mathbf{c}, and query locations X={xi}i=1N\mathcal{X} = \{\mathbf{x}_i\}_{i=1}^{N}, we construct query features Z\mathcal{Z} and jointly predict their flow responses:

Y^=fθ(Z)∈RN×4,Z={zi}i=1N.(1)\widehat{\mathbf{Y}} = f_{\theta}(\mathcal{Z}) \in\mathbb{R}^{N \times4}, \qquad\mathcal{Z} = \{\mathbf{z}_i\}_{i=1}^{N}. \tag*{(1)}

Both pretraining and downstream flow prediction use dimensionless targets yi=[Cp(xi),v(xi)]\mathbf{y}_i = [C_p(\mathbf{x}_i), \mathbf{v}(\mathbf{x}_i)], with

Cp=p−p∞12ρU∞2,v=uU∞,(2)C_p = \frac{p-p_{\infty}}{\frac{1}{2}\rho U_{\infty}^{2}}, \qquad\mathbf{v} = \frac{\mathbf{u}}{U_{\infty}}, \tag*{(2)}

where p∞p_{\infty}, ρ\rho, and U∞U_{\infty} are the freestream pressure, density, and speed. CFD targets use these definitions, with supervision restricted to available components and queries.

For steady, inviscid, incompressible, irrotational flow, Bernoulli’s equation gives

p+12ρ∥u∥2=p∞+12ρU∞2.(3)p + \frac{1}{2}\rho\lVert\mathbf{u}\rVert^{2} = p_{\infty} + \frac{1}{2}\rho U_{\infty}^{2}. \tag*{(3)}

Substituting into Equation (2) gives

Cp=1−∥u∥2/U∞2=1−∥v∥2.(4)C_p = 1 - \lVert\mathbf{u}\rVert^{2}/U_{\infty}^{2} = 1 - \lVert\mathbf{v}\rVert^{2}. \tag*{(4)}

Labeling with Simplified Physics

Potential flow couples the geometry boundary and permits reuse across inflows. Its dimensionless velocity potential satisfies

Δϕ=0in ΩG,∇ϕ⋅n=0on ∂G,∇ϕ→aas ∥x∥→∞,(5)\Delta\phi= 0 \quad\text{in } \Omega_{\mathcal{G}}, \\ \nabla\phi\cdot\mathbf{n} = 0 \quad\text{on } \partial\mathcal{G}, \\ \nabla\phi\to\mathbf{a} \quad\text{as } \lVert\mathbf{x}\rVert\to\infty, \tag*{(5)}

where ΩG\Omega_{\mathcal{G}} is the exterior fluid domain, n\mathbf{n} the wall normal pointing into the fluid, and a=U∞/U∞\mathbf{a} = U_{\infty}/U_{\infty} the unit inflow direction. The simplified velocity is vL=∇ϕ\mathbf{v}_{\mathrm{L}} = \nabla\phi, with pressure from Equation (4). The model omits viscosity, separated wakes, turbulence, compressibility, and free-surface effects.

Figure 1 (PDF p. 4). SimpFlow pretraining and transfer. Potential-flow labels on 9,271 unlabeled ShapeNet geometries (8,971 training, 300 validation) provide a shared initialization for separate downstream fine-tuning runs. Labels use closed and simplified source meshes; colored flow fields illustrate the references in Figure 4. The schematic uses CpC_p for pressure coefficient, v\mathbf{v} for normalized velocity, and σVMmax⁡\sigma_{\mathrm{VM}}^{\max} for maximum-over-time von Mises stress; black and struck-through symbols mark supervised and excluded components. Volume DrivAerML supervises all four channels at volume queries, with surface points providing context. The separate Car-Crash test uses a new scalar stress head; its illustration is cropped from GeoPT (Wu et al., 2026) (CC BY 4.0).

A source-panel method (Hess & Smith, [10]; Katz & Plotkin, [12]) discretizes only the surface. One matrix factorization yields three velocity bases bG,k\mathbf{b}_{\mathcal{G},k} for Cartesian unit inflows ek\mathbf{e}_k, giving

vL(x;a)=∑k=13akbG,k(x).(6)\mathbf{v}_{L}(\mathbf{x};\mathbf{a}) = \sum_{k=1}^{3} a_k \mathbf{b}_{\mathcal{G},k}(\mathbf{x}). \tag*{(6)}

New query clouds require basis evaluation but no new source solve. At fixed queries, new inflows reuse these values; pressure is recomputed through Equation (4). Solver details and costs are in Sections A and A.3.

Source geometries are ShapeNet cars, airplanes, and watercraft (Chang et al., [6]), aligned in orientation and scaled to streamwise length five. We construct closed surfaces for sampling and geometric queries and simplify them to a target of 4,000 panels for the main solver. Each sample pairs a geometry and inflow with 4,096 surface and 8,192 volume queries, with volume points sampled both near the wall and farther out. Each geometry provides 40 samples: cars vary query clouds at fixed inflow, while airplanes and watercraft also vary inflow conditions (Section A.2).

Surface targets use the nearest panel’s fluid-side center velocity, while volume fields are evaluated at query locations. Validity masking and label clipping follow Section A.

Training and Transfer

The features in Equation (1) encode query position, geometry, and conditions:

zi=[xi,di,ηi,a,ac,i]∈R11.(7)\mathbf{z}_i = [\mathbf{x}_i,d_i,\boldsymbol{\eta}_i,\mathbf{a},a_{c,i}] \in\mathbb{R}^{11}. \tag*{(7)}

For volume queries, did_i is the distance to the nearest surface point and ηi\boldsymbol{\eta}_i is the unit vector pointing toward it. For surface queries, di=0d_i=0 and ηi\boldsymbol{\eta}_i is the outward unit normal. The conditions c\mathbf{c} are encoded by the shared inflow direction a\mathbf{a} and a scalar ac,ia_{c,i} representing a Mach code or fluid-region indicator. These encodings follow GeoPT (Wu et al., 2026) and are specified in Section B.2. The potential-flow teacher depends on geometry and inflow direction; the Mach code does not introduce compressible physics into its labels.

We use Transolver (Wu et al., 2024) to process Z\mathcal{Z} jointly. It aggregates queries into learned slice tokens, applies attention among the tokens, and broadcasts the result back to the queries. Its output head returns the four channels in Equation (1).

Both stages minimize masked mean squared error. For a batch B\mathcal{B}, let OB\mathcal{O}_{\mathcal{B}} contain its valid, observed sample–query— component indices. With Y^b=fθ(Zb)\hat{Y}_b=f_\theta(\mathcal{Z}_b), the loss is

LB(θ)=1∣OB∣∑(b,i,k)∈OB(Y^b,i,k−Yb,i,k)2.(8)\mathcal{L}_{B}(\theta)=\frac{1}{|\mathcal{O}_{B}|}\sum_{(b,i,k)\in\mathcal{O}_{B}}\left(\hat{Y}_{b,i,k}-Y_{b,i,k}\right)^2. \tag*{(8)}

Pretraining supervises all four components at valid queries using the postprocessed potential-flow targets. Fine-tuning includes only the quantities and query points observed by each task; points used solely as geometry context receive no loss (Section B).

Let θL\theta_L denote the pretrained weights. Each flow task starts from θL\theta_L and updates all parameters, including the four-channel output head. The separate Car-Crash test inherits the embedding and backbone and initializes a new scalar stress head.

Local Geometry Field Control

Local Geometry Field (LGF) constructs velocity from local geometry, using the same inputs, targets, and training schedule as SimpFlow (validity masks: Section A). For unit a\mathbf{a} and η\boldsymbol{\eta},

vs=a−ω(d)(a⋅η)η,(9)\mathbf{v}_s=\mathbf{a}-\omega(d)(\mathbf{a}\cdot\boldsymbol{\eta})\boldsymbol{\eta}, \tag*{(9)}
ω(d)=exp⁡[−(d/δ)2].\omega(d)=\exp\left[-(d/\delta)^2\right].

with δ=0.5\delta=0.5 in normalized geometry coordinates. LGF

preserves tangential inflow, damps normal inflow near the wall, and recovers the freestream far away (Figure 2). Its pressure coefficient follows from Equation (4):

Figure 2. LGF construction at an exterior query x\mathbf{x}. The inset shows the tangent plane at the nearest surface point, where the inflow splits into a kept tangential and a damped normal part: vs=at+(1−ω(d))an\mathbf{v}_s=\mathbf{a}_t+(1-\omega(d))\mathbf{a}_n with an=(a⋅η)η\mathbf{a}_n=(\mathbf{a}\cdot\boldsymbol{\eta})\boldsymbol{\eta}.

Cp,s=1−∥vs∥2=ω(2−ω)(a⋅η)2≥0.(10)C_{p,s}=1-\lVert\mathbf{v}_s\rVert^2=\omega(2-\omega)(\mathbf{a}\cdot\boldsymbol{\eta})^2\ge0. \tag*{(10)}

LGF therefore cannot produce suction; the derivation is in Section C.1.

Experiments

We evaluate labeling cost and transfer to five flow tasks, analyze the effects of supervision content and panel resolution, and finally examine transfer to solid mechanics.

Setup. We evaluate surface CpC_p on AirCraft ([18]), NASA-CRM ([4]), and DrivAerML ([3]), and normalized volume velocity v\mathbf{v} on DTCHull ((Wu et al., 2026)). DrivAerML volume predicts all four components [Cp,v][C_p,\mathbf{v}] at volume queries; surface context points receive no loss. Flow targets use the nondimensionalization in Equation (2). The original four tasks use 20/40/60/80/100 training cases; volume DrivAerML uses 10/20/30/40, defining 24 flow task–budget settings. Counts refer to complete CFD cases. Car-Crash provides a separate solid-mechanics test.

We compare Scratch, LGF, GeoPT ((Wu et al., 2026)), and SimpFlow, using an 8-layer Transolver and 200 fine-tuning epochs. Pretrained methods use 8,971 source geometries and 358,840 training examples; SimpFlow’s main initialization uses 4k-panel labels. All main runs use seed 42 for pretraining and fine-tuning, fixed task-specific splits, and shared backbone and optimization settings. GeoPT retains its input mapping and resets its output head; SimpFlow and LGF retain both for flow prediction. GeoPT is retrained at the shared data scale (Section B.4); its separate early reproduction and input-mapping control are in Section B.5. We report test relative L2L_2 averaged over cases, with final comparisons at epoch 200. These are single-seed results. Full protocols are in Section B.

Labeling Cost and Flow Transfer

Low-cost physical labels. With four logical CPUs of an AMD EPYC 9684X, SimpFlow takes 0.111 s per example, 64.2% less than our GeoPT reproduction (Table 1). The benchmark uses one geometry per category, four query clouds and ten conditions per cloud, totaling 120 examples. Timing covers labeling from existing meshes and queries, including validity checks, but excludes mesh preparation, query sampling, and I/O. Factorization and velocity-basis reuse amortize work across conditions; the actual car corpus varies clouds at fixed inflow (Section A.3).

MethodHardwares/example
SimpFlow (4k)EPYC 9684X, 4 threads0.111
GeoPTEPYC 9684X, 4 threads0.309
LBMNVIDIA A100, 1 GPU135.5*

Table 1 (PDF p. 5). Amortized labeling time per benchmark example. SimpFlow and our GeoPT reproduction use the same CPU allocation over 120 examples. LBM is estimated from the reported 542 s geometry–condition solve assuming four query clouds per solution; extraction is omitted. Accounting is in Section A.3.

*Reported solve time divided by four, rather than a new measurement: 542/4 = 135.5 s.

The concurrent LBM study reports 542 s per geometry–condition solve on an A100 ([24]). Sharing each solution across four clouds gives a solve-only estimate of 135.5 s per example, about 1,225 times SimpFlow’s measured mean. This hardware-specific comparison concerns labeling cost; transfer comparisons below use baselines reproduced under a shared training protocol.

Consistent flow transfer. At epoch 200, the shared SimpFlow initialization improves over scratch in all 24 settings and GeoPT in 21 (Figure 3). It beats GeoPT at every surface DrivAerML, DTCHull, and volume DrivAerML budget, extending the benefit from individual flow quantities to four-channel prediction. GeoPT performs better on AirCraft at 80 and 100 cases and NASA-CRM at 100 cases. Full errors are in Section D.1; showcases use model-selection checkpoints (Section D.5).

Fewer CFD cases and fine-tuning epochs. We use scratch’s largest-budget, epoch-200 error as the task-specific reference. At epoch 200, intersections with the budget curves give 35–68% fewer required CFD cases; at the largest budgets, epoch ratios range from 1.46 to at least 4.00 (Figure 3). DTCHull reaches the reference by the first measured checkpoint, epoch 50. These interpolated comparisons measure fine-tuning data and epochs, excluding pretraining and labeling costs. Per-task values and calculations are in Section D.2, with training histories in Section D.4.

Effect of Pretraining Supervision

LGF and SimpFlow share the geometry library, prediction targets, and training schedule, and both retain the output head (validity masks: Section A). Yet LGF causes negative transfer at every surface DrivAerML budget, while SimpFlow improves over scratch in all flow settings and reduces error relative to LGF by 20.7% on average.

Potential flow couples the entire boundary, allowing geometry-induced acceleration and deceleration. Through Equation (4), these produce suction and high-pressure regions. LGF only attenuates inflow, so ∥vs∥≤1\lVert\mathbf{v}_{s} \rVert\le1 and Cp,s≥0C_{p,s} \ge0 (derivation and sphere comparison: Section C.1). Despite similar-looking streamlines, it misses the roof suction shared by potential flow and CFD (Figure 4).

Figure 4. Reference fields for DrivAerML run_181 with 8,000-panel potential flow. The surface CpC_p color scale is clipped to [−1,1][-1, 1] and normalized streamline speed to [0,1.5][0, 1.5]. Potential flow and CFD share the stagnation high-pressure and roof low-pressure regions, whereas only CFD has a separated wake. Clipping hides amplitude differences, so the figure compares structure. Large annotated errors use identical full surface queries before display averaging or clipping. Dataset and per-sample errors, including exclusion-based diagnostics, are in Section C.3; further views are in Figure 9 and Figure 10.

Figure 9. Detailed reference-field comparison for the same car and inflow. Columns show potential flow, LGF, and high-fidelity CFD. Rows show an overview, roof/windshield details, and near-wake details with a speed slice. Surface CpC_p uses the shared range [−1, 1]; normalized speed uses [0, 1.5]. Cameras, seeds, and scales are matched. Surface rendering uses the full boundary reference, while streamline integration uses reconstructed steady or mean velocity fields. The potential solution retains selected large-scale flow features despite large pointwise discrepancies from CFD; visual similarity is not quantitative agreement.

Potential flow retains frontal stagnation pressure and roof suction but misses the separated wake. Its surface relative L2L_2 on this car is 1.61, versus 1.56 for LGF; these reference fields use 8k panels, while transfer uses 4k. Thus, useful flow structure can accompany large pointwise errors. Further fields and label errors are in Figure 8 and Figure 10 and Section C.3.

Figure 8. DTCHull dtchull_15, 8k double-body potential flow, LGF, and CFD at matched yaw −8.02∘-8.02^\circ and U∞=1.668U_\infty= 1.668. The inlet phase interface sets the waterline; the mid-draft slice is at y=−0.1293y = -0.1293. Rows show the full slice and bow detail. Colors are 100(∥u∥/U∞−1)100(\lVert\mathbf{u}\rVert/U_\infty- 1), clipped to [−15%,15%][-15\%, 15\%]; gray marks the hull. The 901×373901 \times373 display grid uses direct potential evaluation and native CFD interpolation. CFD colors are lightly smoothed for display with a Gaussian filter (σ=3\sigma= 3 grid points); error metrics use unsmoothed fields. Annotated vector errors use the original 31,696 common queries before clipping, separately from formal test-set metrics.

Figure 10. Aircraft surface references: AirCraft aircraft 22 ((a)–(f); Mach 7, angle of attack 7°, zero sideslip) and NASA-CRM train Sample001 ((g)–(l); Mach 0.7, zero angle of attack). Columns: 8,000-panel potential flow, LGF, and CFD; rows: upper/lower surfaces. The CpC_p color scale is clipped to [−0.35, 0.35] for all panels. Potential flow produces both high-pressure and negative-pressure suction regions, whereas LGF has Cp≥0C_p \ge0 and cannot represent suction. On NASA-CRM, potential flow captures the nose high pressure and wing suction seen in CFD; LGF retains nose high pressure but misses wing suction. Potential flow nevertheless differs from CFD in tail pressure. On AirCraft, potential flow distinguishes upper-surface suction from lower-surface compression, but predicts negative rear pressure where CFD shows positive pressure. It therefore retains part of the pressure organization without reproducing every region or its magnitude. Color clipping hides amplitude differences; the shared scale is used to compare spatial patterns. Annotated relative L2L_2 values show that pointwise errors remain large. For each sample, both labels use the same full set of surface queries without label-dependent exclusions; each column shows its whole-surface value once below the lower-surface row. Metrics precede face-to-vertex display averaging, with lighting disabled. LGF labels use d=0d = 0 and original face normals. Full per-dataset and per-sample errors are in Section C.3.

Resetting the main 4k output head still beats scratch in 24/24 settings and GeoPT in 21/24 (Section D.3), showing that transfer gains do not depend on head inheritance.

Effect of Panel Resolution

With the physical model fixed, we next ask whether finer boundary resolution continually improves transfer. We vary the target panel count from 500 to 8k, holding geometry identities, inflows, query clouds, initialization, and optimization schedules fixed. Each model is fine-tuned on 20 CFD cases per benchmark and evaluated at epoch 200. The dedicated 8k run shares the 2k/4k validity mask (Section F).

Very coarse resolution weakens transfer: reducing the panel count from 1k to 500 lowers the gain over scratch by 5.6–10.3 percentage points across the four tasks, although both improve over scratch (Figure 5). From 2k to 8k, finer resolution gives no consistent monotonic improvement. The lowest errors occur at 4k on three tasks and 8k on DTCHull (Table 19), indicating that moderate resolution already supplies useful supervision.

Figure 5. Downstream test-error reduction relative to scratch versus target panel count. Each curve represents one benchmark; points use 20 CFD training cases, seed 42, and epoch 200. Higher is better; the dashed line denotes no gain. Numerical results are listed in Table 19.

Benchmark5001k2k4k8k
AirCraft0.2160120.1928340.1917280.1837960.187804
NASA-CRM0.2861180.2538630.2214800.2212670.236149
DrivAerML0.2772650.2543970.2177760.2127990.219389
DTCHull0.0626100.0586580.0568370.0571380.056514

Table 19. Panel-resolution ablation.

The broader comparison uses 22 shared task–budget settings, including volume DrivAerML at 20/40 cases; its 10/30-case runs are available only for 4k. Wins over GeoPT increase

from 15/22 at 2k to 19/22 at 4k and remain 19/22 at 8k (Table 2). This comparison uses the original 8k initialization and mask, distinct from the dedicated resolution study. Meanwhile, labeling costs rise from 0.055 to 0.111 and 0.322 s per example. These results motivate 4k as the main configuration: it balances transfer performance and labeling cost.

Task2k4k8k
AirCraft3/53/54/5
NASA-CRM3/54/53/5
DrivAerML (surface)2/55/55/5
DTCHull5/55/55/5
DrivAerML (volume)2/22/22/2
Total15/2219/2219/22

Table 2. Settings with lower epoch-200 test error than GeoPT. Counts use the same 22 settings across five flow tasks: five budgets for each original task and 20/40 cases for volume DrivAerML. The 8k column uses the original initialization and validity mask; the 20-case curves use dedicated resolution-study runs.

Transfer to Solid Mechanics

We finally test whether a flow-pretrained representation can help predict structural response. Car-Crash takes an undeformed car geometry as input and predicts maximum-over-time von Mises stress. All pretrained methods replace the output layer with a scalar stress head and use 20, 40, 60, or 80 training cases, following the same 200-epoch schedule and seed 42.

At 20 training cases, SimpFlow reduces test error by 13.2% relative to scratch and also outperforms GeoPT (Figure 6). At 40 and 60 cases its error is 21.7% and 7.7% above scratch, respectively, while at 80 cases it is 0.7% below scratch. Averaged across the evaluated budgets, error reduction is 15.5–29.8% on the five flow tasks but −3.9% on Car-Crash (Figure 6c). Transfer is thus stronger and more consistent for flow prediction than for structural response. This difference is consistent with the physical content of pretraining supervision: potential flow links geometry to flow response, whereas crash-induced stress also depends on distinct mechanisms such as material behavior, contact, and structural deformation. The pressure and stress examples in Figure 20 illustrate the change in physical response; complete results are in Section E.

Figure 6. Transfer with the same 4k initialization. Car-Crash test relative L2L_2 versus (a) epoch at 80 cases and (b) budget at epoch 200. (c) Mean relative error reduction against scratch across all evaluated budgets of each benchmark at epoch 200, computed as 100(1−ESimpFlow/EScratch)100(1 - E_{\mathrm{SimpFlow}}/E_{\mathrm{Scratch}}) per budget and then averaged equally. All six axes use the same [−10,40]%[-10, 40]\% scale; the dashed hexagon marks zero gain. Full results are in Sections D.1 and E.

Figure 20. Car-Crash test_sim_000, impact angle 3.38°, shown on the initial geometry. Left: illustrative 4k-panel potential-flow CpC_p on a closed outer envelope constructed from geometry alone, with direction taken from the downstream condition encoding. Right: maximum-over-time von Mises stress on the original finite-element structure. Rows show an overview and front detail. Independent color limits are [−1, 1] for CpC_p and [0, 247.05] in source-file units for stress, whose upper limit is the 99th percentile of original surface-cell values. For display, panel CpC_p is averaged at vertices and interpolated within triangles onto the unchanged envelope. The envelope omits internal components. These are different physical quantities; no cross-quantity error is defined.

Conclusion

SimpFlow turns unlabeled 3D geometry libraries into physical supervision for transferable flow representations, without existing CFD data or paired downstream solutions. Boundary-only potential-flow solves and reusable inflow bases enable inexpensive labeling. The resulting initialization transfers to independent CFD benchmarks, improving over scratch in all 24 tested settings and reducing interpolated CFD sample requirements by 35–68% at a fixed fine-tuning budget.

The results show that simplified solutions can provide useful supervision despite large pointwise errors. Potential flow retains geometry-induced acceleration, stagnation, and suction that the local attenuation rule of LGF cannot fully express. Moderate panel resolution provides a favorable cost–transfer balance, while further refinement yields no consistent monotonic improvement. SimpFlow thus offers a practical route to labeling extensive geometry libraries for pretraining and reducing the high-fidelity data demands of CFD surrogates.

Pre-Training Sample Generation

Potential-Flow Solver

Let a closed surface have PP triangular panels with constant source strengths σj\sigma_j. Using an outward source-velocity kernel, we write

Kj(x)=14π∫Γjx−y∥x−y∥3 dSy,v(x)=a+∑jσjKj(x).(11)\mathbf{K}_j(\mathbf{x}) = \frac{1}{4\pi}\int_{\Gamma_j}\frac{\mathbf{x}-\mathbf{y}}{\lVert\mathbf{x}-\mathbf{y}\rVert^3}\,dS_{\mathbf{y}},\qquad\mathbf{v}(\mathbf{x}) = \mathbf{a}+\sum_j\sigma_j\mathbf{K}_j(\mathbf{x}). \tag*{(11)}

Collocating the exterior no-penetration condition at panel centers gives

Aσ=−Na,Aij=ni⋅Kj+(ci),(12)A\sigma=-N\mathbf{a},\qquad A_{ij}=\mathbf{n}_i\cdot\mathbf{K}_j^+(\mathbf{c}_i), \tag*{(12)}

where row ii of NN is niT\mathbf{n}_i^{\mathsf{T}}. The exterior source-layer jump contributes +12σini+\frac{1}{2}\sigma_i\mathbf{n}_i, giving diagonal entries 1/21/2 in the normal system. Surface velocity evaluation also retains the in-plane self-interaction of irregular triangles. This source-only model includes neither wake circulation nor a Kutta condition. Three inflow bases share the same factorization:

AΣ=−N,B(x)=I3+K(x)Σ,v(x;a)=B(x)a.(13)A\Sigma=-N,\qquad B(\mathbf{x})=I_3+K(\mathbf{x})\Sigma,\qquad\mathbf{v}(\mathbf{x};\mathbf{a})=B(\mathbf{x})\mathbf{a}. \tag*{(13)}

Pressure is computed after combining velocities; pressure fields do not combine linearly. New query clouds require new field evaluations, while the geometry-dependent matrix factorization remains reusable.

For panel jj of area SjS_j, we use centroid quadrature when the query-to-centroid distance is at least 3Sj3\sqrt{S_j}. Closer interactions use the centroids of 64 equal-area subtriangles obtained by three subdivision steps; self-interactions use the terms above. Source strengths are solved in double precision. Volume velocities are evaluated at the query coordinates. For each surface query, a closest-surface search identifies the nearest triangle, and its fluid-side panel-center velocity is assigned to that query. All four target components at volume queries inside the panel mesh are marked invalid and excluded from training; the retained LGF control uses the original 8k mask, while the main 4k model uses the shared resolution-study mask (Section B.3).

To limit extreme label values, we clip pressure coefficients and cap velocity magnitudes:

v~=vmin⁡(1,3∥v∥),C~p=clip⁡(1−∥v∥2,−2,2).(14)\widetilde{\mathbf{v}}=\mathbf{v}\min\left(1,\frac{\sqrt{3}}{\lVert\mathbf{v}\rVert}\right),\qquad\widetilde{C}_p=\operatorname{clip}\left(1-\lVert\mathbf{v}\rVert^2,-2,2\right). \tag*{(14)}

For these potential-flow targets, the paired operation preserves C~p=1−∥v~∥2\widetilde{C}_p=1-\lVert\widetilde{\mathbf{v}}\rVert^2 up to rounding. Spatially varying rescaling need not preserve the continuous divergence or curl constraints.

Sample Construction

ShapeNet geometries are centered, oriented by category to match the downstream coordinate conventions, and scaled to longitudinal length five. Preprocessing produces a closed surface for sampling and geometric queries, and a simplified mesh for the source-panel solve. The main experiments target 4,000 panels using quadric edge-collapse decimation with topology and normal preservation. The actual retained count is recorded; meshes with fewer faces or incomplete decimation are used without forcing the target count.

A sample consists of one geometry, one inflow condition, and one query cloud. Table 3 and Table 4 specify the point sets and category-dependent sampling. Interior volume candidates are rejected. Potential-flow labels that become invalid under the simplified panel geometry are masked as described above.

Point setCountSampling rule
Surface4,096Sample triangle locations in proportion to surface area.
Near-wall volume4,096Offset surface samples along outward normals, with log-uniform distance in [0.02,0.5][0.02, 0.5]; retain exterior points.
Exterior volume4,096Sample uniformly within the bounding box padded by one unit; retain exterior points.
Total12,288One fixed cloud shared by the conditions assigned to it.

Table 3. Query points per pre-training sample. Distances use normalized geometry coordinates.

CategoryCloudsConditions/cloudSamplesInflow and condition range
Car40140Fixed +xx inflow.
Airplane41040NASA-like: angle of attack [−2.5∘-2.5^\circ, 5∘5^\circ], Mach code [0.5, 0.9]. AirCraft-like: Mach code [2, 7], nonzero angle of attack [0∘0^\circ, 7∘7^\circ] and sideslip [0∘0^\circ, 2∘2^\circ]; also includes fixed-Mach and zero-angle cases.
Watercraft41040Yaw sampled uniformly from [−10∘-10^\circ, 10∘10^\circ].

Table 4. Category-dependent samples per training geometry. Airplane condition groups share the same four-cloud, ten-condition sampling scheme.

The corpus contains 8,971 training geometries with 40 samples each, giving 358,840 training examples. The held-out set contains 100 geometries per category and two validation examples per geometry. Given our computational budget, we reproduce GeoPT’s pre-training method on this shared corpus and training schedule rather than replicate the full data scale and experimental scope of the original study (Section B.3). Cars vary the query cloud rather than the inflow; airplanes and watercraft reuse each cloud across conditions. Mach codes do not introduce compressible physics into the potential-flow labels. Input encodings and losses are specified in Section B.2.

Labeling Cost

The timing unit is one geometry–condition–query-cloud example. We measure four clouds with ten conditions each on one car, airplane, and watercraft, for 120 examples. Reported per-example times are amortized over this benchmark layout. Neural training is excluded.

Work and reuse. With PP panels, dense assembly costs O(P2)O(P^2) and factorization costs O(P3)O(P^3). Three inflow bases share the factorization. Surface and volume basis evaluations cost O(P2)O(P^2) and O(QvP)O(Q_vP), respectively; each additional condition costs O(Qv+Qs)O(Q_v + Q_s) to combine velocities and form CpC_p. GeoPT reuses geometry acceleration structures and initial VDFs, but each motion requires collision checks and updated distance queries. LBM advances NN lattice cells for TT steps, with work proportional to NTNT; a solved field can serve additional query clouds.

Matched CPU measurements. We measure labeling from prepared meshes and query clouds on one geometry per category (Table 5). SimpFlow and our GeoPT reproduction use the same query clouds, each with 8,192 volume and 4,096 surface points, and the same four logical CPUs of an AMD EPYC 9684X. For each geometry, the elapsed time covers generation of all 40 examples, including method-specific initialization and reuse across examples.

CategoryShapeNet IDSimpFlowGeoPTLBM
Car7e7f0637d6798113ddb4014f0e8d0dac5.19521.655—
Airplane870dc1667e957672c66e7238ddb322f44.0326.831—
Watercraft8411cba605709e46c26de8baaf779d694.0508.571—
Total for 120 examples (s)13.27737.057—
Amortized time (s/example)0.1110.309135.5∗135.5^*
Hardware4 CPU threads4 CPU threads1 A100

Table 5. Labeling costs and hardware. SimpFlow (4k) and our GeoPT reproduction use four logical CPUs of an AMD EPYC 9684X; category rows report seconds per 40-example batch. LBM is a literature-based estimate on one A100, reported only as amortized time per example.

The timing benchmark uses four clouds and ten conditions or motions per cloud for both methods. SimpFlow uses its training condition samplers for airplanes and watercraft, and varying yaw for the car timing test. This common timing layout differs from the car training corpus, which uses 40 clouds at fixed inflow.

Amortization. For method mm and geometry gg, let Tm,gT_{m,g} be the measured 40-example labeling time. The amortized time per example is

tˉm=∑g=13Tm,g3×4×10.(15)\bar{t}_m = \frac{\sum_{g=1}^{3} T_{m,g}}{3 \times4 \times10}. \tag*{(15)}

SimpFlow totals 13.277 s, or 0.111 s per example; GeoPT totals 37.057 s, or 0.309 s. The ratio of unrounded means is 2.79. Per-geometry times for SimpFlow are 0.130, 0.101, and 0.101 s, compared with 0.541, 0.171, and 0.214 s for GeoPT. Under the same protocol, 2k and 8k cost 0.055 and 0.322 s per example. Phase totals in Table 6 show that source solving and surface bases dominate the optimized 4k pipeline.

MethodPhaseTotal time (s)
SimpFlowGeometry solves and panel-surface velocity bases10.279
Volume-field evaluation for 12 query clouds2.876
Condition generation and 120 label combinations0.121
GeoPTGeometry acceleration structures0.114
Initial distance fields for 12 query clouds0.324
Motion-label generation for 120 examples36.619

Table 6. Label-generation time by stage, summed over the three geometries. Each method’s total is divided by 120 to obtain the per-example time in Table 1.

LBM estimate. Shen et al. [24] report 542 s on one A100 for a 300 ×\times 120 ×\times 90 lattice and 16,000 steps, producing surface pressure and wall shear. For KK conditions distributed over 40 sampled examples, solve-only amortization is 542K/40542K/40 s plus label extraction. Table 1 assumes four clouds share each solution, giving 542×10/40=135.5542 \times10/40 = 135.5 s per example, with extraction omitted. Under this reuse assumption, the estimate is about 1,225 times SimpFlow’s measured 4k mean on the stated GPU/CPU hardware. The comparison concerns labeling time for different source models and output fields; it does not establish a transfer-accuracy-matched speedup. SimpFlow’s basis reuse also avoids a new flow solve when the inflow direction changes.

Experimental Setup

Data Splits and Evaluation

BenchmarkPrediction targetTrain budgetsValidationTest
AirCraftSurface CpC_p20–1002525
NASA-CRMSurface CpC_p20–100544
DrivAerML surfaceSurface CpC_p20–1002525
DTCHullVolume vv20–100910
DrivAerML volumeVolume [Cp,v][C_p, v]10, 20, 30, 4007
Separate structural-response test
Car-CrashSurface σVMmax⁡\sigma_{\mathrm{VM}}^{\max}20, 40, 60, 801734

Table 7. Five flow tasks and a separate structural-response test, with nested training budgets and fixed test sets. Counts refer to complete simulation cases, not query points.

AirCraft uses 30 geometries in ten families of three, with five conditions per geometry. Two geometries per family enter training; the remaining geometries are split across validation and test. Training budgets balance geometry families and conditions. NASA-CRM retains its official 44-case test set; five of the 105 available training cases form validation, and the remaining 100 are ordered by farthest-point sampling in standardized Mach–angle-of-attack space. DrivAerML and DTCHull use fixed random geometry-disjoint splits. Every compared method uses the same split and nested budgets. The maximum budget is the selected training pool, not necessarily the full source dataset.

Downstream preprocessing. Each of the original four CFD tasks contains one stored set of 4,096 points (Table 8). Points are sampled uniformly without replacement from the native vertices or cells, rather than by surface area. AirCraft reuses the same vertex indices across the five conditions of a geometry. DTCHull volume candidates lie in the model-coordinate box [−4,5]×[−1,1]×[−1.5,1.5][-4,5] \times[-1,1] \times[-1.5,1.5]; its 512 surface points provide geometry context but receive no downstream loss. All methods load the same arrays throughout training and evaluation, with no online point resampling or coordinate augmentation.

BenchmarkPoint setPrediction target
AirCraft4,096 native surface verticesDataset-provided CpC_p
NASA-CRM4,096 native surface verticesDataset-provided CpC_p
DrivAerML4,096 native surface-cell centersSurface pressure coefficient CpC_p
DTCHull3,584 native volume points and 512 surface verticesNormalized volume velocity v\mathbf{v}

Table 8. Fixed downstream point sets and dimensionless flow prediction targets.

Geometry coordinates are centered at the bounding-box midpoint and scaled isotropically to streamwise length five; CFD queries use the same transform. NASA-CRM uses the axis ordering (x,z,y)(x,z,y), and DTCHull uses (−x,z,y)(-x,z,y), with the latter also applied to velocity components. The distance and direction channels are computed in these model coordinates, and the inflow encodings are given in Section B.2. Only the targets listed in Table 8 enter the loss and test metric; other output components are masked in these four tasks.

Native pressure pp and velocity u\mathbf{u} are nondimensionalized using Equation (2): pressure becomes Cp=(p−p∞)/(12ρU∞2)C_p = (p-p_{\infty})/(\frac{1}{2}\rho U_{\infty}^{2}) and velocity becomes v=u/U∞\mathbf{v} = \mathbf{u}/U_{\infty}, with case-specific freestream reference values. Dataset-provided pressure coefficients are used directly. The task tables list these dimensionless flow targets. Pretraining and flow fine-tuning therefore use the same output quantities, with task-specific observation masks.

Additional tasks. DrivAerML volume uses a frozen 47-case pool: 40 training cases and seven test cases, without a validation set. Budgets 10, 20, 30, and 40 use nested prefixes of the frozen training list. Each case contains 8,192 volume queries and 4,096 surface context points, with no extra wake-focused sampling. Only volume points enter the loss, and all four quantities [Cp,v][C_p,\mathbf{v}] are supervised without component masking. Its reported joint relative L2L_2 uses this dimensionless four-channel vector; surface context points receive no loss. Model selection uses training-set four-channel MSE.

Car-Crash uses the undeformed surface geometry, 4,096 surface queries, and scalar maximum-over-time von Mises stress. Its original 80/17/34 train/validation/test partition is fixed, and training budgets are the first 20/40/60/80 entries of the frozen training list. Model selection uses validation relative L2L_2. The existing 11-channel inputs are retained for both added tasks. Neither additional task uses test data for fitting or model selection.

For one test case and its valid observed components O\mathcal{O}, the reported error is

e=(∑(i,k)∈O(y^i,k−yi,k)2)1/2(∑(i,k)∈Oyi,k2)1/2.(16)e = \frac{\left(\sum_{(i,k)\in\mathcal{O}}(\hat{y}_{i,k}-y_{i,k})^2\right)^{1/2}}{\left(\sum_{(i,k)\in\mathcal{O}}y_{i,k}^2\right)^{1/2}}. \tag*{(16)}

We average ee over complete test cases. Every main comparison uses fine-tuning seed 42 and, when applicable, pre-training seed 42. We report no across-seed standard deviation or significance test. Main tables use fixed epoch 200; model-selection checkpoints are not substituted.

Prediction Interface

For a volume query, let ri\mathbf{r}_i point from xi\mathbf{x}_i to its nearest surface point. We use di=∥ri∥d_i = \lVert\mathbf{r}_i \rVert and ni=ri/di\mathbf{n}_i = \mathbf{r}_i/d_i. At surface points, di=0d_i=0 and ni\mathbf{n}_i is the face normal. The volume convention is not an outward-normal field. Reversing ni\mathbf{n}_i leaves the local geometry projection (a⋅ni)ni(\mathbf{a}\cdot\mathbf{n}_i)\mathbf{n}_i unchanged, but the direction supplied to the network follows the stated convention.

The condition channels follow the car and aerodynamics encodings in GeoPT’s implementation (Wu et al., 2026). With angle of attack α\alpha, sideslip β\beta, yaw ψ\psi, and Mach code MM, the direction and scalar encodings are listed in Table 9.

TaskUnit direction a\mathbf{a}Scalar aca_c
Car(1,0,0)(1,0,0)0.30.3
NASA-CRM(cos⁡α,sin⁡α,0)(\cos\alpha,\sin\alpha,0)1.6M1.6M
AirCraft(cos⁡αcos⁡β,sin⁡α,cos⁡αsin⁡β)(\cos\alpha\cos\beta,\sin\alpha,\cos\alpha\sin\beta)M/3M/3
Watercraft pre-training(cos⁡ψ,0,sin⁡ψ)(\cos\psi,0,\sin\psi)0.3 at all queries
Hull fine-tuning(cos⁡ψ,0,sin⁡ψ)(\cos\psi,0,\sin\psi)0.3 in water, 0 in air

Table 9. Condition channels. Directions use the corresponding benchmark coordinate frame; angles in these expressions are in radians.

Inflow direction is broadcast across queries. The scalar is also global in car and aircraft tasks, but hull fine-tuning uses the water/air region encoding supplied with the preprocessed data. Upstream watercraft do not use this air-side gate. Thus, the attribution concerns the encoding conventions and empirical direction/scale guidance, not an identical pre-training strategy. The potential teacher uses unit inflow and does not model Mach- or Reynolds-dependent effects.

Both stages use the masked MSE in Equation (8), with OB\mathcal{O}_{\mathcal{B}} containing valid sample–query–component indices in batch B\mathcal{B}. Invalid low-fidelity labels and missing downstream observations are excluded componentwise; geometry-context points without target observations receive no loss. The query set is Zb={zi}\mathcal{Z}_b = \{z_i\}. Flow fine-tuning inherits and updates all parameters, while Car-Crash inherits the embedding and backbone and initializes a new scalar output head.

Training Configuration

All methods share the backbone and optimization settings in Table 10. The same 4k initialization is reused across all downstream tasks and budgets.

SettingPre-trainingFine-tuning
BackboneTransolver: 8 layers, width 256, 8 heads
Slice tokens32 per head
Epochs8200
Optimizer updates358,840Budget-dependent
Batch size81
OptimizerAdamWAdamW
Learning rate3×10−43 \times10^{-4}Peak 10−310^{-3}
ScheduleWarmup + cosineOneCycle
Weight decay10−510^{-5}10−510^{-5}
LossMSEMSE
GPUNVIDIA RTX 6000 Ada (48 GB)
GPUs per run11
Approx. GPU-hours (SimpFlow, 4k)≈25\approx250.026–0.135

Table 10. Shared model and training configuration. All main comparisons use seed 42. Each pre-training epoch traverses all 40 samples per geometry.

Runtime entries refer to the 4k model. Pre-training time combines the logged training segments, including resumed work but excluding server downtime. Fine-tuning time is the range per 200-epoch run across all six benchmarks and their budgets (seed 42), including evaluation and checkpointing. Each run uses one GPU; independent runs may execute concurrently. Label-generation costs are reported separately in Section A.3.

GeoPT Main Baseline

Resource constraints require a smaller pre-training corpus and fewer query points than in the original GeoPT study (Wu et al., 2026). We retrain GeoPT under the same data scale as LGF and SimpFlow (Table 11); all main downstream comparisons, including scratch, share the same splits, query points, backbone, and optimization settings.

SettingGeoPT (retrained)LGF / SimpFlow
Pre-training geometries8,9718,971
Stored training samples358,840358,840
Pre-training volume / surface points8,192 / 4,0968,192 / 4,096
Layers / width8 / 2568 / 256
Downstream points4,096; 12,288 for DrivAerML volume

Table 11. Actual configurations used in our main experiments. Shared optimization settings are listed in Table 10.

GeoPT outperforms scratch in all 24 main task–budget settings at epoch 200 (Table 15). The configuration above applies to the main comparisons with LGF and SimpFlow. The earlier reproduction and input-head control use the separate protocol below.

BenchmarkCasesScratchLGFGeoPTSimpFlow
AirCraft200.22540.21740.20630.1838
AirCraft400.21280.18550.16850.1655
AirCraft600.24090.16110.15710.1541
AirCraft800.22000.16330.14890.1492
AirCraft1000.15870.15010.13350.1468
NASA-CRM200.39190.31110.27830.2213
NASA-CRM400.26170.21180.16970.1592
NASA-CRM600.18810.17690.16220.1288
NASA-CRM800.14220.14810.11690.1160
NASA-CRM1000.12580.12950.10420.1054
DrivAerML (surface)200.28630.30240.22140.2128
DrivAerML (surface)400.21840.24910.18070.1703
DrivAerML (surface)600.18790.22120.15740.1513
DrivAerML (surface)800.17090.20360.14170.1393
DrivAerML (surface)1000.15910.18420.13000.1275
DTCHull200.07070.07070.06320.0571
DTCHull400.06010.06190.05680.0517
DTCHull600.05770.06050.05270.0494
DTCHull800.05550.05580.04850.0468
DTCHull1000.05390.05280.04760.0462
DrivAerML (volume)100.11740.11800.09260.0861
DrivAerML (volume)200.09630.09980.07790.0743
DrivAerML (volume)300.07760.08060.06620.0624
DrivAerML (volume)400.07070.07390.06200.0590

Table 15. Test relative L2L_2 at epoch 200, using pre-training and fine-tuning seed 42. Values are means over test cases, not over seeds. SimpFlow uses 4k panels. Bold marks the lowest error in each row.

GeoPT Reproduction

An independent early study uses an 8-layer, 128-channel model, 448 unlabeled downstream geometries, 50 pre-training epochs, and 100 fine-tuning epochs (seed 42), separately from the main protocol. It recovers GeoPT’s core qualitative findings: geometry-only pre-training can cause negative transfer (11/20 settings), whereas GeoPT improves over scratch in 19/20 (Figure 7). Keeping the same pre-trained backbone but resetting the input mapping raises test error in all 20 settings and produces negative transfer in 10/20. Both GeoPT variants reset the output head; only input-mapping inheritance differs. This shows the importance of transferring the learned input mapping together with the backbone, as we do in the main GeoPT baseline. The reduced experimental scale reflects resource constraints.

Figure 7. Early GeoPT reproduction and input-head control under one matched protocol. Top: test relative L2L_2 across budgets and epochs (logarithmic height). Middle: epoch curves at 100 cases. Bottom: budget curves at epoch 100. Pre-training uses 4,096 volume and 512 surface points; fine-tuning uses 4,096 points. Original joint targets have 6/1/1/4 channels for AirCraft/NASA-CRM/DrivAerML/DTCHull. The reset variant retains GeoPT’s backbone and reinitializes its input mapping. All reported counts use epoch-100 test errors.

Flow Structure and Label Accuracy

We first analyze how potential flow and LGF differ in velocity and pressure structure, then compare fields on actual geometries and quantify their label errors against CFD (§ 4.2).

Velocity and Pressure Structure

The LGF baseline uses δ=0.5\delta= 0.5 in normalized coordinates. At smooth locations with a unique nearest point, let dd be the exterior distance and nd=∇d\mathbf{n}_d = \nabla d with unit norm. The volume-point convention gives η=−nd\eta= -\mathbf{n}_d, which leaves the projection unchanged. At d=0d = 0, ω=1\omega= 1 and the ideal LGF has zero normal velocity. Wall impermeability alone therefore does not distinguish this baseline from potential flow. Writing t=a⋅ndt = \mathbf{a} \cdot\mathbf{n}_d gives

∥vs∥2=1−2ωt2+ω2t2,Cp,s=ω(2−ω)t2∈[0,1].(17)\lVert\mathbf{v}_s \rVert^2 = 1 - 2\omega t^2 + \omega^2 t^2,\qquad C_{p,s} = \omega(2-\omega)t^2 \in[0,1]. \tag*{(17)}

This baseline attenuates the inflow but cannot accelerate it above unit magnitude. Its targets do not activate the pressure or speed clipping limits. Let HdH_d denote the distance Hessian. Using Hd∇d=0H_d \nabla d = 0, differentiation yields

∇⋅vs=−[ω′(d)+ω(d)Δd](a⋅∇d),(18)\nabla\cdot\mathbf{v}_s = -[\omega'(d) + \omega(d)\Delta d](\mathbf{a}\cdot\nabla d), \tag*{(18)}
∇×vs=−ω(d)(Hda)×∇d.(19)\nabla\times\mathbf{v}_s = -\omega(d)(H_d\mathbf{a})\times\nabla d. \tag*{(19)}

These quantities are generally nonzero. These derivatives apply where the distance is differentiable. On a sphere, ideal potential flow gives surface Cp,L=1−94sin⁡2ϑC_{p,L} = 1 - \frac{9}{4}\sin^2\vartheta, whereas this local geometry rule gives Cp,s=cos⁡2ϑC_{p,s} = \cos^2\vartheta. At the equator they equal −1.25-1.25 and 00, respectively, illustrating global flow acceleration versus local attenuation.

Reference Fields

All potential-flow illustrations use their original 8k solutions. Shared color limits reveal stagnation, suction, and acceleration patterns; the annotated errors are computed before display averaging and color clipping. Car and aircraft annotations use the same full surface query set for both labels. Detailed metric definitions and diagnostic exclusions are in Section C.3.

On DTCHull, potential flow and CFD both distinguish bow deceleration from shoulder acceleration, whereas LGF only reduces the inflow speed and misses the accelerated regions (Figure 8). This spatial redistribution supplies a useful flow prior for hull transfer. However, potential flow imposes impermeability with tangential slip: it does not reproduce the viscous near-wall low-speed layer or the extended downstream velocity deficit visible in CFD. The double-body approximation also omits free-surface dynamics.

Reference-Label Accuracy

Figure metrics use the exact dense face-centroid queries before display averaging and clipping. Potential labels retain their original [−2,2][-2, 2] bound; CFD is unmodified. Relative L2L_2 and MAE use all finite points. Figure annotations use this full set; the diagnostic “excluded” column removes points with the evaluated label’s Cp≤−2C_p \le-2 and can therefore use different subsets across labels.

DatasetLabelL2L_2 allL2L_2 excludedRemovedRemoved (%)MAE
DrivAerMLLGF1.56231.562300.0000.5743
DrivAerMLPotential flow (2k panels)1.70371.7851354464.7060.6265
DrivAerMLPotential flow (4k panels)1.66281.8266516586.8580.6186
DrivAerMLPotential flow (8k panels)1.61141.7961346444.5990.6063
AirCraftLGF1.24951.249500.0000.0618
AirCraftPotential flow (2k panels)3.09612.5703118711.7880.1951
AirCraftPotential flow (4k panels)3.08612.5206126481.9050.2012
AirCraftPotential flow (8k panels)3.02992.5524108711.6370.2010
NASA-CRMLGF1.24121.241200.0000.2651
NASA-CRMPotential flow (2k panels)1.29621.212539080.4300.2509
NASA-CRMPotential flow (4k panels)1.44771.1985171491.8870.2845
NASA-CRMPotential flow (8k panels)1.54001.422369480.7650.3087

Table 12. Surface CpC_p errors for the exact fidelity-figure samples. AirCraft is 22_7.0_7.0_0.0 (663,938 points), NASA-CRM is train Sample001 (908,804), and DrivAerML is run 181 (753,246). “Excluded” removes label Cp≤−2C_p \le-2; MAE uses all points. The figures display LGF and 8k potential labels; 2k/4k rows use other existing labels for the same queries.

The car’s volume errors use velocity vectors at native CFD source nodes before streamline interpolation. The 2k/4k rows retain their saved exterior-valid masks, hence their different point counts. Aircraft figures show pressure only.

LabelValid pointsL2L_2 allL2L_2 excludedRemovedRemoved (%)
LGF626520.45000.450000.000
Potential flow (2k panels)613310.48080.46922290.373
Potential flow (4k panels)619550.49390.47274180.675
Potential flow (8k panels)626520.48190.47232320.370

Table 13. DrivAerML run 181 volume-vector errors associated with the car reference visualization. The figure uses LGF and 8k labels; other rows are existing resolution-study labels.

Full test-set label errors. Table 14 uses the fine-tuning test splits, sampled queries, inflows, and normalization. Entries are case means and population standard deviations. The no-wake proxy removes the last 15% of inflow-projected geometry extent for surface tasks, and points downstream of the stern for DTCHull. These geometric masks retain clipped labels and differ from the dense figure queries.

DatasetRegionLGFPotential flow (2k)Potential flow (4k)Potential flow (8k)
DrivAerMLFull1.4251±0.03601.4251 \pm0.03601.4024±0.06691.4024 \pm0.06691.4090±0.06691.4090 \pm0.06691.3837±0.06171.3837 \pm0.0617
No-wake proxy1.3887±0.03131.3887 \pm0.03131.3422±0.06431.3422 \pm0.06431.3468±0.07131.3468 \pm0.07131.3207±0.05951.3207 \pm0.0595
AirCraftFull1.9734±0.22651.9734 \pm0.22653.9812±0.61893.9812 \pm0.61894.0537±0.69074.0537 \pm0.69074.1088±0.71964.1088 \pm0.7196
No-wake proxy0.5498±0.07980.5498 \pm0.07981.8876±0.59951.8876 \pm0.59952.1291±0.85392.1291 \pm0.85392.1597±0.90222.1597 \pm0.9022
NASA-CRMFull1.2388±0.07081.2388 \pm0.07081.2890±0.19911.2890 \pm0.19911.4618±0.25511.4618 \pm0.25511.6227±0.26011.6227 \pm0.2601
No-wake proxy1.2441±0.08101.2441 \pm0.08101.2751±0.21151.2751 \pm0.21151.5089±0.26791.5089 \pm0.26791.7124±0.30691.7124 \pm0.3069
DTCHullFull0.1801±0.02840.1801 \pm0.0284———
No-wake proxy0.1981±0.03180.1981 \pm0.0318———

Table 14. Existing full-test-set label relative L2L_2 (case mean ±\pm population standard deviation). Numbers of cases: DrivAerML 25, AirCraft 25, NASA-CRM 44, DTCHull 10. A dash denotes an unavailable strict full-case statistic, not zero error.

DTCHull potential-flow entries are unavailable under the strict full-case criterion: some CFD queries lie inside simplified meshes, and six of ten original closed hulls have fewer than 8,000 faces. Missing labels are not filled. Numerical refinement of the same physical model does not remove its modeling error relative to CFD.

Flow Transfer Results

Final Errors

Table 15 gives all 24 flow task–budget comparisons at epoch 200. Figure 3 shows how test error varies with training budget and fine-tuning duration.

Data and Epoch Efficiency

The reference is scratch’s error at the largest budget Nmax⁡N_{\max} and epoch 200. Moving horizontally left to each piecewise-linear curve gives its equivalent case budget N∗N^* (at epoch 200) or epoch E∗E^* (at Nmax⁡N_{\max}), as illustrated in Figure 11. We compute

Figure 11. Horizontal-intersection calculation on the AirCraft curves from Figure 3. A square marks scratch’s final-budget, final-epoch error. The horizontal arrow meets SimpFlow at the same error (open circle); the vertical guide gives N∗=51.9N^* = 51.9 cases or E∗=133.1E^* = 133.1 epochs. These correspond to 48.1% case saving and a 1.50× epoch ratio.

Cases saved=100(1−N∗Nmax⁡)%,Epoch ratio=200E∗.\text{Cases saved} = 100\left(1-\frac{N^*}{N_{\max}}\right)\%, \qquad\text{Epoch ratio} = \frac{200}{E^*}.

We interpolate adjacent measured points on linear axes, taking the rightmost intersection if there are several. Fractional values are interpolated equivalents. A dash denotes an unreached target; a curve below target at its first point gives a bound without extrapolation. Scratch is the fixed endpoint reference. Epoch ratios exclude pre-training time.

BenchmarkMethodEquiv. casesCases saved (%)Equiv. epochEpoch ratio
AirCraftScratch100.00.0200.01.00
AirCraftLGF86.913.1145.71.37
AirCraftGeoPT57.142.9131.71.52
AirCraftSimpFlow51.948.1133.11.50
NASA-CRMScratch100.00.0200.01.00
NASA-CRMLGF––––
NASA-CRMGeoPT76.123.9148.21.35
NASA-CRMSimpFlow64.735.3136.91.46
DrivAerML (surface)Scratch100.00.0200.01.00
DrivAerML (surface)LGF––––
DrivAerML (surface)GeoPT58.641.4131.81.52
DrivAerML (surface)SimpFlow51.848.2100.51.99
DTCHullScratch100.00.0200.01.00
DTCHullLGF92.57.5126.81.58
DTCHullGeoPT54.046.0100.71.99
DTCHullSimpFlow31.768.3≤50.0\le50.0≥4.00\ge4.00
DrivAerML (volume)Scratch40.00.0200.01.00
DrivAerML (volume)LGF––––
DrivAerML (volume)GeoPT26.134.7106.41.88
DrivAerML (volume)SimpFlow23.042.571.02.82

Table 16. Interpolated efficiency at the task-specific scratch reference. Case savings and epoch ratios use the same measured test grid as Figure 3.

Output-Head Reset

This control uses the main 4k initialization and the same query-validity mask, task splits, training schedules, and seed 42 as the main results, covering all 24 flow task–budget settings. We reset the final normalization and projection while retaining the input mapping and backbone, then fine-tune all parameters. At epoch 200, the reset model outperforms scratch and LGF in all 24 settings and GeoPT in 21. Its three losses to GeoPT occur on AirCraft at 80 and 100 cases and NASA-CRM at 100 cases, as with the inherited head. Thus, the main configuration’s transfer gains do not depend on inheriting the output head.

TaskCasesGeoPT (reset)SimpFlow 4k (inherited)SimpFlow 4k (reset)
AirCraft200.20630.18380.1875
AirCraft400.16850.16550.1628
AirCraft600.15710.15410.1493
AirCraft800.14890.14920.1511
AirCraft1000.13350.14680.1453
NASA-CRM200.27830.22130.2288
NASA-CRM400.16970.15920.1586
NASA-CRM600.16220.12880.1316
NASA-CRM800.11690.11600.1154
NASA-CRM1000.10420.10540.1055
DrivAerML surface200.22140.21280.2102
DrivAerML surface400.18070.17030.1740
DrivAerML surface600.15740.15130.1517
DrivAerML surface800.14170.13930.1401
DrivAerML surface1000.13000.12750.1260
DTCHull200.06320.05710.0586
DTCHull400.05680.05170.0528
DTCHull600.05270.04940.0504
DTCHull800.04850.04680.0474
DTCHull1000.04760.04620.0457
DrivAerML volume100.09260.08610.0911
DrivAerML volume200.07790.07430.0767
DrivAerML volume300.06620.06240.0647
DrivAerML volume400.06200.05900.0596

Table 17. Output-head control for the main 4k initialization, seed 42 and epoch 200. Entries are case-averaged test relative L2L_2. Both SimpFlow variants use the same pretrained checkpoint; only output-head initialization differs. Bold marks the lowest error in each row; ties at the displayed precision are both bold.

Training and Selection Curves

Figure 13. Model-selection histories with the same layout as Figure 12. The four original tasks use validation relative L2L_2. DrivAerML volume has no validation set and uses training-set four-channel MSE, marked in its column title. These curves are separate from the fixed-checkpoint test grid and do not determine the reported epoch-200 results.

Figure 12. Training MSE for seed 42. Columns are the five flow benchmarks; rows are their ordered budget levels. Empty cells indicate absent budgets. Vertical limits are shared across budgets within a task and use a logarithmic scale. Targets and normalizations differ across tasks. There is no across-seed uncertainty shading.

Showcases

We show the first test case of each benchmark at its largest training budget, comparing scratch, LGF, and SimpFlow (4k) (seed 42). These plots use the original model-selection checkpoints: training-selected for DrivAerML volume and validation-selected otherwise. They provide qualitative examples separately from the fixed epoch-200 comparisons in Table 15. Annotated relative L2L_2 values use all original supervised queries and match the saved evaluations.

Each pair of rows shows ground-truth and predicted fields followed by absolute errors. All methods share the same field color scale, with any display clipping stated in the caption; error scales saturate at the pooled 99th percentile. Surface and slice reconstruction use the same weights across methods, with a maximum support distance of 0.35 normalized units. Small car-surface gaps are interpolated from neighboring supported faces. Gray indicates unsupported surface regions or solid interiors; unsupported exterior regions are white.

Figure 14. DrivAerML surface pressure coefficient and absolute error for run_181, with U∞=38.889U_\infty= 38.889 m/s. Pressure colors saturate outside [−1.2-1.2, 0.40.4], with white at Cp=0C_p = 0. Relative L2L_2 uses all 4,096 surface queries.

Figure 15. DTCHull speed and velocity-vector error for dtchull_55 at yaw 7.2075258∘7.2075258^\circ, on a horizontal slice 0.10 normalized units below the waterline. Relative L2L_2 uses the velocity vectors at all 3,584 supervised volume queries.

Figure 16. AirCraft upper- and lower-surface pressure coefficients and errors for 1_2.0_0.0_0.0, at Mach 2, zero angle of attack, and zero sideslip. Relative L2L_2 uses all 4,096 surface queries.

Figure 17. NASA-CRM upper- and lower-surface pressure coefficients and errors for test_Sample001, at Mach 0.721875 and angle of attack 3.45679∘3.45679^\circ. Relative L2L_2 uses all 4,096 surface queries.

Figure 18. DrivAerML volume pressure coefficient, speed, and their errors for run_230, shown on a horizontal section through the car. Relative L2L_2 is the joint four-channel error over all 8,192 volume queries; the displayed velocity error is the norm of the vector difference.

Figure 19. Car-Crash maximum-over-time von Mises stress and absolute error for test_sim_000, displayed on the undeformed surface. Relative L2L_2 uses all 4,096 supervised surface queries, with stress restored to its original units.

Transfer to Solid Mechanics

Car-Crash predicts maximum-over-time von Mises stress from the undeformed geometry. All pre-trained models reset their scalar stress head; SimpFlow uses the same 4k initialization as the flow comparisons. Protocols and normalization are in Section B.

Test Results

CasesScratchLGFGeoPTSimpFlow
200.55140.53890.53240.4786
400.31510.34980.32970.3835
600.17190.17670.17750.1852
800.12420.12540.12310.1234

Table 18. Car-Crash test relative L2L_2 at epoch 200, seed 42. Bold marks the lowest error in each row.

At 20 training cases, SimpFlow lowers test error by 13.2% relative to scratch. At 40 and 60 cases the error is 21.7% and 7.7% higher, respectively, while at 80 cases it is 0.7% lower. The strongest benefit is therefore observed at the smallest training budget, with transfer benefits varying across budgets. For the scratch reference of 0.1242 at 80 cases and epoch 200, SimpFlow reaches the target at the same budget and epoch. Figure 6 plots the budget and epoch curves.

Pressure and Stress References

The reference views below show the change from flow pressure to collision stress on the Neon geometry. The pressure illustration uses a 4k-panel solve, matching the resolution used to generate pretraining labels for the main initialization.

Panel Resolution

Ablation Design

We vary the target panel count across 500, 1k, 2k, 4k, and 8k to generate different numerical resolutions of the same potential-flow model. This ablation asks whether downstream transfer gains saturate as increasing the panel count raises the cost of generating pre-training labels. The dedicated 20-case 8k run shares the 2k/4k validity mask. It is separate from the original 8k initialization used in the broader budget comparison. The output-head reset control uses the main 4k initialization.

Twenty-Case Transfer Results

Table 19. Panel-resolution ablation. Entries are test relative L2L_2 at epoch 200, with 20 CFD training cases per benchmark and pre-training/fine-tuning seed 42. Counts denote target panel resolutions. Bold marks the lowest error in each row.

The comparison in Figure 5 reports the relative reduction in downstream test error,

Gb(M)=100Ebscratch−Eb(M)Ebscratch(20)G_b(M) = 100 \frac{E_b^{\mathrm{scratch}} - E_b^{(M)}}{E_b^{\mathrm{scratch}}} \tag*{(20)}

where Eb(M)E_b^{(M)} is the epoch-200 case-averaged test relative L2L_2. Scratch uses the same subset, seed, and evaluation cases, with errors 0.225441, 0.391862, 0.286293, and 0.070693 in table order. All five resolutions improve over scratch. The 500-panel error exceeds 1k on every task, while 2k–8k shows no monotonic improvement.

Transfer Across Budgets

Table 2 compares three available initializations on the same 22 task–budget settings: five budgets per original flow task and 20/40 cases for volume DrivAerML. Strictly lower epoch-200 test error counts as a win: 15/22 for 2k, 19/22 for 4k, and 19/22 for the original 8k model. The additional 10/30-case volume runs appear only in the 4k main grid and are outside this common set. This broader comparison uses the original 8k mask, while the dedicated 20-case 8k control above shares the 2k/4k mask. Labeling costs for these resolutions follow the common timing protocol in Section A.3.

References

  1. [1]Alkin, B., Fürst, A., Schmid, S., Gruber, L., Holzleitner, M., and Brandstetter, J. Universal physics transformers: A framework for efficiently scaling neural operators. In Advances in Neural Information Processing Systems, 2024.arxiv.org/abs/2402.12365
  2. [2]Alkin, B., Bleeker, M., Kurle, R., Kronlachner, T., Sonnleitner, R., Dorfer, M., and Brandstetter, J. AB-UPT: Scaling neural CFD surrogates for high-fidelity automotive aerodynamics simulations via anchored-branched universal physics transformers. Transactions on Machine Learning Research, 2025.
  3. [3]Ashton, N., Mockett, C., Fuchs, M., Fließbach, L., Hetmann, H., Knacke, T., Schonwald, N., Skperdas, V., Fotiadis, G., Walle, A., et al. DrivAerML: High-fidelity computational fluid dynamics dataset for road-car ex- ternal aerodynamics. arXiv preprint arXiv:2408.11969, 2024.
  4. [4]Bekemeyer, P., Hariharan, N., Wissink, A. M., and Cornelius, J. Introduction of applied aerodynamics surrogate modeling benchmark cases. In AIAA SCITECH 2025 Forum, 2025.DOI
  5. [5]Bleeker, M., Dorfer, M., Kronlachner, T., Sonnleitner, R., Alkin, B., and Brandstetter, J. NeuralCFD: Deep learning on high-fidelity automotive aerodynamics simulations. arXiv preprint arXiv:2502.09692v1, 2025. URL https://arxiv.org/abs/2502.09692v1. Version 1.
  6. [6]Chang, A. X., Funkhouser, T., Guibas, L., Hanrahan, P., Huang, Q., Li, Z., Savarese, S., Savva, M., Song, S., Su, H., et al. ShapeNet: An information-rich 3D model repository. arXiv preprint arXiv:1512.03012, 2015.arxiv.org/abs/1512.03012
  7. [7]Hao, Z., Wang, Z., Su, H., Ying, C., Dong, Y., Liu, S., Cheng, Z., Song, J., and Zhu, J. GNOT: A general neural operator transformer for operator learning. In International Conference on Machine Learning, 2023.arxiv.org/abs/2302.14376
  8. [8]Hao, Z., Su, C., Liu, S., Berner, J., Ying, C., Su, H., Anandkumar, A., Song, J., and Zhu, J. DPOT: Auto-regressive denoising operator transformer for large-scale PDE pre-training. In International Conference on Machine Learning, 2024.arxiv.org/abs/2403.03542
  9. [9]Herde, M., Raonić, B., Rohner, T., Käppeli, R., Molinaro, R., de Bézenac, E., and Mishra, S. Poseidon: Efficient foundation models for PDEs. In Advances in Neural Information Processing Systems, 2024.arxiv.org/abs/2405.19101
  10. [10]Hess, J. L. and Smith, A. M. O. Calculation of potential flow about arbitrary bodies. Progress in Aerospace Sciences, 8:1–138, 1967.DOI
  11. [11]Karniadakis, G. E., Kevrekidis, I. G., Lu, L., Perdikaris, P., Wang, S., and Yang, L. Physics-informed machine learning. Nature Reviews Physics, 3(6):422–440, 2021.DOI
  12. [12]Katz, J. and Plotkin, A. Low-Speed Aerodynamics. Cambridge University Press, 2 edition, 2001.DOI
  13. [18]Luo, H., Wu, H., Zhou, H., Xing, L., Di, Y., Wang, J., and Long, M. Transolver++: An accurate neural solver for PDEs on million-scale geometries. In International Conference on Machine Learning, 2025.arxiv.org/abs/2502.02414
  14. [19]McCabe, M., Régaldo-Saint Blancard, B., Parker, L. H., Ohana, R., Cranmer, M., Bietti, A., Eickenberg, M., Golkar, S., Krawczik, G., Lanusse, F., Pettee, M., Tesileanu, T., Cho, K., and Ho, S. Multiple physics pretraining for spatiotemporal surrogate models. In Advances in Neural Information Processing Systems, 2024.DOI
  15. [20]Meng, X. and Karniadakis, G. E. A composite neural network that learns from multi-fidelity data: Application to function approximation and inverse PDE problems. Journal of Computational Physics, 401:109020, 2020.DOI
  16. [21]Raissi, M., Perdikaris, P., and Karniadakis, G. E. Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations. Journal of Computational Physics, 378:686–707, 2019.DOI
  17. [22]Setinek, P., Galletti, G., and Brandstetter, J. Towards multi-fidelity scaling laws of neural surrogates in CFD. arXiv preprint arXiv:2511.01830, 2025. URL https://arxiv.org/abs/2511.01830.
  18. [23]Setinek, P., Paischer, F., Thuerey, N., Brandstetter, J., and Koehler, F. Compute-optimal data scaling for neural surrogates via multi-fidelity training. arXiv preprint arXiv:2610.17221, 2026. URL https://arxiv.org/abs/2610.17221.
  19. [24]Shen, Q., Liu, Y., and Wang, H. Scaling 3D physics surrogates: Low-fidelity pretraining for high-fidelity transfer. Manuscript, 2026.
  20. [25]Wong, B. Y. J. and Khoo, B. C. Inductive transfer-learning of high-fidelity aerodynamics from inviscid panel methods. Advances in Aerodynamics, 7:1, 2025. doi: 10.1186/s42774-024-00186-0.
  21. [28]Zhang, Z., Wu, Y., Zhang, K., and Wang, Y. From cheap geometry to expensive physics: Elevating neural operators via latent shape pretraining. arXiv preprint arXiv:2509.25788, 2025. URL https://arxiv.org/abs/2509.25788.
  22. [29]Zhou, A., Farimani, A. B., Ho, S., and Morel, R. Cross-domain pretraining for steady-state neural CFD surrogates. arXiv preprint arXiv:2610.10398, 2026. URL https://arxiv.org/abs/2610.10398.

Paper details

vlnc:W_qtf4gkr5
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents