betaFeedback

WorksPhysics and Astronomy

TurtLES: A Large-Scale Benchmark for Turbulent 3D Neural PDE Surrogates

Abstract

Machine-learning surrogates are increasingly used to accelerate computational fluid dynamics, yet progress is limited by the lack of benchmarks capturing realistic, time-dependent turbulent flows. We introduce TurtLES, a 14 TB dataset of 3D turbulent cylinder wakes in the shear-layer transition regime, computed via high-fidelity implicit large-eddy simulations. The dataset contains 400 trajectories of 400 time steps each, with 3-11 million points per frame, spanning variations in geometry, Reynolds number, and angle of attack. Unlike existing datasets, TurtLES combines (i) physically realistic turbulence with an active energy cascade driven by vortex stretching, (ii) dense irregular meshes, and (iii) long-horizon temporal dynamics. We benchmark state-of-the-art neural operators on autoregressive rollouts and identify key failure modes, including temporal instability, loss of small-scale energy, and challenges in learning on large irregular domains. TurtLES provides a new benchmark for evaluating surrogate models on 3D turbulent wakes at industrially relevant mesh resolution.

*Equal contribution. †Equal advising. Correspondence: jarno.platenburg[at]gmail.com, armand.kassai[at]isir.upmc.fr.

Introduction

The simulation of physical phenomena is central to industrial workflows in design [3], forecasting (Richardson, 1922), control [13], and decision-making [41]. These phenomena are governed by partial differential equations describing the spatio-temporal evolution of physical fields. Because such systems are rarely analytically tractable, they are solved numerically, often at substantial computational cost [4] (Quarteroni and Valli 2008). Yet downstream decisions rarely require the full resolution produced by high-fidelity solvers [9] (Yang 2015). This mismatch has motivated surrogate models: low-cost approximations that reproduce task-relevant physical behavior while avoiding repeated full-scale simulation. Deep learning has emerged as a powerful framework for surrogate modeling [17] (Long et al. 2018), with rapid progress in operator learning [2] (Li et al. 2021; Lu et al. 2021; Serrano et al. 2023; Wu et al. 2024), neural simulation [11], and generative emulation [44, 37] (Serrano et al. 2025). Its adoption in realistic simulation settings, however, remains limited by a circular dependency: accurate surrogates require large, high-quality datasets, but such datasets must typically be generated by the same numerical solvers or physical experiments that surrogates are meant to replace.

Recent datasets have begun to address this bottleneck, but each leaves a critical axis uncovered. The Well (Ohana et al., 2024) provides approximately 15 TB of dynamical trajectories across sixteen physical settings on regular grids, with most three-dimensional cases capped at 1283128^{3} resolution. DrivAerNet [18] reaches industrial-scale three-dimensional geometries with tens of millions of degrees of freedom on irregular meshes, but only at steady state. EAGLE [33] captures dynamic flows on irregular geometries, yet its O(103)O(10^{3}) points per frame are too coarse to resolve realistic three-dimensional flow structures. RealPDEBench [27] pairs real-world PIV measurements with matched simulations, but its fluid measurements are two-dimensional laser-sheet observations with only in-plane velocity components. It is therefore valuable for simulation–experiment alignment, but does not directly expose the three-dimensional velocity fields and multiscale structures needed to assess turbulent flow surrogates.

More broadly, many machine learning benchmarks conflate temporal complexity with turbulence. A flow may be unsteady, chaotic, or visually complex without containing the mechanisms that define three-dimensional turbulence. Several datasets described as “dynamic fluid” benchmarks fall into this category: they consist of unsteady laminar flows, chaotic two-dimensional systems, or three-dimensional dynamics dominated by buoyancy, radiative forcing, magnetic effects, or other mechanisms rather than by an inertial cascade (Pfaff et al., 2021; Takamoto et al., 2022). In three dimensions, turbulence is sustained by vortex stretching, represented by the (ω⋅∇)u(\boldsymbol{\omega} \cdot\nabla)\mathbf{u} term in the vorticity equation, which transfers kinetic energy from large eddies to progressively smaller scales until viscous dissipation closes the energy budget (Pope, 2000). In two dimensions, this mechanism is absent; in other forced systems, it may be secondary. A surrogate trained where vortex stretching is absent or marginal is therefore not learning three-dimensional turbulence, but rather interpolation of unsteady or chaotic fields without the cascade physics that define turbulent flow. Standard error metrics often hide this distinction, which becomes visible only through energy spectra, fluctuation statistics, and regime-transition behavior.

At the same time, the machine learning community has made substantial progress on the ingredients required for realistic surrogate modeling: long-horizon stability on regular grids (McCabe et al., 2024; Lippe et al., 2023), generalization [29, 36] (Subramanian et al. 2023; Takamoto et al. 2023), neural operators for dense unstructured static fields [43] (Wen et al. 2025; Luo et al. 2025), and generative emulators for chaotic dynamics (Zhou et al., 2025; Pedersen et al., 2025). What remains missing is a benchmark that stresses these capabilities jointly: dynamic three-dimensional trajectories, dense irregular discretizations, long temporal horizons, and physically turbulent flow driven by vortex stretching.

To fill this gap, we introduce TurTLES, a 14 TB dataset of high-fidelity simulations of three-dimensional cylinder wakes in the shear-layer transition regime. The dataset contains 400 trajectories of 400 time steps each, with 3–11 million points per frame sampled on irregular point clouds. Across trajectories, we vary the cylinder cross-section, Reynolds number, and angle of attack, producing geometry-dependent wakes that span subcritical to transitional regimes. In this range, shear-layer transition generates a turbulent near wake, so the dataset contains an active three-dimensional cascade in the simulated fields themselves.

TURTLES makes three contributions to surrogate modeling for PDEs. First, it provides dynamic three-dimensional flow data on dense irregular discretizations, reaching millions of points per frame rather than relying on regular grids or coarse point clouds. Second, it enables long-horizon evaluation over hundreds of autoregressive time steps in chaotic, geometry-dependent wakes. Third, it supports physically grounded assessment of turbulent surrogates through high-frequency quantities such as fluctuation statistics, near-wake spectra, and intermittent shedding-mode behavior. By combining industrially relevant mesh resolution, long temporal trajectories, irregular geometry, and physically turbulent flow, TURTLES targets a regime that existing benchmarks do not jointly cover. It exposes whether learned surrogates can remain stable, resolve multiscale turbulent content, and generalize across geometry-dependent flow regimes, rather than only minimizing standard field-wise errors.

Related Work

Operator Learning Operator learning provides a way to train neural networks to approximate PDE solution maps directly between function spaces. Early neural operators such as DeepONet and FNO showed that these models can act as mesh-independent surrogates for PDEs (Lu et al., 2021; Li et al., 2021). Since then, the field has moved toward models that are more accurate on complex geometries, better at resolving multiscale and high-frequency features, and scalable to very large meshes.

Recent work has explored several directions. Multiresolution and wavelet-based operators improve the representation of fine-scale structures [22], while latent and geometry-aware formulations extend neural operators to irregular domains [43] (Tran et al. 2023). Attention-based models such as OFormer, GNOT and Transolver further improve operator learning on point clouds and arbitrary domains by using graph or transformer encoders to handle irregular inputs and complex PDE dynamics [43, 25] (Wu et al. 2024). However, full attention remains expensive for high-resolution fields.

This has motivated more efficient neural operator surrogates. Perceiver-style and latent-token models such as Aroma and UPT compress large inputs into compact latent representations, reducing the cost of learning on dense meshes [2] (Serrano et al. 2024). Hagnberger et al. [23]; ); Kassaï Koupaï et al. [38] proposed continuous convolution for learning hierarchical neural operators that can operate on very dense grids, allowing million point trajectory generation. Wen et al. (2025) uses geometry-aware multiscale graph/attention encoding to scale neural PDE surrogates to arbitrary large meshes, including industrial 3D computational fluid dynamics (CFD) domains.

Datasets for Machine Learning Applications A key bottleneck in training neural operators for fluid dynamics is the limited availability of high-quality datasets. Generating such data requires solving the Navier-Stokes equations at high spatial and temporal resolution, which comes with substantial computational and storage costs. As a result, most existing datasets are restricted in either fidelity, dimensionality, or physical complexity.

A substantial body of work [9, 18, 35] (Sung et al. 2025; Paischer et al. 2025) has focused on performing steady-state flow simulations through the Reynolds-averaged Navier-Stokes (RANS) equations, where all turbulence fluctuations are modeled rather than computed directly. While these approaches significantly reduce computational complexity, RANS-based simulations suffer from well-documented limitations in capturing complex phenomena such as sharp pressure gradients, laminar-to-turbulent transition and flow separation (Wilcox, 1998). Furthermore, by definition, steady-state solutions neglect temporal dynamics, preventing operators from learning transient flow phenomena.

Therefore, several benchmarks based on unsteady flows have been introduced. A common cost-reducing strategy is to restrict simulations to two-dimensional domains [28, 32, 24, 33] (Viquera and Hachem 2020; Pfaff et al. 2021; Xu et al. 2023; Tali et al. 2025; Luo et al. 2024; Papelo and Bridgeman 2025), at the expense of losing relevant three-dimensional flow phenomena. Alternatively, higher-fidelity transient datasets generated using large-eddy simulation (LES) or direct numerical simulation (DNS) have been explored in well-known (multi-)physics benchmarks [26, 14, 39] (Takamoto et al. 2022; Ohana et al. 2024; Mao et al. 2026). There, they are typically limited to regular grids and idealized configurations (e.g., homogeneous isotropic turbulence, no objects within the domain, periodic boundary conditions). These flow problems do not introduce geometric complexities or capture the anisotropic nature of real-world turbulent flows. It should be noted that scale-resolving simulations for machine learning applications have been conducted by Ashton et al. [7] on the Ahmed and Windsor car bodies, respectively. However, due to storage constraints, only time-averaged volume data was made publicly available.

To the best of our knowledge, there is no dataset that combines three-dimensional, time-resolved high-fidelity CFD simulations with systematic variations in complex geometries while fully resolving a broad range of turbulent scales. The present study aims to address this gap by performing implicit large eddy simulations on irregular grids for the canonical cylinder flow case across a range of inflow and geometric configurations.

Dataset Presentation

The dataset captures a wide range of fluid–object interactions and wake dynamics through systematic variations in geometric parameters and inflow conditions, as illustrated in Figure 1 and Appendix § 18. To accurately resolve the resulting flow features and their temporal evolution, costly high-fidelity numerical simulations are performed. Generating a large number of such trajectories requires a robust and fully automated data generation pipeline. The remainder of this section describes the components of this pipeline, including the governing fluid flow model, the definition of the parameter sampling space, the automated simulation setup, and the subsequent data processing.

Figure 1. TURTLES visualized through QQ-criterion isosurfaces and its dataset parameters.

Fluid flow simulation The fluid dynamics are governed by the Navier–Stokes equations, a system of equations that expresses the conservation of mass, momentum, and energy for a compressible fluid. Given a set of inflow and boundary conditions, characterized by the Reynolds number ReRe, the Mach number MaMa and Prandtl number PrPr, these equations describe how a fluid evolves over space and time. In this study, we focus our attention on the evolution of the pressure pp, density ρ\rho and velocity components uu, vv, ww.

At sufficiently high Reynolds numbers, the Navier-Stokes equations give rise to turbulence, whose multi-scale, chaotic dynamics make direct numerical solution computationally prohibitive. We solve these equations using an implicit Large Eddy Simulation (iLES) approach, in which the most energetic turbulent scales are computed directly, while the truncation error of the numerical scheme acts as a model for the behavior of the smaller, unresolved scales. In this context, the Flux Reconstruction (FR) scheme [31] has proven to be effective and is implemented using PyFR (Witherden et al., 2014), an open-source, high-order accurate GPU-based solver. The user is referred to Appendix § 11 for quantity definitions, and to Appendix § 12 for a detailed description of the compressible Navier-Stokes equations and the solution method used in this study.

