Update README with full dataset card

README.md

@@ -0,0 +1,209 @@
+---
+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).