AhmedML dataset

Dataset overview and leaderboard submission format for AhmedML.

Open for submissions · Check submission availability

Automotive external aerodynamics

Overview

High-fidelity, time-averaged data from transient hybrid RANS–LES simulations of 500 parametrically varied Ahmed bodies, with native three-dimensional boundary and volume fields, geometry, force coefficients, slices, images, and deterministic data-efficiency and out-of-distribution splits.

Mean streamwise-velocity slice through an AhmedML body and its wake.
Mean streamwise-velocity slice from AhmedML run 1. AhmedML source dataset.

FluidsBench evaluation schematic

  1. Model inputs Ahmed geometry + flow conditions
  2. Scoring support Native surface polygons and volume cells
  3. Reported evaluation Area-weighted surface errors; equal-cell volume errors; forces and profiles

Schematic only; the benchmark specification fixes the exact files, entities, arrays, and equations.

Availability and licence

500 field-bearing cases; approximately 3.08 TB for the complete pinned repository

CC BY-SA 4.0. Check the source release for its complete terms.

Benchmark definition

Contract pinned

Technical details

Scoring source pin: neashton/ahmedml @ 02688c727cdb8dc8678e28abc6bbbb7e93c5fa15. Open contract.

What the source contains

STL geometry, native boundary VTP and volume VTU fields, force and geometry tables, CFD slices and images, eight split families, and one native polygon-area sidecar per boundary mesh.

What FluidsBench currently evaluates

The benchmark scores complete native boundary pMean and wallShearStressMean, complete native-volume UMean and pMean, reconstructed force coefficients, three 128-point surface Cp cuts, four 128-point wake-velocity profiles, and report-only near-body/wake/farfield diagnostics. All eight prescribed splits are open for submissions using the published support and resumable evaluator.

Dataset summary

Geometry
Parametric Ahmed car body variants.
Cases
500 CFD simulations.
Solver
OpenFOAM v2212 finite-volume simulations.
Fidelity
Transient hybrid RANS-LES, approximately 80 convective time units per case.
Mesh scale
Approximately 20 million cells per case.
License
CC BY-SA 4.0, as stated by the dataset source.

Getting started

Pressure definition Confirmed from paper and solver setup

Surface and volume pressure use kinematic gauge pressure, with the released outlet fixed at zero. Preserve that reference.

Surface and volume

Native field
pMean · CellData
Units
m²/s²
Reference
Outlet fixedValue = 0; inlet velocity = 1 m/s.
Evaluation
Score the released pMean values without another offset.
Conversion
Cp = pMean / (0.5 × 1²) = 2 × pMean. This scaling leaves relative L1/L2 unchanged.

Use the static-pressure field. total(p)_coeffMean is a different quantity. Absolute-error diagnostics retain their declared native units.

Source evidence and audit details

Start with the source documentation and split metadata, then download one representative case before planning a full transfer. The commands below pin the source snapshot audited for this page. For leaderboard work, always use the separate scoring source pin and case lists in the FluidsBench benchmark specification.

1. Inspect the metadata and splits

python3 -m pip install -U huggingface_hub hf_xet
hf download neashton/ahmedml \
  --repo-type dataset \
  --revision 02688c727cdb8dc8678e28abc6bbbb7e93c5fa15 \
  --include "README.md" \
  --include "splits/**" \
  --local-dir ./ahmedml

2. Download and inspect one surface case

hf download neashton/ahmedml \
  --repo-type dataset \
  --revision 02688c727cdb8dc8678e28abc6bbbb7e93c5fa15 \
  --include "run_1/ahmed_1.stl" \
  --include "run_1/boundary_1.vtp" \
  --include "run_1/boundary_cell_area_1.npy" \
  --include "run_1/force_mom_1.csv" \
  --local-dir ./ahmedml
import numpy as np
import pyvista as pv

surface = pv.read("ahmedml/run_1/boundary_1.vtp")
area = np.load("ahmedml/run_1/boundary_cell_area_1.npy", mmap_mode="r")
assert area.shape == (surface.n_cells,)
print(surface.cell_data.keys())

The boundary fields are cell-associated, so sidecar entry i weights native polygon i. Download run_1/volume_1.vtu only when you are ready for the multi-gigabyte native volume; FluidsBench volume metrics cover every field-bearing cell.

Design-space coverage

What changes across the dataset

Parent shape or archetype means the source geometry family, not an ML baseline model. The cards distinguish shape breadth from operating-condition breadth.