Sampling space The dataset is constructed within a four-dimensional parameter space. Variations in geometry are defined by the super-ellipse (or Lamé curve), i.e. all points (x,y)(x,y) satisfying:

∣xa∣n+∣yb∣n=1,(1)\left|\frac{x}{a}\right|^{n} + \left|\frac{y}{b}\right|^{n} = 1, \tag*{(1)}

where aa and bb represent half the horizontal and vertical dimensions of the object, respectively, as illustrated in Figure 2a. The aspect ratio is defined as AR=a/bAR = a/b. To reduce the number of variable parameters, b=1/2b = 1/2 is fixed for all cases, giving a constant object thickness D=2b=1D = 2b = 1. The semi-axis aa is sampled log-uniformly over the range [1/6,3/2][1/6,3/2], which results in aspect ratios spanning from 1/31/3 to 33, with an equal proportion of cases having AR<1AR < 1 and AR>1AR > 1. The exponent nn is selected from the discrete set {1,2,5,∞}\{1,2,5,\infty\}, corresponding to diamond, elliptical, rounded rectangle and rectangular shapes, respectively.

Figure 2. Overview of the parameter sampling space. (a) Definition of the super-elliptical geometry. (b) The Ns=400N_s = 400 samples visualized in three dimensions, including projections on the xx, yy, zz planes in gray for reference. (c-f) Histograms of the sampled parameters. Note that the colors used for different values of nn in (f) correspond with those in (a) and (b).

The inflow conditions are characterized by Reynolds numbers Re∈[1000,3900]Re \in[1000,3900], where the length scale used in the definition of ReRe is the object thickness DD. Within this range, the wake transitions to turbulence while the boundary layer remains laminar, consistent with observations from circular cylinder flow studies (Lienhard, 1966). The inflow angle of attack α\alpha is the counter-clockwise angle between the xx-axis and the object’s centerline. It is varied between 00 and 4545 degrees, introducing unique flow separation behavior for each configuration. Limiting the range to 45∘45^\circ prevents generating geometrically redundant cases. Both ReRe and α\alpha are varied uniformly and restricted to integer values for simplicity.

To obtain representative samples of the parameter space, we employ a Sobol’ sequence (Sobol’, 1967), which is a quasi-random low-discrepancy sequence designed to minimize clustering and gaps in high-dimensional sampling. Unlike related methods such as Latin Hypercube Sampling, it supports sequential sampling, making it well suited for dataset generation where the total number of cases need not be specified in advance. A four-dimensional unit hypercube is sampled Ns=400N_s = 400 times and subsequently transformed to the previously defined (log-)uniform or discrete parameter ranges. The resulting space is visualized in Figure 2b together with histograms of the different parameters in Figure 2c–Figure 2f. Trajectories are partitioned into fixed training, validation and test sets of 320/40/40 cases. The split is released with the dataset and described in Appendix § 16.

Simulation setup For each case, the super-elliptical object is placed inside the 3D computational domain in Figure 3a at an angle α\alpha. The flow is prescribed through boundary conditions placed on the walls (A–G). A is the inlet, B–D are the outlet and E is the object surface. Walls F and G represent the side-walls of the domain. They are assigned periodic boundary conditions, which means flow leaving F enters back through G. An automated routine is implemented to generate the computational mesh using Gmsh [20]. In Figure 3b, we show the resulting mesh in the xy-plane for the domain presented in Figure 3a. This two-dimensional mesh is then extended into three dimensions by a 30-layer structured extrusion in the span-wise direction. The flux reconstruction method places solution nodes inside these elements. A single element contains 75-125 points, yielding 2.9M to 10.5M unique solution points per case within the stored region (see Data processing below). Additional information on the domain definition and meshing procedure are given in Appendix § 13.

Figure 3. Schematic overview of the domain. (a) Three-dimensional view illustrating the physical boundaries, including the inlet (A), outlets (B–D), object surface (E), and periodic side-walls (F, G). (b) xyxy-plane of the computational mesh, which is extended into three dimensions via a structured extrusion in the span-wise (zz) direction.

The numerical framework is validated against four benchmark cases: a circular cylinder (a=0.5a = 0.5, n=2n = 2) at Re=1000Re = 1000 and Re=3900Re = 3900, a square cylinder (a=0.5a = 0.5, n=∞n = \infty) at Re=2000Re = 2000 and an elongated rectangle (a=2.5a = 2.5, n=∞n = \infty) at Re=3000Re = 3000. The results indicate good agreement with DNS and experimental data reported in the literature. A detailed comparison is provided in Appendix § 14.

Data processing Processing steps are applied to limit the total data size while ensuring the solutions remain physically representative. Data collection starts only after the initial transient has been washed away according to the numerical convergence statistic proposed by Boudet et al. [10]. Subsequently, 400 three-dimensional snapshots are saved of the three velocity components, pressure and density: {u,v,w,p,ρ}\{u, v, w, p, \rho\} at fixed time intervals Δts\Delta t_s. A snapshot is restricted to all solution nodes inside the rectangular box given by x/D∈[−3,10]x/D \in[-3, 10], y/D∈[−3.5,3.5]y/D \in[-3.5, 3.5] and z/D∈[0,2π]z/D \in[0, 2\pi]. The sampling interval Δts\Delta t_s exceeds the solver time-step to manage storage constraints but is chosen such that the inertial range of the turbulence spectrum is retained for all cases. Ultimately, one trajectory covers a time-period in which most characteristic frequencies are repeated multiple times. For instance, four vortex shedding cycles are captured during 400Δts400\Delta t_s in the circular cylinder case (a=0.5a = 0.5, n=2n = 2). Figure 4 visualizes the data structure of a single flow case. A case directory contains one set of node coordinates, as the grid remains constant throughout the entire trajectory, accompanied with the corresponding solutions for all 400 time-steps. Each case directory additionally stores power spectra of the streamwise (uu) and cross-stream (vv) velocity components at three centerline (y/D=0y/D = 0) probes located behind each object, together with the script used to compute them, providing per-case evidence of the turbulent cascade and a physically grounded target for surrogate evaluation. Appendix § 15 goes into more detail on the statistic used to measure the initial transient, the definition of Δts\Delta t_s and the computation of the velocity power spectra.

Figure 4. Overview of the flow case data structure. For each case, a single set of coordinates is stored with the solutions at 400 time-steps (e.g. t0t_0, t1t_1, ..., tft_f, where tf=399t_f = 399). A solution comprises the three-dimensional pressure (pp), density (ρ\rho), and velocity (uu, vv, ww) fields.

To lower the barrier to entry, we additionally define MINI-TURTLES: a set of standardized subsets that reduce the dataset in tiers down to 0.8 TB, together with a 5 GB debug subset. Subset definitions and access details are given in Appendix § 17.

Benchmarking Setup

Motivation and benchmark. To better demonstrate the value of this dataset, we evaluate the performance of current neural operators on these data. The machine learning task considered here is temporal prediction of the fields ρ\rho, pp, uu, vv, and ww. The dataset is designed to expose limitations of existing neural operators for dynamic forecasting: handling dense meshes remains computationally expensive, stability over long rollout horizons is often poor, and high-frequency features are frequently underrepresented or smoothed out. Since the dataset is parametric, it also tests generalization across a rich distribution of physical configurations.

We evaluate several recent state-of-the-art neural operator architectures from the literature: UPT (Alkin et al., [2]), GINO (Li et al., [43]), Transolver++ (Luo et al., 2025), and the continuous layer proposed in CALM-PDE (Hagnberger et al., [23]), combined with the scaling improvements introduced in ECHO for larger meshes (Kassai Koupaï et al., [38]). These baselines are intended as an initial benchmark, illustrating the level of performance attainable with well-established models under a shared, fixed training budget. Architectures, hyperparameters and model-specific adjustments are documented in Appendix § 19.

Training setup. The models are trained on all 320 training trajectories (Appendix § 16) to predict the temporal residual between time tt and time t+1t+1 from a single input frame:

NO⁡(ut,Re)+ut↦ut+1,\operatorname{NO}(u_t, Re) + u_t \mapsto u_{t+1},

where the Reynolds number ReRe is also provided as an input. Learning the residual is generally easier for neural networks than directly predicting the full next state. The training loss is a standard mean squared error, computed on the predicted residual. Since the meshes are very large, a subset of points is sampled during training, and each model predicts the corresponding points at the next time step. All models are trained for 100,000 steps with a batch size of 2, for approximately 20 hours on a single H100 GPU. We use the AdamW optimizer with a weight decay of 10−310^{-3} and a learning rate of 10−410^{-4}. All models are trained with a linear warmup over the first 5,000 steps, followed by a cosine learning-rate scheduler.

Inference and evaluation setup. At inference time, each model rolls out the full dynamics using only the initial condition and the Reynolds number. Each trajectory contains 400 time steps, while the number of mesh nodes varies across trajectories; we therefore use a batch size of 1 and predict all nodes in each frame by iterating over subsets of points, since the full mesh cannot be processed in a single forward pass. The rollout produces predictions u^t,n,c\hat{u}_{t,n,c} and reference values ut,n,cu_{t,n,c}, where t∈{1,…,Tout}t \in\{1, \ldots, T_{\mathrm{out}}\} indexes rollout steps, n∈{1,…,N}n \in\{1, \ldots, N\} indexes mesh nodes, and c∈{1,…,C}c \in\{1, \ldots, C\} indexes physical channels, with C=5C = 5 corresponding to pp, ρ\rho, uu, vv, ww.

We report four quantities computed from the autoregressive rollout. The first two are the relative L2L^2 error and the variance-scaled RMSE (VRMSE). We use VRMSE because the physical channels span several orders of magnitude, so unnormalized RMSE would be dominated by pp and ρ\rho:

Rel⁡-L2=1Tout∑t=1Tout∥u^t−ut∥2∥ut∥2+ε,VRMSE⁡=1Tout∑t=1Tout∥u^t−ut∥2∥ut−uˉt∥2+ε,ε=10−8,\operatorname{Rel}\text{-}L^2 = \frac{1}{T_{\mathrm{out}}} \sum_{t=1}^{T_{\mathrm{out}}} \frac{\lVert\hat{u}_t-u_t\rVert_2}{\lVert u_t\rVert_2+\varepsilon}, \qquad\operatorname{VRMSE} = \frac{1}{T_{\mathrm{out}}} \sum_{t=1}^{T_{\mathrm{out}}} \frac{\lVert\hat{u}_t-u_t\rVert_2}{\lVert u_t-\bar{u}_t\rVert_2+\varepsilon}, \qquad\varepsilon= 10^{-8},

where uˉt\bar{u}_t denotes the per-channel spatial mean of utu_t; a predictor that outputs this per-frame spatial mean attains VRMSE =1= 1.

Third, to assess multi-scale accuracy, we compare spanwise energy spectra of the streamwise velocity uu. The computational mesh has 121 uniformly spaced spanwise solution points, periodic in z∈[0,2π]z \in[0, 2\pi], and thus requires no interpolation. For each frame, we take the orthonormalized real FFT of uu along zz and average the squared modulus over all (x,y)(x,y) locations to obtain the power spectrum

Pt(kz)=1Nxy∑(x,y)∣u^t(x,y,kz)∣2.P_t(k_z) = \frac{1}{N_{xy}} \sum_{(x,y)} \left\lvert\hat{u}_t(x,y,k_z)\right\rvert^2 .

We split the wavenumber range in log kzk_z into low-, mid-, and high-frequency bands, Blow={1,2,3}B_{\mathrm{low}} = \{1, 2, 3\}, Bmid={4,…,15}B_{\mathrm{mid}} = \{4, \ldots, 15\}, Bhigh={16,…,60}B_{\mathrm{high}} = \{16, \ldots, 60\}, and report the RMS log-power discrepancy per band:

