|
Download README.md from nvidia/AeroZoo: direct link, hf CLI and curl.
- Browser
- Download file 43.5 kB
-
https://huggingface.co/datasets/nvidia/AeroZoo/resolve/main/README.md
- Command line
-
hf download hf://datasets/nvidia/AeroZoo/README.md
-
curl -L -o README.md https://huggingface.co/datasets/nvidia/AeroZoo/resolve/main/README.md
43.5 kB
| pretty_name: AeroZoo v1.2 | |
| viewer: false | |
| license: cc-by-4.0 | |
| tags: | |
| - cfd | |
| - computational-fluid-dynamics | |
| - rans | |
| - openfoam | |
| - physicsnemo | |
| - aerodynamics | |
| - mesh | |
| - point-cloud | |
| - physics-ai | |
| - arxiv:2611.17152 | |
| size_categories: | |
| - 1K<n<10K | |
| task_categories: | |
| - other | |
| # AeroZoo v1.2 | |
| <p align="center"> | |
| <img src="assets/zoo.png" alt="Velocity slices across AeroZoo's seven geometry families and eight enclosure configurations" width="100%"/> | |
| </p> | |
| Most 3D aerodynamics datasets vary a single parametric shape family inside one | |
| fixed wind tunnel, allowing surrogate models to memorize coordinate-to-field | |
| shortcuts instead of solving boundary-value problems or generalizing out of | |
| distribution. **AeroZoo** poses 3,816 distinct 3D incompressible flow problems | |
| across Reynolds numbers from \\(10^3\\) to \\(10^8\\), solved with unsteady | |
| RANS (Langtry–Menter transition SST in OpenFOAM 14) and time-averaged over a | |
| fixed convective window. | |
| <p align="center"> | |
| <img src="assets/posing.png" alt="One car geometry placed inside four different box enclosures at the same reference speed and Reynolds number, producing four distinct velocity fields and force coefficients" width="660"/> | |
| </p> | |
| <p align="center"><em>One geometry, four boundary-value problems: placing the same car at the same reference speed and Reynolds number into four enclosures shifts axial force from C<sub>x</sub> = 0.025–0.029 to 0.554 and vertical force from near zero to C<sub>z</sub> = +1.066.</em></p> | |
| Every sample is stored in dimensional SI units as a PhysicsNeMo `DomainMesh` | |
| (a memory-mapped PyTorch `TensorDict` tree) that bundles the posed | |
| boundary-value problem with its time-mean solution across: | |
| - **Seven geometry families:** Blobs, Blender bluff, Procedural cars, | |
| Zero-to-CAD, Airframe Foundry, Streamlined, and Blender streamlined (plus one | |
| mascot sample outside every split). | |
| - **Eight enclosure configurations** across four enclosure families: | |
| rectangular boxes with five boundary layouts (open, ground-effect, confined, | |
| crossflow, and dual-inlet), opposed inlet/outlet spheres, symmetry | |
| hemispheres, and internal ducts (with or without an internal body). | |
| - **Three body-wall layouts:** all no-slip, two contiguous slip/no-slip bands, | |
| or three bands. | |
| **v1.2 is the official release**, exported 2026-10-08 from a population frozen | |
| on 2026-10-02. Authors: Peter | |
| Sharpe\*, Carmelo Gonzales\*, Corey Adams, Mehdi Ataei, and Sanjay Choudhry | |
| (NVIDIA; \*lead authors). | |
| ## Links | |
| - This dataset: <https://huggingface.co/datasets/nvidia/AeroZoo> | |
| - PhysicsNeMo (`DomainMesh`): <https://github.com/NVIDIA/physicsnemo> | |
| - The AeroZoo paper: <https://arxiv.org/abs/2611.17152> | |
| ## Visual Overview | |
| Every body stores time-averaged pressure on its remeshed boundary triangles | |
| (`no_slip` and `slip`) and wall shear stress on `no_slip`, spanning high-genus | |
| organic blobs, bluff shapes, procedural cars, CAD parts, aircraft, streamlined | |
| bodies, wings, and the mascot: | |
| <p align="center"> | |
| <img src="assets/surfaces.png" alt="3D surface renders of pressure coefficient and skin-friction coefficient across all seven geometry families and the mascot, showing slip bands in gray" width="100%"/> | |
| </p> | |
| At matched sample counts, AeroZoo's seven geometry families span 25 to 390 | |
| effectively distinct shapes out of 400 under the Vendi diversity score | |
| (compared with 13 for DrivAerML and 11 for SHIFT-SUV at 400 shapes, and 7 out | |
| of 126 for HiLiftAeroML). Across five decades of Reynolds number, boundary | |
| layers transition from fully laminar near \\(Re \approx 10^3\\) (tracking | |
| Blasius flat-plate friction) through transitional turbulent wedges near | |
| \\(Re \approx 10^5\\) to fully turbulent at \\(Re \ge 10^6\\) (tracking Prandtl | |
| turbulent friction): | |
| <p align="center"> | |
| <img src="assets/diversity-and-regimes.png" alt="Vendi shape diversity across AeroZoo geometry families compared with single-family datasets, alongside boundary-layer laminar fraction and skin-friction coefficient across five decades of Reynolds number" width="100%"/> | |
| </p> | |
| <p align="center"> | |
| <img src="assets/transition-ladder.png" alt="Five streamlined bodies from Re = 8.0e3 to Re = 3.7e7 colored by first-cell intermittency, showing laminar-to-turbulent transition" width="100%"/> | |
| </p> | |
| Alongside external enclosures, 303 released internal-duct samples span 10 | |
| passage geometries (161 body-free ducts and 142 ducts containing an internal | |
| body): | |
| <p align="center"> | |
| <img src="assets/ducts.png" alt="Mean velocity slices through one body-free internal-duct sample of each of the 10 passage geometries in AeroZoo" width="100%"/> | |
| </p> | |
| ## Contents | |
| | Quantity | Value | | |
| |:---|:---| | |
| | Released samples | 3,816 (3,815 in splits + one mascot outside every split) | | |
| | Stability labels | 2,817 `mean_stable` / 999 `mean_unstable` (canonical benchmark uses `mean_stable`) | | |
| | Interior query points | 23.8 billion total; median 5.0M cells per sample (range 0.6M–24M) | | |
| | Total storage | 1.48 TB in uncompressed tars; median 347 MB per sample | | |
| | Benchmark splits and tasks | 22 frozen train / validation / test splits; two tasks (interior and boundary) | | |
| ```text | |
| README.md this card | |
| LICENSE the dataset license | |
| NOTICE third-party credits and terms: Zero-to-CAD 100K | |
| (Apache License 2.0) and UIUC Airfoil Coordinates Database | |
| zero-to-cad-provenance.csv one row per Zero-to-CAD body in a sample: the | |
| part, its source revision, and NVIDIA's changes to it | |
| assets/ dataset overview and sample-anatomy figures | |
| index.json one record per released sample: identity, hashes, stability label, | |
| quality diagnostics, and export lineage | |
| release-v1.2.json release manifest: status per planned case (complete / failed / | |
| timed_out), planned and released sizes per split part, and SHA-256 | |
| digests of index.json and the split files | |
| splits/cases.json planned population: geometry family (`bank`), enclosure family, | |
| box layout (`profile`), body-wall layout, Reynolds decade, source | |
| geometry hash, and split placement per case | |
| splits/splits.json 22 named splits as "<split>_<part>" -> [case_id, ...] | |
| splits/body-free-ducts.json the 219 internal-duct case IDs posed without an internal body | |
| splits/splits-metadata.json placement scheme (geometry hash) and design seed (note: `full` is | |
| unstratified despite its description string here) | |
| checksums.sha256 SHA-256 of every sample tar | |
| SHA256SUMS SHA-256 of every data file of the unpacked release (see Verifying a copy) | |
| samples/shard-NNN/<case_id>.tar one uncompressed tar per sample (shards are administrative only) | |
| ``` | |
| Each sample tar unpacks to one directory: | |
| ```text | |
| <case_id>/ | |
| domain.pdmsh/ PhysicsNeMo DomainMesh (memory-mapped TensorDict tree, schema 5) | |
| domain.pdmsh.validated.json reload-validation receipt of the artifact | |
| reexport-lineage.json validated solver attempt and exporter provenance | |
| smoke-audit.json structural audit of the exported artifact | |
| case-manifest.json the posed boundary-value problem | |
| status.json execution outcome and attempt history | |
| result.yaml solver summary: termination, cell count, and stability | |
| ``` | |
| ## Loading a sample | |
| Install PhysicsNeMo (`>=2.1.0` for `DomainMesh`, Python `>=3.11`) and the | |
| Hugging Face client: | |
| ```bash | |
| pip install "nvidia-physicsnemo>=2.1.0" "huggingface_hub>=1.7.1" | |
| ``` | |
| Load one sample lazily via memory mapping (tensors are read on first access): | |
| ```python | |
| import json, tarfile | |
| from pathlib import Path | |
| from huggingface_hub import hf_hub_download | |
| from physicsnemo.mesh import DomainMesh | |
| repo = "nvidia/AeroZoo" | |
| index = json.loads(Path(hf_hub_download(repo, "index.json", repo_type="dataset")).read_text()) | |
| case_id, record = next(iter(index["samples"].items())) | |
| tar_path = hf_hub_download(repo, f"samples/shard-{record['shard']:03d}/{case_id}.tar", repo_type="dataset") | |
| with tarfile.open(tar_path) as tar: | |
| tar.extractall(Path("aerozoo"), filter="data") | |
| sample = DomainMesh.load(Path("aerozoo") / case_id / "domain.pdmsh") | |
| interior = sample.interior # one point per finite-volume cell centroid | |
| x = interior.points # [N, 3] meters, query coordinates | |
| u_mean = interior.point_data["solution", "velocity"] # [N, 3] m/s, a target | |
| volume = interior.point_data["_target_quadrature_measure"] # [N] m^3, loss and metric weight | |
| inlet = sample.boundaries["inlet"] # triangle mesh; prescribed/* are inputs | |
| u_in = inlet.cell_data["prescribed", "dirichlet", "velocity"] # [F, 3] m/s | |
| nu = sample.global_data["physics", "kinematic_viscosity"] # () m^2/s, an input | |
| stable = sample.global_data["diagnostics", "solve", "mean_window", "stability_pass"] # () bool; True iff mean_stable | |
| ``` | |
| To download a specific split in parallel without duplicating tars in the global | |
| cache (for example `super_scarce_train`, 53 canonical samples, ~18 GB): | |
| ```python | |
| import json | |
| from pathlib import Path | |
| from huggingface_hub import hf_hub_download, snapshot_download | |
| repo = "nvidia/AeroZoo" | |
| index = json.loads(Path(hf_hub_download(repo, "index.json", repo_type="dataset")).read_text())["samples"] | |
| splits = json.loads(Path(hf_hub_download(repo, "splits/splits.json", repo_type="dataset")).read_text()) | |
| patterns = [ | |
| f"samples/shard-{index[c]['shard']:03d}/{c}.tar" | |
| for c in splits["super_scarce_train"] | |
| if c in index and index[c]["quality"]["solution_quality"] == "mean_stable" | |
| ] | |
| snapshot_download(repo, repo_type="dataset", allow_patterns=patterns, local_dir="aerozoo-raw", max_workers=8) | |
| ``` | |
| <p align="center"> | |
| <img src="assets/anatomy.png" alt="Anatomy of an AeroZoo DomainMesh sample: an aircraft with slip and no-slip bands inside a ground-effect box with inlet, outlet, slip, and no-slip boundary meshes and interior query points" width="520"/> | |
| </p> | |
| All physical quantities use dimensional SI units. Nested `TensorDict` keys are | |
| indexed in Python with string tuples (for example | |
| `cell_data["prescribed", "dirichlet", "velocity"]`). A sample contains three | |
| top-level groups (example dimensions shown for a 4.55M-cell aircraft sample): | |
| ```text | |
| DomainMesh | |
| |-- interior (Mesh: point cloud of cell centroids, no interior connectivity) | |
| | |-- points [4550479, 3] float32 m | |
| | |-- cells [0, 1] int64 | |
| | `-- point_data | |
| | |-- solution | |
| | | |-- velocity [4550479, 3] float32 m/s | |
| | | |-- gauge_pressure [4550479] float32 Pa | |
| | | |-- turbulent_kinetic_energy [4550479] float32 m^2/s^2 | |
| | | |-- specific_dissipation_rate [4550479] float32 1/s | |
| | | |-- turbulent_kinematic_viscosity [4550479] float32 m^2/s | |
| | | |-- intermittency [4550479] float32 1 | |
| | | `-- momentum_thickness_reynolds_number [4550479] float32 1 | |
| | `-- _target_quadrature_measure [4550479] float32 m^3 (cell volume) | |
| |-- boundaries | |
| | |-- inlet (Mesh: triangle faces) | |
| | | |-- points [12800, 3] float32 m | |
| | | |-- cells [25122, 3] int64 | |
| | | `-- cell_data | |
| | | |-- solution/* [25122, ...] float32 (seven fields, as interior) | |
| | | `-- prescribed/dirichlet/{velocity, turbulent_kinetic_energy, | |
| | | specific_dissipation_rate, intermittency, momentum_thickness_reynolds_number} | |
| | |-- outlet (Mesh: triangle faces) | |
| | | |-- points / cells [17289, 3] / [34080, 3] | |
| | | `-- cell_data | |
| | | |-- solution/* [34080, ...] float32 (seven fields, as interior) | |
| | | |-- prescribed/dirichlet/gauge_pressure [34080] float32 Pa (zero) | |
| | | `-- prescribed/reverse_flow/* [34080, ...] float32 (five inlet fields) | |
| | |-- no_slip (Mesh: body no-slip bands and enclosure walls) | |
| | | |-- points / cells [55553, 3] / [110356, 3] | |
| | | `-- cell_data | |
| | | |-- solution/* [110356, ...] float32 (seven fields, as interior) | |
| | | |-- prescribed/dirichlet/velocity [110356, 3] float32 m/s (zero) | |
| | | |-- annotation/body_id [110356] int64 (0 enclosure, 1 primary, 2 secondary) | |
| | | `-- derived/{wall_shear_stress [F, 3] Pa, wall_y_plus [F]} | |
| | `-- slip (Mesh: body slip bands, slip walls, and symmetry planes) | |
| | |-- points / cells [68480, 3] / [135042, 3] | |
| | `-- cell_data | |
| | |-- solution/* [135042, ...] float32 (seven fields, as interior) | |
| | `-- annotation/body_id [135042] int64 | |
| `-- global_data | |
| |-- schema_version () int64 | |
| |-- physics/{density () kg/m^3, kinematic_viscosity () m^2/s, body_acceleration [3] m/s^2, closure_model_id ()} | |
| |-- reference/{velocity [3], secondary_inlet_velocities [M, 3], force_projection_direction [3], | |
| | speed (), length (), dynamic_pressure ()} | |
| `-- identity/*, solution_definition/*, diagnostics/* (provenance, averaging window, and stability metrics) | |
| ``` | |
| A sample stores more tensors than a benchmarked model is permitted to take as | |
| input; see [Tasks](#tasks) for the input contract. | |
| ## Tasks | |
| AeroZoo supports general physics-AI training and evaluation, with two benchmark | |
| tasks that map a posed boundary-value problem to its time-averaged solution. | |
| ### Inputs, Targets, and Withheld Keys | |
| Only data that define the governing boundary-value problem enter a model: | |
| | Role | Interior task | Boundary task | | |
| |:---|:---|:---| | |
| | Allowed inputs | The four boundary triangle meshes (`points` and `cells`, whose mesh names identify each condition), `cell_data["prescribed", ...]`, `global_data["physics", "kinematic_viscosity"]`, `density` (1.225 kg/m³ everywhere, to work in pascals), and `body_acceleration` (zero) | Same inputs (no `interior` points) | | |
| | Query coordinates | `interior.points` (cell centroids) | Boundary face centroids, computed from `points` and `cells` | | |
| | Predicted targets | `interior.point_data["solution", ...]` (the seven mean fields; predicting velocity and pressure alone is also valid when stated) | `cell_data["solution", ...]` on boundaries and `derived/wall_shear_stress` on `no_slip`, excluding Dirichlet-fixed fields (`inlet` velocity and turbulence, `outlet` pressure, `no_slip` velocity) and `slip` velocity on symmetry hemispheres | | |
| | Loss and metric weights (withheld) | `interior.point_data["_target_quadrature_measure"]` (cell volume) | Boundary triangle face areas | | |
| | Withheld from model inputs | `solution/*`, `derived/*`, `_target_quadrature_measure`, `annotation/body_id`, and all of `global_data` except `kinematic_viscosity`, `density`, and `body_acceleration` | Same withheld keys, plus `interior` | | |
| **Why reference scales and body annotations are withheld.** Keys under | |
| `global_data["reference", ...]` (reference length, speed, dynamic pressure, | |
| inlet vectors, and force direction) define scoring units rather than the PDE. | |
| Renaming which length is called the reference leaves the physical flow | |
| unchanged, so feeding `reference/length` or a Reynolds number built on it leaks | |
| convention into the inputs. Likewise, the PDE applies the same wall boundary | |
| condition regardless of `annotation/body_id` (`0` for enclosure walls, `1` or | |
| `2` for bodies); only losses and post-processing metrics use `body_id`. Nor | |
| does every problem have a single free-stream vector (for example a 90° duct | |
| bend or a dual-inlet box). Models that normalize coordinates or condition on a | |
| length, speed, or Reynolds scale derive it from one sample's boundary inputs | |
| and pass that derived scale (or Reynolds number) alongside rescaled | |
| coordinates. | |
| ### Benchmark Rules | |
| - **Canonical subset (`mean_stable`):** Train, validate, and test on | |
| `mean_stable` samples only. In the remaining 999 `mean_unstable` samples, | |
| averages over the two halves of the window differed beyond the stability | |
| tolerances (30% of crossflow boxes and 34% of symmetry hemispheres pass, and | |
| predicting the inlet velocity everywhere yields median | |
| \\(\varepsilon_U = 0.110\\) on `full`'s canonical test set versus 0.184 | |
| across all released test samples). Scores over all released samples, or | |
| models trained with `mean_unstable` samples included, can be reported beside | |
| the canonical result when labeled. | |
| - **Body-only test scoring on body-property splits:** The seven geometry-family | |
| splits (`bank_*`) and `layout` place body-free ducts according to a body or | |
| wall layout drawn from the case seed and never posed. Canonical test sets for | |
| those eight splits exclude body-free ducts (12 of 322 in `bank_cars`, | |
| 38 of 930 in `layout`). Training and validation parts, and all other | |
| splits, retain them. | |
| - **Single-sample input functions only:** Any deterministic function of one | |
| sample's allowed inputs (such as a boundary-derived length, speed, or | |
| Reynolds number) is permitted. Normalization constants or other statistics | |
| fitted across test samples are prohibited. | |
| - **Validation for selection only:** Select models and hyperparameters on the | |
| validation part, then fit scored weights on the training part alone without | |
| refitting on `train + val` (`super_scarce` has 53 canonical training samples | |
| and 290 validation samples). Hyperparameters chosen on `full`'s validation | |
| part can be reused across other splits when stated in the report (every | |
| validation case of one split belongs to the test set of another). | |
| ### Metrics and Reporting | |
| Metrics are evaluated per test sample in that case's reference units so flows | |
| spanning a 200-fold range in inlet speed contribute on a common dimensionless | |
| scale: | |
| | Metric | Task | Definition | | |
| |:---|:---|:---| | |
| | \\(\varepsilon_U,\;\varepsilon_p\\) | interior | Headline metrics: volume-weighted RMS errors of mean velocity and gauge pressure over the fluid, in units of \\(U_{\mathrm{ref}}\\) and \\(q_{\mathrm{ref}}\\) | | |
| | \\(\varepsilon_U^{\mathcal{N}},\;\varepsilon_p^{\mathcal{N}}\\) | interior | Same volume-weighted RMS errors within one \\(L_{\mathrm{ref}}\\) of a body face centroid (samples with a body) | | |
| | \\(r_U,\;r_p\\) | interior | Unweighted relative \\(L_2\\) errors \\(\lVert\hat{\mathbf{y}} - \mathbf{y}\rVert_2 / \lVert\mathbf{y}\rVert_2\\) across interior points, for comparison with unweighted ML baselines | | |
| | \\(\varepsilon_k,\;\varepsilon_\omega,\;\varepsilon_{\nu_t},\;\varepsilon_\gamma,\;\varepsilon_{\widetilde{\mathrm{Re}}_{\theta t}}\\) | interior | Auxiliary: volume-weighted RMS errors of the five turbulence fields, normalized by \\(U_{\mathrm{ref}}^2\\), \\(U_{\mathrm{ref}}/L_{\mathrm{ref}}\\), \\(U_{\mathrm{ref}}L_{\mathrm{ref}}\\) for \\(k, \omega, \nu_t\\), and by the target field's own volume-weighted RMS for \\(\gamma, \widetilde{\mathrm{Re}}_{\theta t}\\) | | |
| | \\(\varepsilon_{C_F}\\) | boundary | Error of the body force coefficient along the primary inlet direction \\(\mathbf{e}_F\\), divided by the larger of \\(C_F\\)'s magnitude and 0.05 | | |
| | \\(\varepsilon_{\mathbf{C}}\\) | boundary | Norm of the error of the full body force coefficient vector \\(\mathbf{C}\\), divided by \\(\max(\lVert\mathbf{C}\rVert_2,\,0.05)\\) | | |
| | \\(\varepsilon_{C_p},\;\varepsilon_\tau\\) | boundary | Area-weighted RMS errors of pressure on all body faces (\\(\mathcal{B}\\)) and wall shear stress on no-slip body faces (\\(\mathcal{W}\\)), in units of \\(q_{\mathrm{ref}}\\) | | |
| | \\(\varepsilon_K\\) | boundary | Error of an internal duct's mass-flow-weighted total-pressure loss coefficient \\(K\\), divided by \\(\max(K,\,0.05)\\) (a non-finite value or predicted outlet mass flux at most 1% of inlet mass flux counts as 1) | | |
| Specifically, velocity error, body force coefficient, and axial force error are | |
| defined as | |
| $$ | |
| \begin{aligned} | |
| \varepsilon_U &= \frac{1}{U_{\mathrm{ref}}}\left(\frac{\sum_i V_i\,\lVert\hat{\mathbf{u}}_i - \mathbf{u}_i\rVert_2^2}{\sum_i V_i}\right)^{1/2}, \\ | |
| \mathbf{C} &= \frac{1}{q_{\mathrm{ref}} L_{\mathrm{ref}}^2}\left(\sum_{j \in \mathcal{B}} p_j A_j\,\mathbf{n}_j - \sum_{j \in \mathcal{W}} A_j\,\boldsymbol{\tau}_j\right), \\ | |
| \varepsilon_{C_F} &= \frac{\lvert(\hat{\mathbf{C}} - \mathbf{C}) \cdot \mathbf{e}_F\rvert}{\max(\lvert\mathbf{C} \cdot \mathbf{e}_F\rvert,\,0.05)}, | |
| \end{aligned} | |
| $$ | |
| where \\(V_i\\) is cell \\(i\\)'s volume, \\(\mathcal{B}\\) is the set of body | |
| faces (`annotation/body_id >= 1` on `no_slip` and `slip`), \\(\mathcal{W}\\) is | |
| the no-slip subset of \\(\mathcal{B}\\), \\(A_j\\) and \\(\mathbf{n}_j\\) are | |
| face \\(j\\)'s area and outward normal (pointing out of the fluid), and | |
| \\(\mathbf{e}_F\\) is `reference/force_projection_direction`. Note that | |
| \\(\mathbf{C}\\) uses the reference area \\(L_{\mathrm{ref}}^2\\) rather than | |
| frontal area. | |
| **Free-stream reference (\\(\varepsilon_U^{\mathrm{fs}}\\)).** Predicting the | |
| area-weighted mean prescribed inlet velocity everywhere (with zero gauge | |
| pressure and zero wall shear) requires no training and achieves a median | |
| \\(\varepsilon_U\\) of 0.110 on `full`'s canonical test set, ranging from | |
| 0.03 in opposed spheres to 1.5 in dual-inlet boxes. Because a split's raw | |
| median depends strongly on its enclosure mix, every interior-task evaluation | |
| also reports three sample-paired comparisons using each test sample's own | |
| \\(\varepsilon_U^{\mathrm{fs}}\\): | |
| - the median of \\(\varepsilon_U / \varepsilon_U^{\mathrm{fs}}\\) across test samples, | |
| - the fraction of test samples with \\(\varepsilon_U < \varepsilon_U^{\mathrm{fs}}\\), and | |
| - the median \\(\varepsilon_U\\) within each of the eight enclosure | |
| configurations (`profile` for rectangular boxes and `family` otherwise in | |
| `splits/cases.json`). | |
| **Reporting checklist.** For every benchmark result, state: | |
| 1. Task (`interior` or `boundary`), split name, release version (`v1.2`), and | |
| `index.json` SHA-256 (`release-v1.2.json` records it). | |
| 2. Whether evaluation and training used the canonical `mean_stable` subset, and | |
| whether hyperparameters were reused from `full`'s validation part. | |
| 3. Number of random seeds and exact train and test sample counts. | |
| 4. Mean and median of each applicable metric across defined test samples (plus | |
| shares within 0.02 and 0.05 for \\(\varepsilon_{C_F}\\) and | |
| \\(\varepsilon_{\mathbf{C}}\\)), noting whether the five auxiliary | |
| turbulence fields were predicted. | |
| 5. For interior results, the three free-stream comparisons above. | |
| ## Splits | |
| The 22 frozen splits in `splits/splits.json` map `"<split>_<part>"` to lists of | |
| `case_id`s. **Split placement is a deterministic hash of each case's primary | |
| geometry**, so train, validation, and test share no primary body, and adding | |
| cases in a future release moves no existing case. (The second body that 3% of | |
| cases include is a scaled copy of that case's own primary body, so no geometry | |
| is shared across train, validation, and test.) Validation sets are drawn from | |
| the training distribution rather than held-out regimes. Of 4,360 planned split | |
| cases in `release-v1.2.json`, 3,815 completed (2,816 `mean_stable`), 208 | |
| failed mesh or solver checks, and 337 timed out when generation stopped. | |
| Uncompleted cases keep their split assignments and are never replaced. | |
| Canonical (`mean_stable`) / all-released sample counts per split (canonical | |
| test counts for the seven `bank_*` splits and `layout` exclude body-free | |
| ducts): | |
| | Split | Test regime | Train (canonical / all) | Val (canonical / all) | Test (canonical / all) | | |
| |:---|:---|---:|---:|---:| | |
| | **Random** | | | | | | |
| | `full` | Unstratified 70 / 10 / 20 baseline split | 2,011 / 2,713 | 290 / 386 | 515 / 716 | | |
| | `scarce` | Data efficiency: one-sixth of `full` train | 321 / 440 | 290 / 386 | 515 / 716 | | |
| | `super_scarce` | Data efficiency: one-thirty-sixth of `full` train | 53 / 74 | 290 / 386 | 515 / 716 | | |
| | **Held-out enclosure** | | | | | | |
| | `profile_open_opposed` | Open box | 1,943 / 2,775 | 293 / 405 | 580 / 635 | | |
| | `profile_ground_effect` | Ground-effect box | 2,011 / 2,837 | 294 / 400 | 511 / 578 | | |
| | `profile_confined_opposed` | Confined box | 2,114 / 2,963 | 301 / 418 | 401 / 434 | | |
| | `profile_crossflow` | Crossflow box | 2,298 / 2,820 | 345 / 417 | 173 / 578 | | |
| | `profile_dual_inlet` | Dual-inlet box | 2,044 / 2,875 | 313 / 424 | 459 / 516 | | |
| | `family_opposed_sphere` | Opposed sphere | 2,158 / 3,017 | 302 / 418 | 356 / 380 | | |
| | `family_opposed_hemisphere` | Symmetry hemisphere | 2,330 / 2,982 | 352 / 442 | 134 / 391 | | |
| | `family_duct` | Internal duct | 2,266 / 3,055 | 348 / 457 | 202 / 303 | | |
| | `family_non_box` | Spheres, hemispheres, and ducts (train on boxes) | 1,850 / 2,390 | 274 / 351 | 692 / 1,074 | | |
| | **Held-out geometry family** | | | | | | |
| | `bank_blobs` | Blobs | 1,662 / 2,156 | 237 / 292 | 872 / 1,367 | | |
| | `bank_blender_bluff` | Blender bluff | 2,149 / 2,935 | 331 / 441 | 326 / 439 | | |
| | `bank_cars` | Procedural cars | 2,173 / 2,965 | 321 / 434 | 310 / 416 | | |
| | `bank_zero_to_cad` | Zero-to-CAD | 2,250 / 3,040 | 332 / 442 | 224 / 333 | | |
| | `bank_airframes` | Airframe Foundry | 2,198 / 3,018 | 321 / 430 | 288 / 367 | | |
| | `bank_streamlined` | Streamlined | 2,132 / 2,940 | 332 / 441 | 337 / 434 | | |
| | `bank_blender_streamlined` | Blender streamlined | 2,148 / 2,938 | 310 / 418 | 346 / 459 | | |
| | **Reynolds range and body-wall layout** | | | | | | |
| | `reynolds` | Extrapolation: train \\(Re < 10^6\\), test \\(Re \ge 10^6\\) | 1,577 / 2,119 | 238 / 311 | 1,001 / 1,385 | | |
| | `reynolds_interior` | Interpolation: \\(10^5 \le Re < 10^6\\) decade held out | 1,935 / 2,614 | 292 / 380 | 589 / 821 | | |
| | `layout` | Three-band bodies (train on all-no-slip and two-band) | 1,647 / 2,233 | 239 / 311 | 892 / 1,271 | | |
| `full`, `scarce`, and `super_scarce` share identical validation and test sets. | |
| Every other split holds out one regime as its test set, so test-set sizes and | |
| difficulty vary across splits; compare models on the same split, starting with | |
| `full` and using the held-out splits to measure extrapolation. | |
| Resolve any canonical split part directly from the top-level metadata files | |
| before downloading sample tars: | |
| ```python | |
| import json | |
| from pathlib import Path | |
| from huggingface_hub import hf_hub_download | |
| repo = "nvidia/AeroZoo" | |
| fetch = lambda name: json.loads(Path(hf_hub_download(repo, name, repo_type="dataset")).read_text()) | |
| splits = fetch("splits/splits.json") | |
| release = fetch("release-v1.2.json") | |
| body_free = set(fetch("splits/body-free-ducts.json")["case_ids"]) | |
| quality = {c: r.get("solution_quality") for c, r in release["cases"].items()} | |
| def canonical(part: str) -> list[str]: | |
| split, kind = part.rsplit("_", 1) | |
| chosen = [c for c in splits[part] if quality[c] == "mean_stable"] | |
| if kind == "test" and (split.startswith("bank_") or split == "layout"): | |
| chosen = [c for c in chosen if c not in body_free] | |
| return chosen | |
| train_ids, test_ids = canonical("bank_cars_train"), canonical("bank_cars_test") | |
| ``` | |
| An unpacked sample records the same body-free indicator locally: | |
| `geometry.body_count == 0` in `case-manifest.json`, and zero faces with | |
| `annotation/body_id >= 1` on `no_slip` and `slip`. | |
| ## What to know before training | |
| - **Time-averaged URANS targets:** Stored fields are time means over an | |
| 80-convective-time window (following 15 convective times of spin-up) of | |
| unsteady RANS with the Langtry–Menter transition SST closure in OpenFOAM 14. | |
| Internal ducts that did not settle in the first window ran one fresh | |
| 80-convective-time window. `mean_stable` marks samples whose two | |
| 40-convective-time half-window averages agree within 0.02 of | |
| \\(U_{\mathrm{ref}}\\) in velocity, 0.05 of \\(q_{\mathrm{ref}}\\) in | |
| pressure, and 0.02 times \\(\max(\lvert C_F\rvert,\,0.05)\\) in axial force | |
| coefficient. | |
| - **High-Reynolds attrition:** Of the 337 planned cases still running when | |
| generation stopped, 230 lie in the \\(10^7\\) to \\(10^8\\) Reynolds decade | |
| (`release-v1.2.json` records every planned case's status). | |
| - **Sign and pressure conventions:** `derived/wall_shear_stress` follows | |
| OpenFOAM's convention (traction exerted by the wall on the fluid, giving the | |
| minus sign in \\(\mathbf{C}\\)). `gauge_pressure` is in pascals relative to | |
| the outlet (0 Pa), and boundary face normals point out of the fluid domain. | |
| - **Enclosed volumes:** Compute fluid or body volumes from a sample's boundary | |
| triangle meshes (for example via the divergence theorem over `boundaries/*`). | |
| Those match the sum of cell volumes across all released samples, including | |
| three Zero-to-CAD cases (550, 2273, and 3538) whose upstream CAD surfaces | |
| self-intersected before exterior meshing. | |
| ## Geometry sources | |
| Six of the seven geometry families (plus the EasterEggs mascot meshes) were | |
| created in-house at NVIDIA. Two of the 11 airfoil sections used in Blender | |
| streamlined wings (Eppler E387 and SD7003-085-88) come from coordinate files in | |
| the UIUC Airfoil Coordinates Database (M. S. Selig, UIUC), and the remaining | |
| nine sections were evaluated from the analytic NACA equations. The Zero-to-CAD | |
| family is a farthest-point sample of 500 parts drawn across three bluffness | |
| strata from the 52,408 watertight, single-body parts of Autodesk AI Lab's | |
| Zero-to-CAD 100K dataset (`ADSKAILab/Zero-To-CAD-100k`); 320 of them appear in | |
| released samples, and the family's other 13 released samples are body-free | |
| ducts. That dataset is | |
| released under the Apache License 2.0, which applies to those parts. `LICENSE` and `NOTICE` at the top of this repository state the terms, attributions, and modifications, and `zero-to-cad-provenance.csv` maps each Zero-to-CAD sample body to its upstream part and transform. | |
| ## License | |
| **GOVERNING DOWNLOAD TERMS:** Use of the dataset is governed by the | |
| [Creative Commons Attribution 4.0 International License (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/legalcode.en), | |
| and includes 500 parts selected from Autodesk AI Lab's Zero-to-CAD 100k dataset | |
| which is governed by [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0). | |
| Origin of every input: | |
| | Input | Origin | Terms | | |
| |---|---|---| | |
| | Blobs, Blender bluff, Blender streamlined, Streamlined, Procedural cars, Airframe Foundry geometry families | generated in-house at NVIDIA | the dataset license | | |
| | Two of the 11 airfoil sections of the Blender streamlined wings (Eppler E387, SD7003-085-88) | coordinate files from the UIUC Airfoil Coordinates Database (M. S. Selig, UIUC); the other nine were computed from the published NACA equations | the dataset license; the coordinate files are not included (credited in NOTICE) | | |
| | Zero-to-CAD parts (500 selected; 320 appear in released samples) | Autodesk AI Lab, Zero-to-CAD 100K | Apache License 2.0; see `NOTICE` and `zero-to-cad-provenance.csv` | | |
| | Two mascot meshes (unicorn, jackalope; the EasterEggs family, outside every split, one released sample) | modeled in-house at NVIDIA by Carmelo Gonzales | the dataset license | | |
| | All flow solutions, meshes, the stability label and metadata | computed by NVIDIA | the dataset license | | |
| ## Verifying a copy | |
| `SHA256SUMS` lists the SHA-256 of every data file of the release as stored on | |
| NVIDIA's clusters: the top-level files alongside each sample tar unpacked into | |
| its shard directory. It was added on 2026-10-16 with no change to any data | |
| file. To reconstruct that layout from a download and verify every file: | |
| ```bash | |
| for t in samples/shard-*/*.tar; do | |
| s=$(basename "$(dirname "$t")"); mkdir -p "$s"; tar -xf "$t" -C "$s" | |
| done | |
| grep -v ' README.md$' SHA256SUMS | sha256sum --quiet -c - | |
| ``` | |
| The second command prints nothing when every listed file matches (it skips the | |
| cluster-tree `README.md`, and extra repository files such as `LICENSE`, `NOTICE`, `zero-to-cad-provenance.csv`, `assets/`, or `splits/body-free-ducts.json` are ignored by `sha256sum -c`). Running | |
| `sha256sum SHA256SUMS` prints a single digest covering the entire release: | |
| `f63dc064ca4c8dc5e03d6668c4e60efdb197d4b6cd0d965ec3fe83a2ba77bb38`. | |
| ## Provenance | |
| Generated with OpenFOAM 14 (mesh policy `snappyhexmesh_external_v14` for every | |
| case, ducts included, and solver policy | |
| `openfoam14-external-transition-sst-mean-co10-w80-duct-two-stage-v10`, artifact | |
| schema 5) on NVIDIA's compute clusters (8.1 million CPU core-hours of solver | |
| time); population frozen 2026-10-02 and exported 2026-10-08. The `index.json` | |
| SHA-256 recorded in `release-v1.2.json` is `c8e9508e8a9d8291…`. | |
| ## Citation | |
| ```bibtex | |
| @misc{sharpe2026aerozoo, | |
| title = {{AeroZoo}: A Benchmark of Well-Posed Flow Problems for Foundation Models of Aerodynamics}, | |
| author = {Sharpe, Peter and Gonzales, Carmelo and Adams, Corey and Ataei, Mehdi and Choudhry, Sanjay}, | |
| year = {2026}, | |
| howpublished = {arXiv:2611.17152}, | |
| url = {https://arxiv.org/abs/2611.17152} | |
| } | |
| ``` | |
| Corresponding contact: Peter Sharpe (`psharpe@nvidia.com`). | |
| ## NVIDIA dataset card | |
| ### Dataset Description | |
| AeroZoo is a dataset of computed fluid flows for physics-AI research. | |
| It holds 3,816 samples. Each sample is one solved flow problem: one body (or | |
| none, in some ducts) inside its own enclosure, at its own size, speed and | |
| Reynolds number. The Reynolds number ranges from 10³ to 10⁸, which covers | |
| laminar and turbulent flow. No two planned samples share the same primary | |
| geometry. | |
| Each sample stores three things: | |
| - the problem that was posed: the boundary surfaces, the conditions set on | |
| them, and the fluid's viscosity; | |
| - the solution: seven time-averaged flow fields (velocity, pressure and five | |
| turbulence-model fields) at the center of every cell of the solver's mesh; | |
| - the volume of every cell, used to weight a training loss. | |
| All samples were computed by NVIDIA with the solver OpenFOAM 14. | |
| The solver ran unsteady Reynolds-averaged Navier–Stokes (URANS) simulations | |
| with the Langtry–Menter transition SST turbulence model. Each stored field is a | |
| time average over a fixed window, not an instantaneous snapshot. | |
| The bodies come from seven geometry families: Blobs, Blender bluff, Blender | |
| streamlined, Streamlined, Procedural cars, Airframe Foundry and Zero-to-CAD. | |
| They sit in eight enclosure configurations: a rectangular box with five | |
| boundary layouts (open, ground-effect, confined, crossflow and dual-inlet), an | |
| opposed sphere, a symmetry hemisphere and an internal duct. Each body uses one | |
| of three body-wall layouts (all no-slip, two slip/no-slip bands, three bands). | |
| The dataset is meant for training and testing machine-learning models that | |
| predict fluid flow ("surrogate models"). It ships with 22 fixed train / | |
| validation / test splits and two benchmark tasks with defined metrics. | |
| This dataset is ready for commercial or non-commercial uses. | |
| ### Dataset Owner(s) | |
| NVIDIA Corporation. | |
| ### Dataset Creation Date | |
| 2026-10-08 (v1.2 export). | |
| The simulations behind the released samples completed between 2026-09-13 and | |
| 2026-10-02, when generation was stopped and the population was frozen. | |
| ### Versioning | |
| v1.2 (2026-10-08 export). | |
| ### Intended Usage | |
| AeroZoo is intended for researchers and engineers who build machine-learning | |
| models of fluid flow. Intended uses are: | |
| - training and evaluating surrogate models of steady or time-averaged | |
| incompressible flow; | |
| - pretraining such models on many unrelated flows; | |
| - measuring how well a model generalizes to unseen geometry families, | |
| enclosures, boundary layouts and Reynolds numbers, using the 22 frozen | |
| splits; | |
| - comparing models on the two benchmark tasks. The interior task predicts the | |
| mean fields at every cell center. The boundary task predicts the mean fields | |
| on every boundary face and the wall shear stress on no-slip walls. The canonical | |
| benchmark uses only `mean_stable` samples. | |
| What the dataset does not support: | |
| - Forecasting a flow over time. Only time averages are stored. | |
| - Compressible, heated, multiphase or non-Newtonian flow; moving or rotating | |
| walls; porous media. | |
| - Use as measurements of real flows. Each sample solves one turbulence model's | |
| equations on one mesh. Each solution is converged at the recipe's placement of | |
| the first wall cell, not independently of it: on meshes 1.5 times finer per | |
| direction the force changes by a median of 3.7% (at most 19%), and a first | |
| cell at y⁺ ≈ 1 changes it by a median of 6.9% (at most 36%) and can move | |
| transition. | |
| ### Dataset Characterization | |
| **Data Collection Method** | |
| - Synthetic | |
| Every sample was generated by computer simulation; nothing was measured or | |
| collected from people. For each case, the generator drew a geometry, its size | |
| (2 cm to 20 m), inlet speed (0.25 to 50 m/s) and Reynolds number (10³ to 10⁸) | |
| from a seed and a frozen recipe. It then built a mesh with OpenFOAM's | |
| `snappyHexMesh` (mesh policy `snappyhexmesh_external_v14`). The solver ran | |
| OpenFOAM 14 with the Langtry–Menter transition SST model (solver policy | |
| `openfoam14-external-transition-sst-mean-co10-w80-duct-two-stage-v10`). Each | |
| solve ran 15 convective times to let the start-up wash out, then averaged every | |
| field over the next 80 convective times. An internal duct whose first window | |
| did not settle averaged one fresh 80-convective-time window; there was no | |
| further extension. (A convective time is the reference length, the body's largest | |
| extent, divided by the inlet speed.) The exporter converted each result to | |
| a PhysicsNeMo `DomainMesh`, reloaded it and checked it before release. | |
| The posed problem of every case was fixed before any mesh existed. Cases that | |
| failed a mesh or solver check (208) or were still running when generation | |
| stopped (337) are listed in the release manifest and are not replaced. The | |
| runs used NVIDIA's compute clusters. The released samples took 8.1 million | |
| CPU core-hours of solver time. | |
| Geometry origin: six of the seven geometry families were generated in-house at | |
| NVIDIA. The seventh, Zero-to-CAD, is a sample of 500 parts from Autodesk AI | |
| Lab's Zero-to-CAD 100K, chosen from the 52,408 parts that pass watertightness, | |
| single-body and shape checks. Two of the 11 airfoil sections of the Blender | |
| streamlined wings (Eppler E387 and SD7003-085-88) come from coordinate files of | |
| the UIUC Airfoil Coordinates Database; the other nine were computed from the | |
| published NACA equations. The two mascot meshes were modeled in-house at | |
| NVIDIA. | |
| The dataset contains no personal data. | |
| **Labeling Method** | |
| - Automated | |
| The dataset has one label: the stability label, `mean_stable` or | |
| `mean_unstable`. It says whether the time average had settled. The software | |
| compares the averages over the two halves of the 80-convective-time window, | |
| with three fixed tests: velocity change at most 0.02 of the inlet speed, | |
| pressure change at most 0.05 of the reference dynamic pressure, and a change in | |
| the body-force coefficient of at most 0.02 times its mean value (or times 0.05, | |
| if that is larger). A sample is | |
| `mean_stable` if it passes all three. The thresholds were fixed before the | |
| studies that tested them and were never adjusted. All three measured changes | |
| are stored, so users can apply another rule. No person labeled any sample. | |
| ### Dataset Format | |
| - **Modality:** 3D physics simulation data: point clouds (interior cell | |
| centers with field values) and triangle meshes (boundary surfaces), with | |
| scalar metadata. Units are SI throughout. | |
| - **Format:** one uncompressed `.tar` file per sample. Each unpacks to a | |
| PhysicsNeMo `DomainMesh` (`domain.pdmsh`, a memory-mapped TensorDict tree; | |
| artifact schema 5) and small JSON / YAML files. Floating-point tensors are | |
| `float32`. Top-level catalog, split and checksum files are JSON and text. | |
| - **Structure of one sample (`domain.pdmsh`):** | |
| - `interior`: one point per mesh cell, at the cell center. Each point holds | |
| 13 `float32` values: 3 coordinates, the seven mean fields (9 components) | |
| and the cell volume. There is no interior connectivity. | |
| - `boundaries`: four triangle meshes, `inlet`, `outlet`, `no_slip` and | |
| `slip`, grouped by boundary condition. They carry the prescribed values, | |
| the mean fields on every face, and wall shear stress and y⁺ on `no_slip`. | |
| - `global_data`: fluid properties, reference scales, how the mean was | |
| defined, identity hashes and quality diagnostics, including the stability | |
| label. | |
| - **Files beside the samples:** `index.json` (one record per released sample), | |
| `release-v1.2.json` (status of every planned case), `splits/cases.json`, | |
| `splits/splits.json` (22 named splits), `splits/splits-metadata.json`, | |
| `checksums.sha256` and `SHA256SUMS`. | |
| ### Dataset Quantification | |
| - **Record count:** 3,816 samples: 3,815 of the 4,360 planned cases plus one | |
| mascot outside every split (`release-v1.2.json`). Of these, 2,817 | |
| are `mean_stable` and 999 `mean_unstable`. | |
| - **Feature count:** per interior point, 13 values (3 coordinates, 9 | |
| mean-field components, 1 cell volume). Per sample, four boundary meshes and | |
| the `global_data` scalars (artifact schema 5). | |
| - **Size of the samples:** 23.8 billion interior points in total; median 5.0 | |
| million cells per sample, range 0.6 to 24 million. | |
| - **Total data storage:** 1.48 TB: 1,480,746,807,800 bytes of sample artifacts, | |
| median 347 MB per sample. | |
| The Hugging Face repository stores 1,482,788,671,963 bytes in all (Hub API, | |
| 2026-10-30). | |
| Planned and released cases per geometry family: | |
| | Geometry family | Planned cases | Released samples | | |
| |---|---:|---:| | |
| | Blobs | 1,600 | 1,367 | | |
| | Blender bluff | 500 | 439 | | |
| | Blender streamlined | 500 | 459 | | |
| | Streamlined | 480 | 434 | | |
| | Procedural cars | 480 | 416 | | |
| | Zero-to-CAD | 400 | 333 | | |
| | Airframe Foundry | 400 | 367 | | |
| | **Total** | **4,360** | **3,815** | | |
| | EasterEggs mascots (outside every split) | 2 | 1 | | |
| ### Reference(s) | |
| - AeroZoo on Hugging Face: https://huggingface.co/datasets/nvidia/AeroZoo | |
| - NVIDIA PhysicsNeMo (the `DomainMesh` format): https://github.com/NVIDIA/physicsnemo | |
| - OpenFOAM 14: https://openfoam.org/version/14/ | |
| - Zero-to-CAD 100K (source of the Zero-to-CAD geometry family): | |
| https://huggingface.co/datasets/ADSKAILab/Zero-To-CAD-100k | |
| - Ataei, Askari, Rahimi Malekshan and Jayaraman, "Zero-to-CAD: Agentic | |
| Synthesis of Interpretable CAD Programs at Million-Scale Without Real Data", | |
| 2026, https://arxiv.org/abs/2604.24479 | |
| - The AeroZoo paper: <https://arxiv.org/abs/2611.17152> | |
| ### Ethical Considerations | |
| NVIDIA believes Trustworthy AI is a shared responsibility and we have | |
| established policies and practices to enable development for a wide array of | |
| AI applications. Developers should work with their internal developer teams to | |
| ensure this dataset meets requirements for the relevant industry and use case | |
| and addresses unforeseen product misuse. | |
| Please report quality, risk, security vulnerabilities or NVIDIA AI Concerns | |
| [here](https://www.nvidia.com/en-us/support/submit-security-vulnerability/). | |