Parent shapes / archetypes

1 parent shape

  • Ahmed body A single simplified automotive bluff-body family; every case is a continuous variant of this parent geometry.

Geometry parameterization

6 continuous geometry parameters

The source varies the rear treatment and the main body dimensions while retaining the recognizable Ahmed-body topology.

View 6 documented variables and ranges
Rear-window angle
10°–60°
Tilted-surface length
150–250 mm
Body length
800–1,200 mm
Body height
250–315 mm
Body width
300–500 mm
Front-body radius
80–120 mm

Conditions and sampling

Operating conditions

The operating setup is fixed across the dataset, so the intended breadth comes from geometry rather than a boundary-condition sweep.

Sampling

Latin hypercube sampling fills the six-dimensional parameter box with 500 geometry cases.

Benchmark coverage

What the current splits test

The eight published source splits separate the random full-data task, nested data-efficiency tasks, and held-out geometry, force, and wake regimes. All eight benchmark bindings now use the exact pinned public case IDs; the four nested data-efficiency splits share the same 50-case test set.

AhmedML paper and design-space table

Published source splits

AhmedML publishes the eight train, validation, and test manifests below. The evaluator binds these exact public run_N case IDs and the immutable source revision. Check the submission guide for current availability.

Split Purpose Train Validation Test
full Seed-42 random public baseline split. 400 50 50
medium Nested data-efficiency subset with fixed validation and test cases. 133 50 50
scarce Smaller nested data-efficiency subset with fixed validation and test cases. 67 50 50
super_scarce Minimum-data nested training subset with fixed validation and test cases. 11 50 50
geometry STL-Chamfer geometry out-of-distribution split. 350 50 100
high_drag High-drag force-regime out-of-distribution split. 350 50 100
low_drag Low-drag force-regime out-of-distribution split. 350 50 100
image_wake Image-derived UxMean wake out-of-distribution split. 350 50 100

Evaluate and submit

Follow the AhmedML participant quickstart for pinned Linux setup, data and prepared-support downloads, complete-split evaluation with resume, reports and validated packaging. Predict both surface and volume fields in native cell order. The evaluator derives forces and all seven profile series per case. Submit only the generated result directory, following the submission instructions.

Open-reproducibility submission Files, validation and optional artifacts

Check this dataset's submission availability before preparing a result. Contributions are accepted only while its exact scoring-support release is marked official and open. For an open dataset, contributors propose one result directory at submissions/ahmedml/<submission-id>/ in the FluidsBench submission repository. The planned result package contains:

  • submission.json for model metadata and the required scalar metrics;
  • evaluation-evidence.json linking those submitter-provided metrics to the declared evaluation revision and profile-index checksum;
  • discretization.json describing the training input and supervision supports, inference input, direct model outputs, and mapping to the official scoring support;
  • discretization/cases.jsonl recording case-level counts, domains, mapping, and declared scoring coverage;
  • metrics/cases.json recording the official-support errors, the unweighted and physical-measure-weighted sufficient statistics required by that dataset's contract, and exact coverage for every declared evaluation case;
  • profiles/index.json listing the lightweight profile chunks; and
  • profiles/chunk-*.json containing profile coordinates and predictions for the declared test cases.

FluidsBench uses an open reproducibility track. The declared evaluation partition, scored case lists, and ground truth are public. Evaluation cases must not be used for fitting, hyperparameter selection, or preprocessing statistics. Contributors will calculate the metrics and extract the profiles from their own predictions. Each dataset specification fixes the locations, IDs, weights, targets, and coverage used for final scoring. A model may infer on a different point set, mesh, or grid, but its final predictions must be mapped onto every required entity in the release-bound public field files before the reference evaluator calculates the errors. Large cases may be processed in chunks, but contributors must sum the sufficient statistics across all chunks before calculating a case metric; chunk-level L2 values are never averaged. Leaderboard field errors are calculated on the declared evaluation/test cases, not on the training cases. Full meshes and volume fields are not committed to the submission repository. Contributors may optionally publish example cases or the complete scored predictions in a public, immutable external repository and link that artifact from the submission. Use the AhmedML benchmark specification for the exact split, metric, case, panel, station, and quantity IDs. The reference equations and code define how the scalar values must be calculated, and the worked examples show the JSON structure.