specRMSE⁡B=1Tout∑t=1Tout1∣B∣∑kz∈B(log⁡Ptu^(kz)−log⁡Ptu(kz))2.\operatorname{specRMSE}_{B} = \frac{1}{T_{\mathrm{out}}} \sum_{t=1}^{T_{\mathrm{out}}} \sqrt{\frac{1}{\lvert B \rvert} \sum_{k_z \in B} \left(\log P_t^{\hat{u}}(k_z) - \log P_t^u(k_z)\right)^2}.

These three bands probe large, intermediate, and small flow scales, respectively, and penalize spectral mismatches that pointwise RMSE can average away.

Finally, we report inference cost as the GPU time required to predict one trajectory on the full mesh. Encoder–decoder baselines such as UPT and CALM-PDE encode the input mesh once and decode query points in chunks, whereas Transolver++ processes the mesh through a tile partition; all models use the same per-frame timing protocol, differing only in kernel-launch granularity.

Results

We evaluate the models along three complementary axes: rollout accuracy, spectral fidelity, and latency. These criteria are designed to separate errors that are often conflated in field-wise metrics. A model may achieve low pointwise error while dissipating small-scale turbulent content, or may perform well over short horizons while drifting during long autoregressive rollouts.

Dynamics forecasting. In Table 1, we report the models’ performance on the first frame prediction. Under the shared training budget, CALM-PDE obtains the best field-level accuracy among the four baselines, with the lowest relative L2L^2 error (6.80×10−26.80 \times10^{-2}) and the lowest VRMSE (7.26×10−27.26 \times10^{-2}). UPT is close behind in relative L2L^2 error (7.01×10−27.01 \times10^{-2}), but its VRMSE is about 23% higher (8.94×10−28.94 \times10^{-2}), indicating larger errors once the spatial variance of each frame is accounted for. Transolver++ and GINO are substantially less accurate in this setting: both have higher relative L2L^2 errors, and their VRMSE values are at or above the mean-field level (1.06 and 1.21, respectively), i.e. no better than predicting the per-frame spatial mean. The spectral metrics further show that UPT and CALM-PDE preserve the low-, mid-, and high-frequency content with similar accuracy, while Transolver++ exhibits a much larger high-frequency error and GINO a larger low-frequency error.

ModelRel-L2L^2 ↓\downarrowVRMSE ↓\downarrowLow ↓\downarrowMid ↓\downarrowHigh ↓\downarrow
UPT7.01e-28.94e-24.69e-22.33e-24.42e-2
GINO1.32e-11.211.32e-17.31e-24.48e-2
Transolver++1.08e-11.068.02e-22.89e-24.41e-1
CALM-PDE6.80e-27.26e-24.66e-22.38e-24.44e-2

Table 1. Next frame results on the test set. Lower is better for all metrics. Spectral errors are RMS log-power discrepancies computed over low-, mid-, and high-frequency spanwise wavenumber bands.

Long-range stability. Table 2 highlights a clear difference between short-horizon accuracy and long-horizon rollout stability. CALM-PDE remains stable throughout the autoregressive rollout, with VRMSE increasing only from 4.61×10−14.61 \times10^{-1} in the first 50 steps to 7.89×10−17.89 \times10^{-1} in the last rollout window. In contrast, UPT begins with a moderate error but drifts rapidly over time, reaching a VRMSE of 5.12 in the final window. Transolver++ is unstable from the beginning of the rollout and its error grows sharply, reaching 31.24 over steps 301–399. These results indicate that CALM-PDE better preserves the dynamics of the wake attractor over long autoregressive horizons, whereas the other reported baselines accumulate errors that eventually dominate the trajectory.

Table 2: Rollout stability and computational cost. Rollout columns: VRMSE averaged over windows of rollout steps. Cost: GPU time to generate (solver) or predict (surrogates) one full trajectory, i.e. wall-clock time ×\times GPUs used (four for the solver, one for each surrogate) on NVIDIA H100 80 GB.

Model1–5051–150151–300301–399Cost [GPU-s] ↓\downarrow
Solver (PyFR)––––13160
UPT6.51e-11.563.315.12835
GINO3.1810.3224.3133.124097
Transolver++2.338.3219.3331.241148
CALM-PDE4.61e-15.46e-16.52e-17.89e-11073

Table 2.

Spectral fidelity. Pointwise errors do not fully reveal whether a surrogate preserves the multi-scale structure of the turbulent wake. We therefore compare spanwise energy spectra between predicted and reference trajectories. In Figure 5, spectra are averaged over test trajectories and rollout times, and the spectral error is shown as a function of wavenumber. A model that tracks large coherent structures but dissipates small eddies is expected to match low wavenumbers while underestimating high-wavenumber energy. We also report a persistence baseline, defined by the one-step rule u^t+1=ut\hat{u}_{t+1} = u_t; under autoregressive rollout, this corresponds to repeating the initial state. Because this baseline preserves a real turbulent snapshot, it can match the time-averaged energy spectrum reasonably well despite not predicting the temporal evolution of the wake. This highlights that spectral agreement alone is insufficient and should be interpreted together with field-level and long-horizon rollout errors. Among the learned models, CALM-PDE most closely matches the reference spectrum across the resolved range, with near-zero log-power discrepancy over low and intermediate wavenumbers. UPT follows the correct spectral decay but shows larger high-wavenumber errors, indicating reduced fidelity at small scales. In contrast, Transolver++ strongly overpredicts spectral energy, especially at intermediate and high wavenumbers, suggesting spurious small-scale content during rollout.

Figure 5. Spectral fidelity of autoregressive rollouts. Panel (a) shows reference and predicted spanwise energy spectra averaged over test trajectories. Panel (b) shows the log-power discrepancy across wavenumbers.

Latency. Finally, we compare the full-mesh inference cost of the neural surrogates in the last column of Table 2, together with the cost of generating one trajectory with the solver. All evaluated methods remain costly at this spatial resolution, requiring hundreds to thousands of seconds to predict a full trajectory. UPT is the fastest baseline, followed by CALM-PDE and Transolver++, while GINO is substantially slower than the other methods, which also constrains its accuracy: it is the only baseline that did not converge within the shared training budget. In GPU-seconds, every surrogate provides a net speedup over the solver, ranging from ∼3×\sim3\times for GINO to ∼16×\sim16\times for UPT. This margin is modest compared with the speedups commonly reported for neural surrogates on smaller problems. These results show that, even when surrogate models improve rollout accuracy, scaling inference to dense irregular meshes with millions of points remains a major computational bottleneck.

Together, these evaluations expose complementary failure modes of neural PDE surrogates on TURTLES: short-horizon prediction error, long-horizon instability, loss of high-frequency turbulent energy, and insufficient computational acceleration on dense irregular meshes.

Limitations. TURTLES is restricted to one physical regime: turbulent cylinder wakes in the shear-layer transition range. Whether the failure modes observed here transfer to other geometries or Reynolds regimes remains an open question. The reference trajectories are themselves an approximation: computed via implicit-LES, so every surrogate error reported here is measured against this solver rather than against a DNS or experimental ground truth. To keep the dataset tractable, snapshots are subsampled in time; although the sampling interval is chosen to preserve the inertial range, some high-frequency information is inevitably discarded. The resulting short sampling window also rules out converged averaged statistics such as Reynolds stresses, which would require substantially longer trajectories than storage permits, limiting the physical diagnostics available for evaluation. Finally, the four baselines surveyed here are not an exhaustive account of how neural operators perform on this class of flows; building that account is the role we intend TURTLES to serve.

Conclusion

We introduced TURTLES, a large-scale benchmark for learning neural PDE surrogates in realistic three-dimensional turbulent flow regimes. The dataset contains 400 high-fidelity iLES trajectories of cylinder wakes across variations in geometry, Reynolds number, and angle of attack, with millions of irregularly distributed solution points per frame and hundreds of time steps per trajectory. By combining dense unstructured spatial discretizations, long temporal horizons, and physically turbulent wake dynamics, TURTLES targets a regime that is not jointly covered by existing CFD benchmarks.

Our benchmark experiments show that current neural operators face major challenges in this setting. While several models achieve reasonable short-horizon accuracy, long autoregressive rollouts reveal substantial differences in stability. Spectral diagnostics show that pointwise errors alone are insufficient: models may appear accurate while misrepresenting turbulent energy at fine scales.

TURTLES is intended to support progress toward neural surrogates that are not only accurate on average, but also stable over long horizons, faithful to multiscale turbulent structure, and efficient on meshes of industrially relevant size. Future work may extend the benchmark to additional geometries, higher Reynolds-number regimes, richer boundary conditions, and uncertainty-aware or generative surrogate models. We hope that TURTLES will provide a useful testbed for developing and evaluating next-generation neural operators for high-resolution computational fluid dynamics.

Acknowledgments and Disclosure of Funding

We acknowledge the financial support provided by DEEPNUM (ANR-21-CE23-0017-02), PHLUSIM (ANR-23-CE23-0025-02), MELISSA (ANR-24-CE23-7140-01), PEPR Sharp (ANR-23-PEIA0008, ANR, FRANCE 2030), and cluster IA PostGenAI@Paris (ANR-23-IACL-0007).

This project was provided with computer and storage resources by GENCI at IDRIS thanks to the grants 2026-AD011016890R2, 2026-AD011017368, 2025-A0191016890, 2026-A0211016890 on the supercomputer Jean Zay’s V100/A100/H100 partitions.

The authors declare no competing interests.

Broader impact

TURTLES provides high-fidelity three-dimensional turbulent flow trajectories on dense irregular meshes, and is intended to serve as a benchmark for the development of neural surrogate models in computational fluid dynamics. We anticipate the following uses:

  1. evaluating geometry-aware operator-learning models on dynamic, physically turbulent three-dimensional flow rather than on regular-grid or two-dimensional benchmarks;

  2. studying the long-horizon stability and multiscale spectral fidelity of learned PDE surrogates through the evaluation protocol introduced in § 5;

  3. informing the design of new architectures for irregular meshes with millions of degrees of freedom, where memory and inference cost become first-order constraints;

  4. extending point-cloud and graph-based benchmarks toward industrially relevant fluid-dynamics regimes;

  5. supporting the development of surrogate solvers that accelerate early-stage design exploration in aerospace and automotive engineering;

  6. studying the generalization behavior of neural operators across geometry, Reynolds number, and angle of attack in a controlled parametric setting.

We do not anticipate direct negative societal impact: the dataset is synthetic and contains no personally identifiable, geographic, or sensitive information. As with any data-driven surrogate, downstream practitioners should validate predictions before relying on them for safety-critical engineering decisions; surrogate models trained on TURTLES are not substitutes for verified high-fidelity simulation in such contexts.

Reproducibility statement

The project page provides (i) the code used to generate every table and figure in the main paper; and (ii) a link to the dataset hosted on Hugging Face, along with instructions for re-running the data generation pipeline (mesh generation with Gmsh, simulation with PyFR, post-processing into HDF5).

All baseline experiments were conducted on a single NVIDIA H100 80 GB GPU per run, with approximately 20 hours of wall-clock training time per model. Evaluation runs use the same hardware. Hyperparameters, data subsampling, optimization schedule, and inference protocol are documented in Appendix § 19.

Description of software

This work uses computational fluid dynamics, mesh-generation, and machine learning tools, all of them open source.

PyFR (Witherden et al., 2014). PyFR is an open-source GPU-accelerated solver for advection–diffusion-type problems, based on the Flux Reconstruction high-order accurate scheme. We use PyFR for all ILES simulations. We used version 2.1 of PyFR with CUDA 12 on NVIDIA H100 GPUs. PyFR is released under the BSD 3-Clause license.

Gmsh [20]. Gmsh is an open-source three-dimensional finite-element mesh generator with a built-in CAD engine and post-processor. We use Gmsh, scripted from Python, to build all 400 meshes in the dataset (block-structured near-wall regions, unstructured wake regions, structured spanwise extrusion). We used version 4.11. Gmsh is released under the GNU GPL.

