| --- |
| license: cc-by-sa-4.0 |
| task_categories: |
| - graph-ml |
| tags: |
| - cfd |
| - aerodynamics |
| - point-cloud |
| - surrogate-modeling |
| - automotive |
| - drivaer |
| - drivaerml |
| size_categories: |
| - n<1K |
| --- |
| |
| # DrivAerML Point Clouds |
|
|
| A preprocessed, point-cloud version of the [**DrivAerML**](https://huggingface.co/datasets/neashton/drivaerml) high-fidelity CFD dataset, ready for training point-based deep learning surrogates (PointNet, PCT, DGCNN, Graph Neural Operators, etc.) for automotive external aerodynamics. |
|
|
| The original DrivAerML release contains 500 scale-resolving CFD simulations of parametrically morphed DrivAer notchback geometries and ships as ~31 TB of raw STL / VTP / VTU / OpenFOAM data. This release distills the **surface boundary** of each run down to a single compressed `.npz` file (~10 MB) containing the STL point coordinates and the CFD surface fields interpolated onto those points — so the full usable set fits in **~5 GB** instead of multiple terabytes. |
|
|
| ## What's in here |
|
|
| For each run: |
|
|
| - `point_cloud_{i}.npz` — STL surface points with interpolated CFD fields |
| - `force_mom_{i}.csv` — time-averaged force and moment coefficients (Cd, Cl, Clf, Clr, Cs) |
|
|
| Plus at the dataset root: |
|
|
| - `splits.json` — reproducible train/val/test assignment (seed 42, 80/10/10) |
| - `processing_log.json` — per-run processing status and nearest-neighbor distance diagnostics |
|
|
| ### Directory layout |
|
|
| ``` |
| Drivaerml_point_clouds/ |
| ├── train/ # 387 runs |
| │ ├── run_1/ |
| │ │ ├── point_cloud_1.npz |
| │ │ └── force_mom_1.csv |
| │ └── ... |
| ├── val/ # 46 runs |
| │ └── ... |
| ├── test/ # 52 runs |
| │ └── ... |
| ├── splits.json |
| └── processing_log.json |
| ``` |
|
|
| Total: **485 runs** (of the 500 original designs, 15 runs are missing from the source dataset: 167, 211, 218, 221, 248, 282, 291, 295, 316, 325, 329, 364, 370, 376, 403, 473). |
|
|
| > **Note on the Hugging Face dataset viewer:** the viewer only previews the tabular `force_mom_*.csv` files (the Cd/Cl/Clf/Clr/Cs coefficients). The actual point-cloud payload lives in the `.npz` files, which the viewer does not render — clone the repo or stream it with `huggingface_hub` to access the geometry and fields. |
| |
| ## `.npz` contents |
| |
| Each `point_cloud_{i}.npz` has three arrays: |
| |
| | Key | Shape | Dtype | Description | |
| | ------------- | ------------ | ---------- | ----------------------------------------------------- | |
| | `points` | `(N, 3)` | `float32` | XYZ coordinates of STL surface points | |
| | `fields` | `(N, 5)` | `float32` | CFD surface fields interpolated to each STL point | |
| | `field_names` | `(5,)` | `str` | Names of the columns in `fields` | |
| |
| `N` varies per run (roughly 300k points, matching the STL resolution). |
| |
| The five field columns are: |
| |
| 1. `CpMeanTrim` — time-averaged pressure coefficient |
| 2. `wallShearStressMeanTrim_mag` — magnitude of time-averaged wall shear stress |
| 3. `wallShearStressMeanTrim_x` — x-component |
| 4. `wallShearStressMeanTrim_y` — y-component |
| 5. `wallShearStressMeanTrim_z` — z-component |
| |
| ## How the preprocessing works |
| |
| The original DrivAerML surface data is stored in **`boundary_{i}.vtp`**: a high-resolution (~8M point) mesh with CFD fields attached as **cell data**. The STL geometry **`drivaer_{i}.stl`** is a lower-resolution (~300k point) representation of the same surface but without any fields. |
| |
| To produce a clean point cloud where every geometry point carries its own CFD values, the pipeline runs the following per run: |
| |
| 1. Load the `.vtp` boundary mesh and the `.stl` geometry. |
| 2. Convert the VTP's cell-centered fields to point-centered via PyVista's `cell_data_to_point_data()` (averaging adjacent cells to the shared vertex). |
| 3. Build a `scipy.spatial.cKDTree` over the VTP point coordinates. |
| 4. For each STL point, take the **K=1 nearest neighbor** in the VTP point cloud and copy its field values. |
| 5. Save `points`, `fields`, and `field_names` as a compressed `.npz`. |
| 6. Delete the raw VTP and STL to keep disk usage bounded while processing. |
| |
| The K=1 nearest-neighbor mapping was chosen deliberately for **benchmark comparability** with existing DrivAerML / DrivAerNet++ leaderboard models (TripNet, FIGConvNet, RegDGCNN), all of which operate on the STL vertices directly. The nearest-neighbor distances are logged in `processing_log.json` for every run so this mapping can be audited. |
| |
| The 80/10/10 train/val/test split is computed with `numpy.random.default_rng(seed=42)` over a sorted list of successfully-processed run IDs, making it fully reproducible from the `splits.json` manifest. |
| |
| ## Loading |
| |
| ### With `datasets` (CSV force/moment preview only) |
| |
| The Hugging Face dataset loader will pick up the `force_mom_*.csv` files automatically: |
|
|
| ```python |
| from datasets import load_dataset |
| ds = load_dataset("Jrhoss/Drivaerml_point_clouds") |
| # ds["train"][0] -> {"Cd": 0.30, "Cl": 0.07, "Clf": -0.04, "Clr": 0.10, "Cs": 0.05} |
| ``` |
|
|
| ### Point clouds (recommended) |
|
|
| Clone the repo or snapshot-download it, then load `.npz` files directly: |
|
|
| ```python |
| from huggingface_hub import snapshot_download |
| import numpy as np |
| from pathlib import Path |
| |
| root = Path(snapshot_download("Jrhoss/Drivaerml_point_clouds", repo_type="dataset")) |
| |
| run = np.load(root / "train" / "run_1" / "point_cloud_1.npz", allow_pickle=True) |
| points = run["points"] # (N, 3) |
| fields = run["fields"] # (N, 5) |
| names = run["field_names"] # ['CpMeanTrim', 'wallShearStressMeanTrim_mag', ...] |
| ``` |
|
|
| ### Minimal PyTorch `Dataset` |
|
|
| ```python |
| import numpy as np |
| import pandas as pd |
| import torch |
| from pathlib import Path |
| from torch.utils.data import Dataset |
| |
| class DrivAerMLPointClouds(Dataset): |
| def __init__(self, root, split="train", n_points=16384): |
| self.run_dirs = sorted((Path(root) / split).glob("run_*"), |
| key=lambda p: int(p.name.split("_")[1])) |
| self.n_points = n_points |
| |
| def __len__(self): |
| return len(self.run_dirs) |
| |
| def __getitem__(self, idx): |
| run_dir = self.run_dirs[idx] |
| run_id = int(run_dir.name.split("_")[1]) |
| |
| npz = np.load(run_dir / f"point_cloud_{run_id}.npz", allow_pickle=True) |
| points, fields = npz["points"], npz["fields"] |
| |
| # Random subsample for batching |
| sel = np.random.choice(len(points), self.n_points, replace=False) |
| points, fields = points[sel], fields[sel] |
| |
| # Integrated force/moment coefficients |
| fm = pd.read_csv(run_dir / f"force_mom_{run_id}.csv").iloc[0] |
| coeffs = torch.tensor([fm["Cd"], fm["Cl"], fm["Clf"], fm["Clr"], fm["Cs"]], |
| dtype=torch.float32) |
| |
| return { |
| "points": torch.from_numpy(points), # (n_points, 3) |
| "fields": torch.from_numpy(fields), # (n_points, 5) |
| "coeffs": coeffs, # (5,) |
| "run_id": run_id, |
| } |
| ``` |
|
|
| ## Suggested tasks |
|
|
| - **Per-point surface field regression** — predict `CpMeanTrim` and wall shear stress vectors from geometry alone. Comparable to the TripNet / FIGConvNet / RegDGCNN benchmarks (which report ~20% relative L2 error). |
| - **Integrated coefficient regression** — predict `Cd`, `Cl`, etc. from the point cloud (global pooling over the surface). |
| - **Coupled prediction** — joint learning of per-point fields and integrated coefficients, using the integrated values as a physics-informed auxiliary loss. |
|
|
| ## Known limitations |
|
|
| - **K=1 interpolation is not exact.** It preserves the CFD field values faithfully where VTP and STL points are co-located, but introduces small errors at points where the STL has higher local resolution than the VTP. `processing_log.json` reports `nn_dist_mean`, `nn_dist_max`, and `nn_dist_p99` per run so you can filter out any pathological cases. |
| - **Fields are time-averaged only.** Transient information (e.g. unsteady vortex shedding in the wake) is not preserved; the source dataset contains scale-resolving data but only the trim-averaged fields are interpolated here. |
| - **Surface only.** The volumetric flow field (the 50 GB-per-run `volume_{i}.vtu`) is not included — go to the source dataset for volumetric surrogate modeling. |
|
|
| ## Reproducing this dataset |
|
|
| The full preprocessing script is shipped alongside this repo (`process_drivaerml.py`). To regenerate from scratch: |
|
|
| ```bash |
| pip install pyvista numpy scipy tqdm huggingface_hub |
| python process_drivaerml.py --output_dir ./drivaerml_processed --start 1 --end 500 |
| ``` |
|
|
| The script streams one run at a time — downloading the VTP + STL + force/moment CSV from `neashton/drivaerml`, producing the `.npz`, then deleting the raw files — so it runs comfortably in a few tens of GB of free disk regardless of total dataset size. |
|
|
| ## License |
|
|
| **CC-BY-SA 4.0**, inherited from the source dataset. If you use this data you must give appropriate credit, indicate any changes, and distribute any derivative works under the same license. |
|
|
| ## Citation |
|
|
| Please cite the original DrivAerML paper: |
|
|
| ```bibtex |
| @article{ashton2024drivaer, |
| title = {DrivAerML: High-Fidelity Computational Fluid Dynamics Dataset for Road-Car External Aerodynamics}, |
| author = {Ashton, N. and Mockett, C. and Fuchs, M. and Fliessbach, L. and Hetmann, H. |
| and Knacke, T. and Schonwald, N. and Skaperdas, V. and Fotiadis, G. |
| and Walle, A. and Hupertz, B. and Maddix, D.}, |
| journal = {arXiv preprint arXiv:2408.11969}, |
| year = {2024}, |
| url = {https://arxiv.org/abs/2408.11969} |
| } |
| ``` |
|
|
| ## Acknowledgments |
|
|
| All credit for the underlying CFD data goes to the DrivAerML team (Neil Ashton et al., AWS / UpstreamCFD / BETA-CAE / Siemens Energy / Ford). This repository only redistributes a preprocessed surface-point-cloud view of that work. For the full multi-terabyte dataset including volumetric fields, OpenFOAM meshes, slice images, and residual plots, see [`neashton/drivaerml`](https://huggingface.co/datasets/neashton/drivaerml). |