Before opening a pull request, run python scripts/validate_submission.py --contributor-stage submissions/ahmedml/<submission-id>. The validator checks the schema, split identity, scoring-support binding, derived-score arithmetic, profile coverage, reported discretization, array lengths, ordering, finite values, and file hashes. It checks the submitted package's internal consistency; it does not run the contributor's model or recalculate base metrics from full fields.

A passing validator or pull request will not make a result official. Official results require maintainer approval of the validated submission package. Public code, model, and environment artifacts and their documentation are optional. If supplied, they must use stable links and include the revisions, digests, and licences required by the submission schema; the leaderboard reports those details. Their absence does not change accuracy rank, citation eligibility, or promotion eligibility. Prediction sharing is also optional. When prediction artifacts are shared, the leaderboard separately reports their coverage, artifact-check status, and whether any metrics were recomputed; it does not collapse those distinct checks into a generic “verified” badge. The public validation record states exactly what FluidsBench checked.

Prototype notice: any case IDs, ground truth, profile values, or leaderboard rows labelled prototype are illustrative dummy data. Those materials must be replaced and finalized before the dataset opens; a prototype row is never an official result.

Scoring support and complete coverage Exact files, weighting and complete-case rules

Submissions are open.

Final predictions must cover the complete reference support. For every scored case, this means every required entity, exactly once, in the actual field-bearing mesh or curve file from the named public dataset release. FluidsBench binds those files, their ordering, any masks, and their hashes to the scoring-support release. A method may infer on another representation and may process a large file in chunks, but it must map its predictions back to every required reference entity before calculating the final metrics. Downsampled or partially covered predictions are not complete results.

Scored support Public field file and association Required coverage Relative-L2 pair
Three-dimensional body boundary run_<case-id>/boundary_<case-id>.vtp; pMean and wallShearStressMean in VTK CellData; matching polygon areas are in boundary_cell_area_<case-id>.npy (static(p)_coeffMean is also available for coefficient diagnostics) Every polygon carrying the scored pressure and wall-shear fields Area-weighted primary; unweighted polygon (each polygon counts equally) secondary
Three-dimensional flow volume run_<case-id>/volume_<case-id>.vtu; UMean and pMean in VTK CellData Every cell carrying UMean and pMean Unweighted cell (each cell counts equally) primary; volume-weighted secondary

How to calculate large cases

  • Surface and one-dimensional curve fields use area- or length-weighted relative L2 as the primary value and unweighted relative L2 as the secondary value. Two- and three-dimensional flow domains reverse that order: unweighted relative L2 is primary and area- or volume-weighted relative L2 is secondary. “Unweighted” means that every scored point, node, face, polygon, or cell counts equally.
  • Face- or cell-associated fields use the face area, cell area, or cell volume directly. For PointData or CGNS Vertex fields, FluidsBench supplies the area, volume, or curve length represented by each point or vertex, derived from the same reference mesh connectivity.
  • In one pass over each case, accumulate the squared-error numerator and ground-truth denominator for every relative-L2 variant required in the table above, together with the corresponding entity count and total physical measure wherever one is used. Chunks may be any convenient size, but their numerators and denominators must be summed before taking the square root; never average chunk-level L2 values.
  • Calculate each complete-case percentage first, then macro-average the case percentages so every case counts equally.

Sharing complete prediction fields is optional. A contributor may link versioned predictions in an external public repository, but the submission package records exact coverage plus the per-case sufficient statistics used to reproduce each required relative-L2 value.

Cp stations

AhmedML does not publish a canonical set of one-dimensional pressure traces. FluidsBench therefore defines the following symmetry-plane benchmark traces, informed by the body regions described in the AhmedML paper. The target lines move with each body: their coordinates use that case's length, height, width, slant dimensions, and actual surface bounds. The evaluator then samples a frozen nearest-native-polygon mapping. The dataset frame itself remains fixed at rear plane x=0, symmetry plane y=0, and ground z=0. Use the exact ID in station_id.

Station ID Displayed station
upper_body_centerline Upper-body centreline over the roof and rear slant.
underbody_centerline Underbody centreline along the underfloor.
rear_slant_centerline Centreline across the pressure-sensitive rear slant.

Wake velocity stations

Wake targets are also geometry-relative. For each case, L, H, and W come from that body's published parameters, and the evaluator freezes the native volume-cell mapping before any submission is scored. Each trace contains exactly 128 samples.