HDF5 / h5py [19]. The dataset is stored in HDF5 chunks (one coordinate file plus four temporal chunks of 100 frames per trajectory) and read at training and evaluation time through h5py. HDF5 is released under a permissive BSD-style license; h5py is released under the BSD 3-Clause license.

PyVista (Sullivan and Kaszynski, 2019). PyVista is an open-source tool for 3D visualization and mesh analysis built on top of the Visualization Toolkit (VTK). In this work, we use it to post-process the physical fields produced by our simulations. PyVista is released as free and open-source software under the MIT License.

ParaView ([1]). We use ParaView for qualitative visualization of the simulated and predicted flow fields. We used version 5.13. ParaView is released under the BSD 3-Clause license.

PyTorch ([5]). All neural-network training and inference is implemented in PyTorch. We used PyTorch 2.8 with CUDA 12.8 and Python 3.12. PyTorch is released under the BSD 3-Clause license.

neuraloperator ([40]). The GINO baseline is built on the official neuraloperator library, which provides the GNO and FNO building blocks used in the encoder–FNO–decoder pipeline described in Appendix § 19. We used version 1.0.2. neuraloperator is released under the MIT license.

Constant and Dimensionless Quantities

In compressible flow simulations, the dynamics are primarily governed by the Reynolds number (ReRe), Mach number (MaMa) and Prandtl number (PrPr). In addition, cylinder flows exhibit periodic unsteady behavior which warrants the introduction of a non-dimensional frequency, namely the Strouhal number (StSt). We mathematically define these quantities as follows:

Re=ρUDμ,Ma=Uc,Pr=μcpk,St=fDU.(2)Re = \frac{\rho U D}{\mu}, \qquad Ma = \frac{U}{c}, \qquad Pr = \frac{\mu c_p}{k}, \qquad St = \frac{fD}{U}. \tag*{(2)}

UU and DD denote the characteristic velocity and length scale of the problem, respectively. In the present study, UU is equal to the inflow velocity U∞U_{\infty}, and D=2b=1D = 2b = 1 is the object thickness defined in § 3. Furthermore, ρ\rho is the fluid density, μ\mu the dynamic viscosity, cc the speed of sound, cpc_p the specific heat, kk the thermal conductivity, and ff is a characteristic frequency associated with the flow. For all flow cases considered in this work, the Mach number Ma=0.2Ma = 0.2 and Prandtl number Pr=0.71Pr = 0.71 are kept constant while the Reynolds number is varied. Finally, time tt is always presented in dimensionless form, normalized by the characteristic time scale D/UD/U.

Implicit Large Eddy Simulation

The Navier–Stokes equations represent the fundamental laws governing fluid dynamics. For a Cartesian coordinate system, Equation (3), Equation (4), and Equation (5) respectively denote a fluid’s conservation of mass, momentum and energy:

∂ρ∂t+∂∂xi(ρui)=0,(3)\frac{\partial\rho}{\partial t} + \frac{\partial}{\partial x_i}(\rho u_i) = 0, \tag*{(3)}
∂∂tρui+∂∂xj(ρuiuj)=−∂p∂xi+∂∂xjτij,(4)\frac{\partial}{\partial t}\rho u_i + \frac{\partial}{\partial x_j}(\rho u_i u_j) = -\frac{\partial p}{\partial x_i} + \frac{\partial}{\partial x_j}\tau_{ij}, \tag*{(4)}
∂∂tE+∂∂xj(Euj)=∂∂xj[uiτij−qj−puj],(5)\frac{\partial}{\partial t}E + \frac{\partial}{\partial x_j}(E u_j) = \frac{\partial}{\partial x_j}[u_i\tau_{ij} - q_j - p u_j], \tag*{(5)}

where ρ\rho is the fluid density, EE is the total energy per unit volume and uiu_i denotes the velocity in the xix_i direction (with i=1,2,3i = 1, 2, 3 corresponding to the xx, yy, zz axes). Note that these equations utilize Einstein notation where a repeated index (ii, jj, kk) implies a summation over all spatial dimensions. Furthermore, the stress tensor, strain tensor and heat flux are defined as:

τij=2μ[Sij−13∂uk∂xkδij],Sij=12(∂ui∂xj+∂uj∂xi),qj=−μPr∂h∂xj.(6)\tau_{ij} = 2\mu\left[S_{ij} - \frac{1}{3}\frac{\partial u_k}{\partial x_k}\delta_{ij}\right], \qquad S_{ij} = \frac{1}{2}\left(\frac{\partial u_i}{\partial x_j} + \frac{\partial u_j}{\partial x_i}\right), \qquad q_j = -\frac{\mu}{Pr}\frac{\partial h}{\partial x_j}. \tag*{(6)}

Here, μ\mu is the fluid’s dynamic viscosity, PrPr is the Prandtl number, and hh is the specific enthalpy. Finally, the ideal gas equation of state provides a relation coupling the pressure to the total energy:

p=(γ−1)(E−12ρuiui).(7)p = (\gamma- 1)\left(E - \frac{1}{2}\rho u_i u_i\right). \tag*{(7)}

where γ\gamma is the specific heat ratio. An analytical solution to this system of equations only exists under simplifying assumptions, and thus numerical methods are used to approximate solutions for complex flow problems. The domain is then discretized into a grid on which flow variables are iteratively solved. To capture the entire turbulence spectrum of a fluid, Direct Numerical Simulation (DNS) employs a grid fine enough to resolve the smallest physical structures. The computational overhead is often intractable for industrially relevant applications, as the cost of fully resolving all turbulent scales in 3D Navier-Stokes simulations grows with Re3Re^3, where ReRe denotes the Reynolds number. Instead, Reynolds-averaged Navier-Stokes (RANS) based simulations decompose an instantaneous fluid quantity into its time-averaged and fluctuating component, whereby the effects of the latter are represented by a turbulence model rather than computed directly. While this allows a significant reduction in computational cost, these methods exhibit limited accuracy for complex flow phenomena (e.g. laminar-to-turbulent transition, separation, three-dimensional effects) (Wilcox, 1998).

Large Eddy Simulation (LES) provides a high-fidelity alternative for simulating turbulent flows at reasonable cost. It is based on the separation between the energy-containing large scales of turbulence and the smaller high-frequency scales through a filter operation (Pope, 2000):

ui(x,t)=u^i(x,t)+ui′′(x,t).(8)u_i(x,t) = \hat{u}_i(x,t) + u_i^{\prime\prime}(x,t). \tag*{(8)}

The filtered flow variables (u^i\hat{u}_i) are also referred to as the resolved variables, as they are directly solved for in the LES framework. The residual of the filter operation, ui′′u_i^{\prime\prime}, represents the unresolved turbulent motions. Numerous filtering strategies exist, but often the computational mesh itself acts as a filter where the local grid size, Δgrid\Delta_{grid}, dictates the cut-off between represented turbulent scales and sub-grid scales (SGS). The scale separation of Equation (8) is physically motivated by each component’s distinct behavior. The resolved scales are highly energetic, anisotropic, and strongly influenced by the flow geometry, which requires their direct computation. In contrast, the unresolved scales are more isotropic, carry less energy and exhibit a more universal behavior, which allows for unified approaches to modeling their effects. Because these smaller scales are not resolved, LES utilizes significantly coarser meshes than DNS, leading to reduced computational complexity.

In explicit LES, an explicit model is used to replicate the effects of SGS turbulence, which entails providing the correct energy drain from the resolved flow to the smaller unresolved scales. This approach assumes that numerical errors associated with the discretization scheme are small. In practice, this is often not the case, as even high-order schemes exhibit truncation errors of similar magnitude to SGS model contributions [21]. Both truncation errors and SGS model terms are typically most significant at the smallest resolved scales. Due to the strong non-linear nature of Navier-Stokes, their combined effect can be difficult to anticipate. One way to address this challenge is to apply an explicit filter at a scale larger than the grid spacing (Δfilter>Δgrid\Delta_{filter} > \Delta_{grid}), effectively shifting the SGS model’s activity away from the high-frequency truncation errors. However, this significantly increases computational cost as much finer grids are required to maintain the same level of resolved turbulence.

Alternatively, by recognizing that some numerical schemes exhibit errors of similar dissipative nature as the effect of the sub-grid scales, implicit LES (iLES) abandons the use of an explicit SGS model and lets the truncation error serve as the energy drain from the resolved flow. The present study adopts this approach by employing the Flux Reconstruction (FR) or Correction Procedure via Reconstruction (CPR) scheme [31]. CPR functions well in the context of iLES as the scheme is inherently dissipative at high wave numbers (Vincent et al., 2011).

Simulation setup

Domain and Boundary Conditions The compressible Navier-Stokes equations are solved within the three-dimensional domain in Figure 6a. This domain is generated by extruding the 2D plane depicted in Figure 6b by a spanwise length of 2π2\pi. The center of the super-elliptical object E (colored in pink) is placed at the origin (x,y)=(0,0)(x,y) = (0,0) and rotated according to its prescribed inflow angle α\alpha. Rotating the object, rather than modifying the inflow angle of the flow field, is more convenient as it ensures the wake always propagates in the horizontal direction, which simplifies meshing and deciding what solution region to extract during data processing. The five blocks defined by the black lines in Figure 6b have no physical meaning but are used to control the automated meshing. The four blocks directly surrounding the physical object define the structured meshing region by placing a super-ellipse with a′a', b′b' and n′n' (see § 3) and connecting it to object E with parameters aa, bb and nn. In all cases, a′=a+D/2a^{\prime}=a+D/2 and b′=b+D/2b^{\prime}=b+D/2 in order to create a thick enough structured mesh region that can capture the initial development of separated shear layers. n′n^{\prime} is discretely defined as 1.5, 2, 5, and 10 for n=1n=1, 2, 5, and ∞\infty, respectively. These values mitigate mesh skewness, which can otherwise lead to numerical issues. The rectangular box is used to control the mesh nearby and behind the object, where a fine resolution is required to capture complex wake structures. Its front, top and bottom boundaries are located 1D1D from the structured mesh region, while the back edge extends to 7D7D behind the super-ellipses. Finally, the inlet A is positioned at 7D7D ahead of the rectangular wake box while the outlet curves B–D always extend until x/D=25x/D=25. Table 3 provides an overview of the boundary conditions placed on the domain.

Figure 6. Schematic overview of the computational domain. (a) Three-dimensional view illustrating the physical boundaries, including the inlet (A), outlets (B–D), object surface (E), and periodic side-walls (F, G). (b) 2D side view showing characteristic dimensions relative to the object thickness DD. Note that black lines have no physical implications but indicate regions used for mesh refinement.