Station ID Geometry-relative target Displayed coordinate
wake_vertical_x_0p25_l x=0.25L, y=0, z=tH z/H, 0 to 2
wake_vertical_x_0p50_l x=0.50L, y=0, z=tH z/H, 0 to 2
wake_vertical_x_1p00_l x=1.00L, y=0, z=tH z/H, 0 to 2
wake_lateral_x_0p50_l_z_0p50_h x=0.50L, y=tW, z=z_min+0.50H y/W, −1 to 1

Metric definitions

Relative L2 error
For each evaluation/test geometry, map predictions to every entity in the release-bound public field support and return predictions and targets to dimensional physical space, \(q^\ast = T_q^{-1}(q)\). Calculate both paired relative-L2 values from the accumulated sufficient statistics: area-weighted L2 is primary on the boundary, while unweighted cell L2 (each cell counts equally) is primary in the flow volume. Report the complete-case percentages first, then take the arithmetic mean of the geometry-level values.
Relative L1 error
When reported as a supplementary metric, relative L1 uses the same complete dimensional support and the primary weighting for that domain. Calculate a percentage for each geometry, then take the arithmetic mean of the geometry-level percentages.
Dimensional evaluation
Relative L1 and L2 metrics are not computed on normalized, standardized, or non-dimensional training targets. If a model predicts normalized values, the submission/evaluator must undo that transform before scoring. Cd, Cl, and Cp-cut comparisons remain coefficient-based by definition.
Surface pressure relative L1/L2
Relative L1 and L2 error for dimensional surface pressure p_surface_pred against the evaluator surface pressure values. Cp is used only for the Cp-cut comparisons and plots.
Surface wall-shear relative L1/L2
Relative L1 and L2 error for the wall-shear vector \(\tau_w = (\tau_{w,x}, \tau_{w,y}, \tau_{w,z})\) on the Ahmed body surface.
Volume velocity relative L1/L2
Relative L1 and L2 error for the velocity vector \(u = (u_x, u_y, u_z)\) on every field-bearing cell in the release-bound volume_<case-id>.vtu file.
Volume pressure relative L1/L2
Relative L1 and L2 error for pressure on every field-bearing cell in the same public volume file.
AB-UPT convention
The secondary unweighted polygon relative L2 (each polygon counts equally) is the AB-UPT-compatible value: targets may be normalized for training, but evaluation uses unnormalized predictions and targets. FluidsBench additionally uses the area-weighted boundary value as its primary surface metric.
Coefficient of determination
For scalar values \(y_i\), \(R^2 = 1 - \sum_i(\hat{y}_i - y_i)^2 / \sum_i(y_i - \bar{y})^2\). Higher is better; 1.0 is perfect.
Cd and Cl R2
R2 computed over all evaluated cases using predicted drag coefficient cd_pred and lift coefficient cl_pred.
Force R2
Mean of Cd R2 and Cl R2.
Cp cut R2
One global R2 over all selected surface pressure coefficient samples from the held-out test cases. The evaluator flattens cp_pred and ground-truth cp across case_id, cut_id, station_id, and cut sample locations before computing R2. The plotted trace is chosen with the leaderboard station selector.
Cp cut comparisons
Per-case and per-cut R2 values can be reported as profile comparisons, but the leaderboard ranking should use the global held-out score so that cases with low Cp variance do not dominate through unstable per-case averages.
Velocity profile R2
One global R2 over evaluator-derived scalar Ux/Uinf samples, flattened across the four frozen stations, held-out cases, and 128 sample locations. The other velocity components are part of native volume-field scoring, not this profile metric.

Default overall score

The leaderboard can be ranked by any individual metric. Its default ranking is a bounded 0-100 weighted score:

Relative L1 fields are reported as sortable supplementary metrics, but they are not included in this default score unless a future benchmark rule assigns them weights.

S_error(q) = 100 * max(0, 1 - E_q / cap_q)
S_R2(q)    = 100 * min(1, max(0, R2_q))
S_overall  = sum(weight_q * S_q)
Component Weight Cap or transform
Dimensional surface pressure, area-weighted relative L2 15% 15% cap
Dimensional surface wall shear, area-weighted relative L2 10% 20% cap
Dimensional volume velocity, unweighted cell relative L2 15% 12% cap
Dimensional volume pressure, unweighted cell relative L2 10% 15% cap
Cd R2 15% Clamped to [0, 1]
Cl R2 10% Clamped to [0, 1]
Velocity profile R2 15% Clamped to [0, 1]
Cp cut R2 10% Clamped to [0, 1]

Links