CategorySymbol (in Figure 6aBoundary condition
InletARiemann invariant
OutletB–DRiemann invariant
WallEAdiabatic no-slip wall
Left sideFPeriodic
Right sideGPeriodic

Table 3. Boundary conditions of the simulation. Surface symbols refer to boundaries indicated in Figure 6a

Meshing Generating a high-quality mesh is essential for achieving accurate and stable CFD simulations. Key considerations include minimizing element distortions, maintaining low skewness, ensuring gradual transitions in cell size, and providing adequate resolution. The latter is of particular importance in implicit large eddy simulations, where it is assumed that a significant portion of turbulence scales is directly resolved. In practice, a high-quality mesh is attained through case-specific iterative refinement, which is not feasible when constructing a large dataset. It was therefore chosen to adopt a simple meshing strategy that can be automated, accommodates a wide range of flow cases and limits the number of variable parameters. The routine is implemented using Python and Gmsh ([20]), an open source three-dimensional finite element mesh generator. Gmsh supports the generation of high-order meshes, which improve accuracy for domains with curved boundaries.

The xyxy-plane is partitioned into six blocks as illustrated in Figure 7. The dimensions of each block are defined in Figure 6b and remain consistent across all flow cases. Blocks V and VI are discretized using unstructured triangular elements, as they provide flexibility in dealing with geometric variations. For each block, a target cell size is set: lwbl_{wb} (for V) and lffl_{ff} (for VI). Gmsh targets these sizes when possible while ensuring smooth transitions between regions of differing resolution. Blocks I-IV employ structured layers to give precise control over the near-wall discretization. Within these regions, the first element thickness ltl_t is chosen such that y+<1y^{+}<1. All other wall-normal cell sizes are determined through a geometric progression with a growth rate of 1.021. Furthermore, the cell size in the wall-parallel direction is set by lpl_p.

Two-dimensional computational mesh showing the full domain and zoomed-in geometric object

Figure 7. Two-dimensional (xyxy-)plane of the computational mesh. The full three-dimensional domain is a 30-layer extrusion in the zz direction. (a) Full domain. (b) Zoomed-in view of the geometric object.

Mesh resolution is highly dependent on Reynolds number; for increasing ReRe, a finer mesh is required to capture the smaller turbulent structures. To determine the appropriate values of the parameters lwbl_{wb}, lffl_{ff}, ltl_t, and lpl_p, mesh convergence studies are conducted at the edge cases of Re=1000Re = 1000 and Re=3900Re = 3900 in Appendix § 14. Between these Reynolds numbers, cell sizes are scaled using a power law interpolation. This resulting two-dimensional mesh is extended into three dimensions by a 30-layer structured extrusion in the span-wise direction.

Validation

The simulation is validated using DNS and experimental data of four benchmark cases: a circular cylinder flow (a=0.5a = 0.5, n=2n = 2) at Re=1000Re = 1000 and Re=3900Re = 3900, an elongated rectangle (a=2.5a = 2.5, n=∞n = \infty) at Re=3000Re = 3000 and a square rectangle (a=0.5a = 0.5, n=∞n = \infty) at Re=2000Re = 2000. These cases were selected to span a broad range of Reynolds numbers and to assess performance on sharp-edged and rounded geometries with varying aspect ratios. Figure 8 presents the overall statistics for each case together with reference data from literature. In general, the simulation shows good agreement with DNS and experimental results. Discrepancies are observed in drag prediction for very bluff bodies, but this appears to be a common trend for the studies included in the figure. These cases are discussed in detail below, with the cylinder flow cases also being used for a mesh convergence study.

Comparison of present simulations with validation data for Strouhal number, drag coefficient, and recirculation length

Figure 8. Comparison between present simulations (solid black markers) and validation data from the literature (open and hatched markers) for (a) Strouhal number, (b) drag coefficient, and (c) recirculation length. Validation data are taken at discrete Reynolds numbers from the following sources: ReRe=1000 (Jiang and Cheng, [34]); ReRe=1783 (Bai and Alam, [8]); ReRe=2000 (hatched) (Sharma and Dutta, 2022}) and (open) (Brun et al., 2008); $Re$=3000 ({citet}Cimarelli et al., 2018); $Re$=3900 ({citet}Lehmkuhl et al., 2013`).

Circular cylinder (a=0.5a = 0.5, n=2n = 2) at Re=1000Re = 1000 and Re=3900Re = 3900

The circular cylinder flow case is used for a mesh convergence study, ensuring the numerical results are independent of spatial discretization. Simulations are conducted for 1500 non-dimensional time units on increasingly refined grids and compared against DNS data from Lehmkuhl et al. [42]. Refinements are achieved by adjusting the parameters lwbl_{wb}, lffl_{ff}, ltl_t and lpl_p described in Appendix § 13, yielding computational meshes with 12.9M, 20.0M, 32.6M solution points in the full computational domain, hereafter referred to as the coarse, medium and fine grids, respectively. Note that the dataset only stores the solution points inside the extraction box defined in the data processing paragraph of § 3, so the per-case point counts reported there are lower.

The flow around a circular cylinder at Re=3900Re = 3900 has been studied extensively, yet varying results are reported in the literature. Lehmkuhl et al. [42] addressed these inconsistencies by demonstrating that the flow exhibits bistable behavior, oscillating between two modes, characterized by the length of the separated wake region, also referred to as the recirculation length. Previous studies relied on observation windows that were too short to record both modes, leading to results that reflected either the short-bubble state ((Lourenço and Shih, 1993)) or the long-bubble state ((Parnaudeau et al., 2008)).

Figure 9b displays the streamwise velocity along the centerline (y/D=0y/D = 0) downstream of the cylinder. The three mesh resolutions yield nearly identical profiles in agreement with the DNS data, although a slightly shorter recirculation bubble is consistently observed. Figure 9a shows the pressure coefficient distribution over the cylinder surface, defined as Cp=(p−p∞)/12ρ∞U∞2C_p = (p - p_\infty)/\frac{1}{2}\rho_\infty U_\infty^2, where ∞\infty denotes free-stream conditions. Due to symmetry, the results from the upper and lower surfaces are averaged together. At θ=0∘\theta= 0^\circ, the flow encounters the stagnation point where its velocity reduces to zero and CpC_p attains its maximum. For incompressible flow, as in Lehmkuhl et al. [42], Cp=1C_p = 1 is expected when the flow velocity is zero, consistent with Bernoulli’s principle. In the present study, however, CpC_p slightly exceeds 1. This deviation can be attributed to compressibility effects, as the flow is computed at Ma=0.2Ma = 0.2. Furthermore, minor discrepancies with the reference data are observed between 45 and 90 degrees, which is consistent with solutions that capture more of the short-bubble state.

Figure 9. Results for the coarse, medium and fine computational grids: (a) pressure coefficient distribution over the cylinder surface as a function of the angular position θ\theta, defined from the front stagnation point (θ=0∘\theta= 0^\circ) and increasing along the cylinder surface in the clockwise direction; and (b) mean streamwise velocity along the centerline (y/D=0y/D = 0) downstream of the cylinder. Validation data are taken from Lehmkuhl et al. [42].

Time-averaged wake velocities and their fluctuations at positions x/D=1.06x/D = 1.06, 1.54 and 2.02 are presented in Figure 10 and Figure 11, respectively. Fluctuations are computed by subtracting the temporal mean from the velocity signal: u′=u−⟨u⟩u' = u - \langle u \rangle. The mean velocity profiles show an excellent agreement with Lehmkuhl et al. [42]. The only notable discrepancy occurs for the streamwise velocity at x/D=2.02x/D = 2.02 where the simulations predict a slightly faster recovery of the velocity deficit, consistent with short-bubble solutions. The fluctuation profiles exhibit larger deviations from the reference data, a challenge commonly reported in the literature. For instance, Vermeire et al. (2017) observed over-predictions of similar magnitude and character when comparing second-order statistics to Lehmkuhl et al. [42].

Figure 10. Results for the coarse, medium, and fine computational grids: mean wake velocity profiles of (a) streamwise component uu and (b) transverse component vv at downstream locations x/D=1.06x/D = 1.06, 1.54, and 2.02. For clarity, profiles at x/D=1.54x/D = 1.54 and 2.02 are shifted downward. Validation data are taken from [42].

Mean fluctuation profiles for coarse, medium, and fine computational grids

Figure 11. Results for the coarse, medium, and fine computational grids: mean fluctuation profiles of (a) streamwise component u′u′u'u' and (b) transverse component v′v′v'v' at downstream locations x/D=1.06x/D = 1.06, 1.541.54, and 2.022.02. For clarity, profiles at x/D=1.54x/D = 1.54 and 2.022.02 are shifted downward. Validation data are taken from Lehmkuhl et al. [42].

Comparing the different computational grids shows that the medium and fine grid produce equivalent results. In contrast, the coarse grid converges to a different solution for the pressure distribution in Figure 9a over the range 45∘<θ<90∘45^\circ< \theta< 90^\circ and across the fluctuation profiles in Figure 11, especially for ⟨v′v′⟩\langle v'v'\rangle at x/D=1.54x/D = 1.54. Therefore, the medium grid is selected, as it ensures mesh-independent results at a reduced cost relative to the fine grid.

An identical mesh convergence procedure is performed for the Re=1000Re = 1000 case using grids with 3.7M, 7.0M and 12.9M solution points (full domain, before solution box extraction; see Data processing in § 3). Due to the limited availability of reliable surface and wake validation data in the literature, detailed profile comparisons are omitted. Grid convergence is achieved on the finest mesh (12.9M points) and its statistics are compared with Jiang and Cheng [34]. The Strouhal number, drag coefficient and recirculation length presented in Figure 8 demonstrate a strong agreement. Furthermore, close agreement is found for the lift fluctuations and base pressure coefficient. The present study yields Cl,rms=0.097C_{l,\mathrm{rms}} = 0.097 and Cpb=−0.8388C_{pb} = -0.8388, compared to 0.100 and −0.8148-0.8148, respectively, reported by Jiang and Cheng [34].

The Power Spectral Density (PSD) of the stream-wise and cross-stream velocity is used to further characterize the unsteady dynamics of the wake for the Re=3900Re = 3900 case on the selected medium mesh. The PSD quantifies how the energy of velocity fluctuations is distributed across frequencies, thereby providing insight into dominant flow structures and their associated time scales. Figure 12 displays the PSD in the shear layer at (x/D,y/D)=(0.71,0.66)(x/D, y/D) = (0.71, 0.66), while Figure 13 shows the spectrum in the middle of the wake at (x/D,y/D)=(3.0,0.0)(x/D, y/D) = (3.0, 0.0). All subsequent discussions are based on the full spectrum result (blue line). The sub-sampled spectrum (orange line) is addressed separately in Appendix § 15, where the information loss caused by sub-sampling the solution, necessitated by storage constraints, is examined. Overall, the spectra are in good agreement with Lehmkuhl et al. [42]. The spectra exhibit the expected energy decay from low to high frequency scales, with an inertial range scaling in accordance with the theoretical −5/3-5/3 Kolmogorov law. Distinct peaks associated with characteristic flow phenomena are indicated in Figure 12. The vortex shedding peak at StvsSt_{vs} represents the periodic release of vortices from the cylinder surface, while Stsh=2StvsSt_{sh} = 2St_{vs} denotes the second harmonic of this process. Finally, the Kelvin-Helmholtz instability within the shear layer is observed at StKHSt_{KH}.

Figure 12. Comparison of velocity power spectra for (a) stream-wise and (b) cross-stream components at position (x/D,y/D)=(0.71,0.66)(x/D, y/D) = (0.71, 0.66). Spectra are shown for both the full temporal resolution and the sub-sampled resolution Δts\Delta t_s. The characteristic frequencies StvsSt_{vs}, StshSt_{sh}, and StKHSt_{KH} are annotated for reference alongside the theoretical −5/3-5/3 turbulence decay slope.

Figure 13. Comparison of velocity power spectra for (a) stream-wise and (b) cross-stream components at position (x/D,y/D)=(3.0,0.0)(x/D, y/D) = (3.0, 0.0). Spectra are shown for both the full temporal resolution and the sub-sampled resolution Δts\Delta t_s. The theoretical −5/3-5/3 turbulence decay slope is indicated for reference.

Elongated rectangle (a=2.5a = 2.5, n=∞n = \infty) at Re=3000Re = 3000

The simulation setup and selected meshing parameters are further evaluated using the Benchmark on the Aerodynamics of a Rectangular 5:1 Cylinder (BARC). The reference data for this case are taken from Cimarelli et al. [15], who performed DNS for this configuration. Although this specific rectangle is not included in the dataset, where elongations are restricted to a≤1.5a \le1.5, it provides a strict test case on the method’s ability to handle object elongations. In contrast to the circular cylinder, the sharp corners induce fixed separation points while the extended flat top and bottom surfaces offer insight into the simulation’s ability to capture near-wall dynamics. To this end, the mean and root-mean-square distributions of the surface pressure coefficient are presented in Figure 14, together with the skin friction coefficient, defined as Cf=τw/(12ρu∞2)C_f = \tau_w/(\frac{1}{2}\rho u_\infty^2), where τw=μ(∂u/∂y)wall\tau_w = \mu(\partial u/\partial y)_{\mathrm{wall}}. Overall, the profiles closely match with the DNS data, except for an under-prediction of the mean pressure over the first half of the rectangle. The mean pressure field in Figure 15b and streamlines of the time-averaged velocity in Figure 15a indicate this discrepancy is located in the region near the primary vortex and secondary vortex, for which the present simulations predict a more intense region of negative pressure. All other key phenomena, including the wake vortex, are accurately captured in both position and magnitude of the associated pressure field.

Comparison of mean pressure coefficient distribution, root-mean-square pressure coefficient fluctuations, and skin-friction coefficient

Figure 14. Comparison of (a) mean pressure coefficient distribution, (b) root-mean-square pressure coefficient fluctuations, and (c) skin-friction coefficient over the rectangle surface. Validation data are taken from Cimarelli et al. [15].

Comparison of the mean flow field above the rectangular surface

Figure 15. Comparison between the present study (top row) and Cimarelli et al. [15] (bottom row) of the mean flow field above the rectangular surface. Streamlines of the mean velocity field are shown in (a), and the mean pressure field in (b). In (a), green lines indicate the primary vortex, red lines the secondary vortex, and black lines the wake vortex.

Square rectangle (a=0.5a = 0.5, n=∞n = \infty) at Re=2000Re = 2000

To further assess the performance of the numerical setup in the wake of sharp-edged geometries, simulations are conducted for the square cylinder at Re=2000Re = 2000 and validated against experimental data from Sharma and Dutta (2022). Figure 16 provides a comparison of mean velocity and Reynolds stress profiles at various locations in the wake. Overall, the mean velocity deficit is accurately captured in the near wake and further downstream. A comparable agreement is observed for the Reynolds stresses close to the square. Notably, the simulation predicts a four-peak structure for ⟨u′v′⟩\langle u'v'\rangle at x/D=0.9075x/D = 0.9075. A comparable result is reported by Sharma and Dutta (2022) for a confined region around x/D≈0.85x/D \approx0.85, beyond which the Reynolds stresses transition to the two-peak structure observed in Figure 16b. The present results therefore reproduce the four-peak behavior, but its location is slightly shifted relative to the experiments. Finally, Reynolds stress profiles far downstream are accurately reproduced.

Figure 16. Mean velocity profiles in (a) from near to far downstream of the object, and Reynolds stress components: (b) u′v′u'v' close to the cylinder and (c) u′u′u'u' in the far wake region. Validation data are taken from Sharma and Dutta (2022).

Data Processing

After initialization, the simulation contains an unphysical numerical transient. To ensure the solution trajectories are unaffected by this startup phase, a numerical convergence criterion is applied following Boudet et al. [10]. Measurement probes are placed in regions where the flow exhibits low frequency dynamics. In the present study, they are located along the centerline (y/D=0y/D = 0) at streamwise distances 4D4D, 6.5D6.5D and 9.5D9.5D behind the object, denoted by P4P_4, P6.5P_{6.5} and P9.5P_{9.5}, respectively. These positions correspond to the wake region, which provides a consistent reference across all flow cases, whereas other regions of interest, such as the shear layer, change with geometry. Each probe measures a time-dependent signal, ϕ\phi. At time tt, the signal is cut into four equal segments. The final three segments are then compared using the following criterion:

χ(ϕ)=max⁡[max⁡i,j=2,4(∣ϕˉ(i)−ϕˉ(j)∣ϕˉ(4)),max⁡i,j=2,4(∣ϕ′(i)−ϕ′(j)∣ϕ′(4))].(9)\chi(\phi) = \max\left[ \max_{i,j=2,4} \left( \frac{\left|\bar{\phi}^{(i)}-\bar{\phi}^{(j)}\right|}{\bar{\phi}^{(4)}} \right), \max_{i,j=2,4} \left( \frac{\left|\phi'^{(i)}-\phi'^{(j)}\right|}{\phi'^{(4)}} \right) \right]. \tag*{(9)}

The superscripts indicate the temporal segment the data originates from, while ϕˉ\bar{\phi} and ϕ′\phi' represent the spanwise-averaged mean and standard deviation of the signal, respectively. Once χ\chi settles around a certain percentage, the flow’s statistics have stabilized over the three most recent temporal quarters, implying the numerical transient was evacuated after the first quarter. Nevertheless, data sampling starts only after the fourth quarter to provide an additional margin of confidence.

The convergence criterion method is initially evaluated after four flow-through times (FTTs) to ensure enough samples are collected for a reliable assessment. If the signal variations have not yet reached a steady level, the simulation is extended for one FTT at a time until they have. For illustration, Figure 17 displays the metric for the uu and vv velocity components for the [Re,α,a,n]=[1796,11,0.424,1][Re,\alpha,a,n] = [1796,11,0.424,1] case. Note that for the vertical velocity, only the standard deviation is considered, as its mean approaches zero, which would cause the criterion to diverge.

Figure 17. Numerical convergence criterion χ\chi for (a) streamwise and (b) vertical velocity at probes P4P_4, P6.5P_{6.5}, and P9.5P_{9.5} for the [Re,α,a,n]=[1796,11,0.424,1][Re,\alpha,a,n] = [1796,11,0.424,1] case. For vv, χ\chi is computed using standard deviation only. Stabilization indicates the evacuation of numerical transients and the onset of statistically steady flow.

Once the numerical transient has been evacuated, the solution fields are sampled at a non-dimensional time-step of Δts=0.04732\Delta t_s = 0.04732. While the solver requires much smaller temporal steps to maintain numerical stability and accuracy, saving the full resolution is computationally prohibitive due to storage requirements. Sub-sampling the simulation at a coarser time-step inevitably results in a loss of information. To quantify the extent of this loss, the energy spectrum is examined. Figure 12 and Figure 13 display the energy spectra for the circular cylinder flow case at Re=3900Re = 3900, evaluated at (x/D,y/D)=[(0.71,0.66),(3.0,0.0)](x/D,y/D) = [(0.71,0.66),(3.0,0.0)], computed using the original uu-velocity signal and the sub-sampled solution at Δts=0.04732\Delta t_s = 0.04732. The spectra match closely across most of the frequencies. In particular, all major characteristic frequencies are accurately recovered. Beyond the inertial subrange, however, the sub-sampled signal is unable to represent the highest frequencies due to its coarser temporal resolution. This is deemed acceptable as this portion of the spectrum is primarily influenced by numerical dissipation rather than physical processes and contains relatively low energy. Note that the sub-sampling acts in time only: each stored snapshot retains the full spatial resolution, so the small-scale spatial content scored by the spectral metric of § 5 is preserved in full.

Per-case wake-probe spectra. In addition to the convergence probes P4P_4, P6.5P_{6.5} and P9.5P_{9.5} described above, three further centerline probes, denoted P2.5′P'_{2.5}, P3.5′P'_{3.5} and P4.5′P'_{4.5}, are placed 2.5D2.5D, 3.5D3.5D and 4.5D4.5D behind the trailing edge of each object (y/D=0y/D = 0). The probes’ absolute location thus varies with aa, nn, and α\alpha across cases. A velocity power spectrum of uu and vv is computed at each probe for every one of the cases. of the 400 cases from the 400 saved snapshots of the sub-sampled trajectory (Δts\Delta t_s). The resulting spectra are released with each case in the public dataset, together with the script used to compute them. They provide per-case, physically grounded evidence of the turbulent energy cascade as well as an evaluation target for surrogate models beyond the aggregate metrics of § 5.

Dataset splits

TURTLES is split at the trajectory level into 320 training, 40 validation and 40 test trajectories (80/10/10) such that no trajectory is shared between subsets. Each shape family n∈{1,2,5,∞}n \in\{1, 2, 5, \infty\} contains 100 trajectories and is split exactly 80/10/10. Within each family, the assignment of trajectories to subsets is optimized so that the distribution of (Re⁡,α,log⁡a)(\operatorname{Re}, \alpha, \log a) in every subset matches that of the full dataset. This prevents a held-out set from concentrating in a corner of the parameter space, which at these subset sizes (40 trajectories) is otherwise likely. The circular-cylinder reference case (Re⁡=1000\operatorname{Re}=1000, a=0.5a=0.5, α=0∘\alpha=0^\circ, n=2n=2) is distributed separately and is not part of the split. The result is an in-distribution interpolation split. Extrapolation across geometry, Reynolds number or angle of attack is not assessed here, but is straightforward to construct from the released data: for example, by holding out an entire shape family, or all cases above a Reynolds-number threshold.

Table 4 reports the size and geometric composition of each subset, and Table 5 its coverage of the continuous parameters. The shape-family proportions of every subset are identical to those of the full dataset (25% each), and the statistics of Re⁡\operatorname{Re}, α\alpha and aa are likewise reproduced in each subset. Figure 18 visualizes the sampled parameter space color-coded by split.

SplitTrajectoriesFraction (%)n=1n=1n=2n=2n=5n=5n=∞n=\infty
Train32080.025.025.025.025.0
Validation4010.025.025.025.025.0
Test4010.025.025.025.025.0
All400100.025.025.025.025.0

Table 4. Size and geometric composition of the TURTLES train/validation/test split. Each subset reproduces the composition of the full dataset.

SplitRe⁡\operatorname{Re} [-] mean ±\pm stdRe⁡\operatorname{Re} [-] rangeα\alpha [deg] mean ±\pm stdα\alpha [deg] rangeaa [-] mean ±\pm stdaa [-] range
Train2456 ±\pm 839[1001, 3889]22.6 ±\pm 13.2[0, 45]0.603 ±\pm 0.365[0.167, 1.499]
Validation2434 ±\pm 847[1077, 3868]22.5 ±\pm 13.3[2, 45]0.614 ±\pm 0.393[0.172, 1.476]
Test2431 ±\pm 859[1089, 3832]22.4 ±\pm 13.3[0, 45]0.604 ±\pm 0.368[0.178, 1.399]
All2451 ±\pm 839[1001, 3889]22.5 ±\pm 13.2[0, 45]0.604 ±\pm 0.367[0.167, 1.499]

Table 5. Parameter coverage of each split. Entries report the mean ±\pm standard deviation and the [min, max] range of the Reynolds number Re⁡\operatorname{Re}, the angle of attack α\alpha, and the super-ellipse semi-axis parameter aa.

Figure 18. Coverage of the parameter space by the train/validation/test split. The first three panels show the sampled cases projected onto the (Re,α)(Re,\alpha), (Re,a)(Re,a) and (α,a)(\alpha,a) planes, with training cases in gray, validation cases as blue squares and test cases as red triangles. The right-most panel shows the fraction of each subset belonging to each shape family nn.

mini-TurtLES: standardized reduced-size subsets

The full dataset is 14 TB, which is prohibitive for many research groups. We therefore define mini-TurtLES, a collection of standardized subsets that reduce the dataset along two independent axes: geometry and time. Fixing the subset definitions ensures that experiments performed in different laboratories use identical data, facilitating reproducibility and fair comparison across published results.

Some storage floor is unavoidable: resolving three-dimensional turbulence requires dense meshes and a sampling interval fine enough to retain the inertial subrange, and reducing either removes the physical content that distinguishes TurtLES from existing benchmarks.

Geometry tiers (G4–G1). These tiers reduce the number of obstacle geometry families while retaining the full range of Reynolds numbers (ReRe), angles of attack (α\alpha), and the geometric semi-axis parameter (aa). G4 contains all four families n∈{1,2,5,∞}n \in\{1,2,5,\infty\}; G3 removes the n=5n = 5 family; G2 further removes n=1n = 1; and G1 retains only the elliptical family (n=2n = 2). Each tier therefore covers the same physical parameter space with progressively fewer geometries. The ordering follows increasing simplicity while preserving representative flow behavior: n=5n = 5 is removed first because it exhibits the least distinctive dynamics, whereas n=2n = 2 is retained in every tier because it is the best-studied and most widely used benchmark geometry.

Temporal tiers (T100–T400). These tiers retain only the first 100, 200, 300, or 400 snapshots of each trajectory. The geometry and temporal tiers are independent and can be combined freely (e.g. G2-T200 or G1-T400). Table 6 reports the approximate download size of each subset.

Geometry tierFamilies nnT100T200T300T400
G4{1,2,5,∞}\{1,2,5,\infty\}3.5 TB7.0 TB10.5 TB14 TB
G3{1,2,∞}\{1,2,\infty\}2.6 TB5.1 TB7.7 TB10.2 TB
G2{2,∞}\{2,\infty\}1.8 TB3.6 TB5.3 TB7.1 TB
G1{2}\{2\}0.8 TB1.6 TB2.4 TB3.3 TB

Table 6. Approximate download size of each MINI-TURTLES subset. Geometry tiers reduce the number of shape families; temporal tiers truncate each trajectory.

Debug subset. We further provide TURTLES-DEBUG (approximately 5 GB), containing the first 100 snapshots of the circular-cylinder reference case (Re=1000Re = 1000, a=0.5a = 0.5, α=0∘\alpha= 0^\circ, n=2n = 2), which is distributed separately from the 400-case split. It is intended for installation checks and dataloader validation.

Retrieval. All subsets have fixed names and are described on the dataset page, which details each tier and explains the procedure for downloading it.

Data visualizations

To visualize the flows in TURTLES, Figure 19 shows the instantaneous vortical structures of eight cases. For each shape family, one case is shown at low (Re≤1300Re \le1300) and one at high Reynolds number (Re>3000Re > 3000). Note that at low ReRe the wake consists of fewer, thicker and more coherent vortex tubes, whereas at high ReRe it breaks up into a much denser field of fine-scale structures.

Figure 19. Visualization of eight TURTLES cases. For each case, 3D, side and top views show isosurfaces of the Q-criterion [30] (Q∗=QD2/U∞2=1Q^* = QD^2/U_\infty^2 = 1) at an instantaneous snapshot, colored by the non-dimensional velocity magnitude ∥U∥/U∞\lVert\mathbf{U}\rVert/U_\infty.

Baseline implementations

This section documents the architectures, hyperparameters, and training recipes used for the four neural-operator baselines reported in § 5. We first describe the components shared across baselines, then provide a per-model architectural summary. A consolidated view of the hyperparameters appears in Table 7.

HyperparameterUPTGINOTransolver++CALM-PDE
Trainable parameters61.96 M3.10 M21.79 M45.14 M
Hidden dim38464 (FNO)512384
Heads6–86
MLP ratio4–44
Depth2/4/2 (enc/lat/dec)4 (FNO)88
Tokens / latent gridK=16,384K=16{,}384, L=4,096L=4{,}09612312^3128 slices163=4,09616^3=4{,}096
kk-NN kk32––32
ConditioningadaLN-zero (ReRe)AdaIN (ReRe)additive bias (ReRe)adaLN-zero (ReRe)
Activation checkpointingyes–yesyes
Mixed precision (bf16)yesnoyesyes
torch.compileyesnoyesno
Steps100,000
OptimizerAdamW (β1=0.9\beta_1=0.9, β2=0.95\beta_2=0.95, wd=10−3\mathrm{wd}=10^{-3})
Learning rate10−4→10−710^{-4}\rightarrow10^{-7}, cosine, 5,000 linear warmup
Effective batch size2 (GINO: bs=1, accum=2)
Subsampled nodes / step524,288
Hardware1 × NVIDIA H100 80 GB, ∼\sim20 h wall time

Table 7. Summary of baseline hyperparameters. Counts are per model.

Shared training and inference setup. All baselines are trained on the same temporal task: predict the residual Δut+1=ut+1−ut\Delta u_{t+1} = u_{t+1} - u_t from a single context frame utu_t, conditioned on the Reynolds number ReRe. Training uses a standard mean-squared-error loss on the residual. We sample one window per gradient step from a uniform-random subset of 524,288 mesh nodes per trajectory, repeated for 100,000 gradient steps with an effective batch size of 2 on a single H100 GPU (80 GB). All four baselines are trained on the 320 training trajectories and evaluated on the 40 test trajectories of the split defined in Appendix § 16. The optimizer is AdamW with learning rate 10−410^{-4}, minimum learning rate 10−710^{-7}, weight decay 10−310^{-3}, β1=0.9\beta_1 = 0.9, β2=0.95\beta_2 = 0.95, and gradient-norm clipping at 1.0. The schedule is a linear warmup over the first 5,000 steps followed by a cosine decay. PDE-parameter conditioning uses only ReRe; geometry parameters (α\alpha, aa, nn) are not exposed to the model and are absorbed into the spatial coordinates and field statistics. For all models except GINO we enable bfloat16 mixed precision and torch.compile. GINO’s FNO backbone relies on complex-valued spectral convolutions that interact poorly with bfloat16 autocast and produce graph-breaking warnings under torch.compile via the neuraloperator/tltorch factorized-tensor indexing path. We therefore train GINO in fp32 without torch.compile, with a per-GPU batch size of one and gradient accumulation of two to keep the effective batch size at two. Activation checkpointing is enabled for all transformer backbones. Apart from the precision and gradient-accumulation adjustments required by GINO, all four baselines follow an identical protocol: the same residual objective, the same node subsample per gradient step, and the same optimizer, schedule, step count, effective batch size and single-GPU budget. No baseline received additional hyperparameter tuning. At inference time we use a batch size of one and a context window of one frame. The full mesh (2.9–10.5 million nodes per trajectory) is processed either by the model’s encoder–decoder split (UPT, GINO, CALM-PDE) or by tile partition (Transolver++) with a chunk size of 524,288 output points. Each test trajectory is unrolled for 399 autoregressive steps starting from the first ground-truth frame.

UPT ([2]). UPT is a perceiver-style transformer for unstructured meshes. The mesh is first pooled to K=16,384K = 16{,}384 supernodes via a runtime kk-nearest-neighbor gather (k=32k = 32) and a small message-passing MLP. Two encoder transformer blocks then operate on the supernode tokens. A perceiver cross-attention compresses the supernodes to L=4,096L = 4{,}096 learned latent tokens, on top of which we run four self-attention blocks. Two more transformer blocks act on the decoder side before a perceiver cross-attention queries the original mesh coordinates with sincos positional embeddings (max angular frequency 100) and produces the per-node residual. The hidden dimension is 384 with 6 attention heads, an MLP expansion ratio of 4, no dropout, and DiT-style adaLN-zero conditioning on ReRe. The trained model has 61.96 M parameters.

GINO ([43]). GINO consists of a graph-neural-operator (GNO) encoder that maps the irregular mesh onto a regular latent grid, an FNO operating on that grid, and a GNO decoder that queries the predicted residual at the original mesh nodes. The latent grid has resolution 12312^3 in [0,1]3[0, 1]^3, with input coordinates min–max normalized to that cube. Both GNOs use a linear transform with neighborhood radius 0.033 (about one cell at this resolution). The FNO has four spectral layers, 6×6×66 \times6 \times6 Fourier modes, 64 hidden channels, and lifting/projection MLPs with channel ratios of 2 and 4 respectively. PDE-parameter conditioning is realized through an AdaIN layer (4 conditioning features). We use the official neuraloperator implementation with Open3D-accelerated GNO kernels ([40]). The trained model has 3.10 M parameters. This size reflects the shared training budget rather than a tuned choice. GINO is by some margin the slowest baseline per gradient step, because the complex-valued spectral convolutions of its FNO backbone preclude bfloat16 autocast and torch.compile and therefore run in fp32 with gradient accumulation. Within the shared budget of 100,000 steps (∼20 h on a single H100) the model had not converged even at 3.10 M parameters, and larger configurations were less accurate for the same wall-clock time. The reported configuration is therefore the best achievable under the shared budget.

Transolver++ (Luo et al., 2025). Transolver++ is a monolithic transformer that aggregates NN spatial tokens into a small set of learned physics-aware slices via Gumbel-softmax routing, applies self-attention on the slice tokens, then scatters back to the mesh. We use 8 transformer blocks with hidden dimension 512, 8 attention heads, MLP ratio 4, 128 slices per head, GELU activation, and no dropout. PDE-parameter conditioning is an additive bias on the encoder output. Because Transolver++ is monolithic, with input and output cardinality equal by construction, partitioning the output necessarily partitions the input as well; there is no latent bottleneck at which the two can be split. Its inference path therefore uses a tile partition rather than an encoder–decoder split: disjoint chunks of the mesh are processed independently, which bounds memory but removes cross-chunk context. This is a consequence of the architecture at this mesh size. The trained model has 21.79 M parameters. Transolver++ was developed for steady-state prediction rather than autoregressive dynamics. We include it because it represents the current state of the art for PDE surrogates on million-point geometries, which is one of the defining constraints of this dataset.

CALM-PDE [23, 38]. We adopt the continuous-convolution encoder/decoder of CALM-PDE combined with the scaling improvements introduced in ECHO; the implementation is registered as CALM-PDE in our codebase. The encoder uses a continuous convolution with k=32k=32 neighbors and a 64-wide kernel MLP to lift features from the irregular mesh to a fixed 163=4,09616^3 = 4{,}096-point regular latent grid in [0,1]3[0,1]^3, with global coordinate bounds computed once over the 320 training trajectories so that the latent grid is shared across batches. A UPT-style transformer with hidden dimension 384, 6 heads, MLP ratio 4, and 8 blocks acts as the time-stepping operator on the latent tokens, conditioned on ReRe via DiT adaLN-zero. The continuous convolution decoder maps the post-transformer latent back to the original mesh nodes, with output queries chunked at 32,768 points to bound peak memory. The trained model has 45.14 M parameters.

References

  1. [1]James Ahrens, Berk Geveci, and Charles Law. ParaView: An end-user tool for large data visualization. In Visualization Handbook. Elsevier, 2005. ISBN 978-0123875822.DOI
  2. [2]Benedikt Alkin, Andreas Fürst, Simon Schmid, Lukas Gruber, Markus Holzleitner, and Johannes Brandstetter. Universal Physics Transformers. In Advances in Neural Information Processing Systems, 2024.arxiv.org/abs/2402.12365
  3. [3]Kelsey R. Allen, Tatiana Lopez-Guevara, Kimberly Stachenfeld, Alvaro Sanchez-Gonzalez, Peter Battaglia, Jessica Hamrick, and Tobias Pfaff. Inverse design for fluid-structure interactions using graph network simulators. In Advances in Neural Information Processing Systems, volume 35, pages 13759–13774, 2022.DOI
  4. [4]William F. Ames. Numerical Methods for Partial Differential Equations. Academic Press, 3 edition, 1992.
  5. [5]Jason Ansel, Edward Yang, Horace He, Natalia Gimelshein, Animesh Jain, Michael Voznesensky, Bin Bao, Peter Bell, David Berard, Evgeni Burovski, Geeta Chauhan, Anjali Chourdia, Will Constable, Alban Desmaison, Zachary DeVito, Elias Ellison, Will Feng, Jiong Gong, Michael Gschwind, Brian Hirsh, Sherlock Huang, Kshiteej Kalambarkar, Laurent Kirsch, Michael Lazos, Mario Lezcano, Yanbo Liang, Jason Liang, Yinghai Lu, CK Luk, Bert Maher, Yunjie Pan, Christian Pührsch, Matthias Reso, Mark Saroufim, Marcos Yukio Siraichi, Helen Suk, Michael Suo, Phil Tillet, Eikan Wang, Xiaodong Wang, William Wen, Shunting Zhang, Xu Zhao, Keren Zhou, Richard Zou, Ajit Mathews, Gregory Chanan, Peng Wu, and Soumith Chintala. PyTorch 2: Faster Machine Learning Through Dynamic Python Bytecode Transformation and Graph Compilation. In 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2 (ASPLOS ’24). ACM, April 2024. doi: 10.1145/3620665.3640366.DOI
  6. [7]Neil Ashton, Danielle C. Maddix, Samuel Gundry, and Parisa M. Shabestari. AhmedML: High-fidelity computational fluid dynamics dataset for incompressible, low-speed bluff body aerodynamics. arXiv preprint arXiv:2407.20801, 2024b.arxiv.org/abs/2407.20801
  7. [8]H. Bai and M. M. Alam. Dependence of square cylinder wake on Reynolds number. Physics of Fluids, 30(1):015102, 2018. ISSN 1070-6631. doi: 10.1063/1.4996945.DOI
  8. [9]Florent Bonnet, Ahmed Jocelyn Mazari, Paola Cinnella, and Patrick Gallinari. AirfRANS: High fidelity computational fluid dynamics dataset for approximating Reynolds-averaged Navier–Stokes solutions. In Advances in Neural Information Processing Systems, Datasets and Benchmarks Track, volume 35, 2022.arxiv.org/abs/2212.07564
  9. [10]J. Boudet, J.-F. Monier, and F. Gao. Implementation of a roughness element to trip transition in large-eddy simulation. Journal of Thermal Science, 24(1):30–36, 02 2015. ISSN 1993-033X. doi: 10.1007/s11630-015-0752-8.DOI
  10. [11]Johannes Brandstetter, Daniel E. Worrall, and Max Welling. Message passing neural PDE solvers. In International Conference on Learning Representations, 2022.arxiv.org/abs/2202.03376
  11. [13]Steven L. Brunton and J. Nathan Kutz. Data-Driven Science and Engineering: Machine Learning, Dynamical Systems, and Control. Cambridge University Press, Cambridge, 2 edition, 2022.
  12. [14]Wai Tong Chung, Bassem Akoush, Pushan Sharma, Alex Tamkin, Ki Sung Jung, Jacqueline H. Chen, Jack Guo, Davy Brouzet, Mohsen Talei, Bruno Savard, Alexei Y. Poludnenko, and Matthias Ihme. Turbulence in focus: Benchmarking scaling behavior of 3D volumetric super-resolution with BLASTNet 2.0 data. In Advances in Neural Information Processing Systems, Datasets and Benchmarks Track, volume 36, 2023.
  13. [15]Andrea Cimarelli, Adriano Leonforte, and Diego Angeli. Direct numerical simulation of the flow around a rectangular cylinder at a moderately high Reynolds number. Journal of Wind Engineering and Industrial Aerodynamics, 174:39–49, March 2018. doi: 10.1016/j.jweia.2017.12.020.DOI
  14. [17]Emmanuel de Bézenac, Arthur Pajot, and Patrick Gallinari. Deep learning for physical processes: Incorporating prior scientific knowledge. In International Conference on Learning Representations, 2018.arxiv.org/abs/1711.07970
  15. [18]Mohamed Elrefaie, Florin Morar, Angela Dai, and Faez Ahmed. DrivArNet++: A large-scale multi-modal car dataset with computational fluid dynamics simulations and deep learning benchmarks. In Advances in Neural Information Processing Systems, Datasets and Benchmarks Track, volume 37, 2024.
  16. [19]Mike Folk, Gerd Heber, Quincey Koziol, Elena Pourmal, and Dana Robinson. An overview of the HDF5 technology suite and its applications. In Proceedings of the EDBT/ICDT 2011 Workshop on Array Databases, pages 36–47. ACM, 2011. doi: 10.1145/1966895.1966900.DOI
  17. [20]Christophe Geuzaine and Jean-François Remacle. Gmsh: A 3-D finite element mesh generator with built-in pre- and post-processing facilities. International Journal for Numerical Methods in Engineering, 79(11):1309–1331, 09 2009. doi: 10.1002/nme.2579.DOI
  18. [21]Sandip Ghosal. An analysis of numerical errors in large-eddy simulations of turbulence. Journal of Computational Physics, 125(1):187–206, 1996. ISSN 0021-9991. doi: 10.1006/jcph.1996.0088.DOI
  19. [22]Gaurav Gupta, Xiongye Xiao, and Paul Bogdan. Multiwavelet-based operator learning for differential equations. Advances in neural information processing systems, 34:24048–24062, 2021.arxiv.org/abs/2109.13459
  20. [23]Jan Hagnberger, Daniel Musekamp, and Mathias Niepert. CALM-PDE: Continuous and adaptive convolutions for latent space modeling of time-dependent PDEs. In The Thirty-ninth Annual Conference on Neural Information Processing Systems, 2025.arxiv.org/abs/2505.12944
  21. [24]Xu Han, Han Gao, Tobias Pfaff, Jian-Xun Wang, and Li-Ping Liu. Predicting physics in mesh-reduced space with temporal attention. In International Conference on Learning Representations, 2022.arxiv.org/abs/2201.09113
  22. [25]Zhongkai Hao, Zhengyi Wang, Hang Su, Chengyang Ying, Yinpeng Dong, Songming Liu, Ze Cheng, Jian Song, and Jun Zhu. GNOT: A general neural operator transformer for operator learning. In International Conference on Machine Learning, pages 12556–12569. PMLR, 2023.arxiv.org/abs/2302.14376
  23. [26]Sheikh Md Shakeel Hassan, Arthur Feeney, Akash Dhruv, Jihoon Kim, Youngjoon Suh, Jaiyoung Ryu, Yoonjin Won, and Aparna Chandramowlishwaran. BubbleML: A multiphase multiphysics dataset and benchmarks for machine learning. In Advances in Neural Information Processing Systems, Datasets and Benchmarks Track, volume 36, 2023.DOI
  24. [27]Peiyan Hu, Haodong Feng, Hongyuan Liu, Tongtong Yan, Wenhao Deng, Tianrun Gao, Rong Zheng, Haoren Zheng, Chenglei Yu, Chunrui Wang, Kaiwen Li, Zhi-Ming Ma, Dezhi Zhou, Xingcai Lu, Dixia Fan, and Tailin Wu. RealPDEBench: A benchmark for complex physical systems with real-world data. In The Fourteenth International Conference on Learning Representations, 2026. Oral Presentation.arxiv.org/abs/2601.01829
  25. [28]Cheng Huang, Karthik Duraisamy, and Charles L. Merkle. Investigations and improvement of robustness of reduced-order models of reacting flow. AIAA Journal, 57(12):5377–5389, 2019. doi: 10.2514/1.J058392.DOI
  26. [29]Xiang Huang, Zhanhong Ye, Hongsheng Liu, Shi Bei Ji, Zidong Wang, Kang Yang, Yang Li, Min Wang, Haotian CHU, Fan Yu, Bei Hua, Lei Chen, and Bin Dong. Meta-auto-decoder for solving parametric partial differential equations. In Alice H. Oh, Alekh Agarwal, Danielle Belgrave, and Kyunghyun Cho, editors, Advances in Neural Information Processing Systems, 2022.arxiv.org/abs/2111.08823
  27. [30]J. C. R. Hunt, A. A. Wray, and P. Moin. Eddies, streams, and convergence zones in turbulent flows. In Proceedings of the Summer Program, pages 193–208. Center for Turbulence Research, Stanford University, 1988.
  28. [31]H. T. Huynh. A flux reconstruction approach to high-order schemes including discontinuous Galerkin methods. In 18th AIAA Computational Fluid Dynamics Conference, Miami, FL, June 2007. doi: 10.2514/6.2007-4079. AIAA Paper 2007-4079.DOI
  29. [32]Jakob Jakob, Markus Gross, and Tobias Günther. A fluid flow data set for machine learning and its application to neural flow map interpolation. IEEE Transactions on Visualization and Computer Graphics, 27(2):1279–1289, 2021. doi: 10.1109/TVCG.2020.3028947.DOI
  30. [33]Steeven Janny, Aurélien Béneteau, Madiha Nadri, Julie Digne, Nicolas Thome, and Christian Wolf. EAGLE: Large-scale learning of turbulent fluid dynamics with mesh transformers. In International Conference on Learning Representations, 2023.arxiv.org/abs/2302.10803
  31. [34]Hongyi Jiang and Liang Cheng. Strouhal–Reynolds number relationship for flow past a circular cylinder. Journal of Fluid Mechanics, 832:170–188, 2017. doi: 10.1017/jfm.2017.685.DOI
  32. [35]Rohit Sunil Kanchi, Benjamin Melanson, Nithin Somasekharan, Shaowu Pan, and Sicheng He. UniFoil: A universal dataset of airfoils in transitional and turbulent regimes for subsonic and transonic flows. In Advances in Neural Information Processing Systems, Datasets and Benchmarks Track, volume 38, 2025.arxiv.org/abs/2505.21124
  33. [36]Armand Kassaï Koupai, Jorge Mifsut Benet, Yuan Yin, Jean-Noël Vittaut, and Patrick Gallinari. GEPS: Boosting generalization in parametric PDE neural solvers through adaptive conditioning. In Advances in Neural Information Processing Systems, volume 37, 2024.
  34. [37]Armand Kassaï Koupai, Lise Le Boudec, Louis Serrano, and Patrick Gallinari. ENMA: Tokenwise autoregression for continuous neural PDE operators. In Advances in Neural Information Processing Systems, volume 38, 2025.DOI
  35. [38]Armand Kassaï Koupai, Lise Le Boudec, and Patrick Gallinari. Efficient generative transformer operators for million-point PDEs. In Advances in Neural Information Processing Systems, volume 39, 2026.arxiv.org/abs/2512.04974
  36. [39]Felix Koehler, Simon Niedermayr, Rüdiger Westermann, and Nils Thuerey. APEBench: A benchmark for autoregressive neural emulators of PDEs. In Advances in Neural Information Processing Systems, Datasets and Benchmarks Track, volume 37, 2024.DOI
  37. [40]Jean Kossaïfi, Nikola Kovachki, Zongyi Li, David Pitt, Miguel Liu-Schiaffini, Robert Joseph George, Boris Bonev, Kamyar Azizzadenesheli, Julius Berner, Valentin Duruissaux, and Anima Anandkumar. A library for learning neural operators. Journal of Machine Learning Research, 27(205):1–6, 2026.
  38. [41]Remi Lam, Alvaro Sanchez-Gonzalez, Matthew Willson, Peter Wirnsberger, Meire Fortunato, Ferran Ale t, Suman Ravuri, Timo Ewalds, Zach Eaton-Rosen, Weihua Hu, Alexander Merose, Stephan Hoyer, George Holland, Oriol Vinyals, Jacklynn Stott, Alexander Pritzel, Shakir Mohamed, and Peter Battaglia. Learning skillful medium-range global weather forecasting. Science, 382(6677):1416–1421, 2023. doi: 10.1126/science.adi2336.DOI
  39. [42]O. Lehmkuhl, I. Rodríguez, R. Borrell, and A. Oliva. Low-frequency unsteadiness in the vortex formation region of a circular cylinder. Physics of Fluids, 25(8):085109, August 2013. ISSN 1070-6631. doi: 10.1063/1.4818641.DOI
  40. [43]Zijie Li, Kazem Meidani, and Amir Barati Farimani. Transformer for partial differential equations’ operator learning. Transactions on Machine Learning Research, 2023a. ISSN 2835-8856.arxiv.org/abs/2205.13671
  41. [44]Zijie Li, Anthony Zhou, and Amir Barati Farimani. Generative latent neural PDE solver using flow matching. Machine Learning: Science and Technology, 7(3):035021, 2026. doi: 10.1088/2632-2153/ae64aa.DOI

Paper details

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

views · 5

downloads · 0

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

  • Physics and Astronomy

Not recorded for this paper

View statement
Looking for related papers…
Contents