Add official deterministic dataset splits

.gitattributes

@@ -17262,3 +17262,4 @@ run_455/volume_455.vtu.01.part filter=lfs diff=lfs merge=lfs -text
 *.vtp filter=lfs diff=lfs merge=lfs -text
 *.vtu filter=lfs diff=lfs merge=lfs -text
 *.stl filter=lfs diff=lfs merge=lfs -text
+splits/README.pdf filter=lfs diff=lfs merge=lfs -text

README.md

@@ -58,6 +58,56 @@ In addition to the files per run folder, there are also:
 * force_mom_all.csv : forces/moments time-averaged (using varying frontal area/wheelbase) for all runs 
 * force_mom_constref_all.csv : forces/moments time-averaged (using constant frontal area/wheelbase) for all runs 
 * geo_parameters_all.csv: reference geometry values for each geometry for all runs 
+* [`splits/`](splits/): deterministic benchmark manifests, documentation, source metrics, diagnostic figures, and generation code.
+
+## Recommended dataset splits
+
+For reproducible machine-learning evaluation, DrivAerML provides eight
+deterministic split families in [`splits/manifest.json`](splits/manifest.json).
+Case identifiers match the top-level `run_N` directories.
+
+The split construction is based on the 484 publicly available runs. The 16
+unavailable or held-back runs are excluded from every partition. Reduced-data
+variants intentionally use subsets of the standard training population while
+retaining fixed validation and test sets.
+
+| Split | Type | Train | Validation | Test | Intended use |
+|---|---:|---:|---:|---:|---|
+| `full` | In-distribution | 400 | 34 | 50 | Seed-42 public baseline |
+| `medium` | In-distribution | 133 | 34 | 50 | Intermediate data-efficiency study |
+| `scarce` | In-distribution | 67 | 34 | 50 | Low-data study |
+| `super_scarce` | In-distribution | 11 | 34 | 50 | Extreme low-data study |
+| `geometry` | OOD | 339 | 48 | 97 | Extrapolation to locally isolated STL geometries |
+| `high_drag` | OOD | 339 | 48 | 97 | Extrapolation to the highest-drag regime |
+| `low_drag` | OOD | 339 | 48 | 97 | Extrapolation to the lowest-drag regime |
+| `rear_separation` | OOD | 339 | 48 | 97 | Extrapolation in image-derived wake and rear-separation behaviour |
+
+The data-efficiency training sets are nested:
+
+`super_scarce_train ⊂ scarce_train ⊂ medium_train ⊂ full_train`
+
+They share the same validation and test sets, allowing direct comparisons
+across training-set sizes. For the OOD splits, validation cases are sampled
+from the training-side population; the held-out extreme is reserved for final
+testing.
+
+Use `full` for a standard baseline, the nested sequence for data-efficiency
+studies, `geometry` for surface-shape extrapolation, `high_drag` or
+`low_drag` for coefficient-regime extrapolation, and `rear_separation` for
+flow-structure generalization.
+
+Download only the split package with:
+
+```bash
+hf download neashton/drivaerml \
+  --repo-type dataset \
+  --include "splits/**" \
+  --local-dir ./drivaerml
+```
+
+Complete definitions, construction methods, diagnostic figures, source
+metrics, and reproducibility instructions are provided in
+[`splits/README.md`](splits/README.md).
 
 How to download:
 ----------------
@@ -121,6 +171,8 @@ This dataset is provided under the CC BY SA 4.0 license, please see LICENSE.txt
 
 version history:
 ---------------
+* 17/08/2026 - Added deterministic official train/validation/test splits, including data-efficiency and out-of-distribution evaluation protocols.
+
 * 04/03/2025 - Now available on HuggingFace!
   
 * 11/11/2024 - the 15 of the 17 cases that were missing are being considered for use as a blind study. For the time-being these are available but password protected in the file blind_15additional_cases_passwd_required.zip. Once we setup a benchmarking sysystem we will provide details on how people can test their methods against these 15 blind cases. 
@@ -132,4 +184,3 @@ version history:
 * 29/07/2024 - Note: please be aware currently runs 167, 211, 218, 221, 248, 282, 291, 295, 316, 325, 329, 364, 370, 376, 403, 473 are not in the dataset. 
 
 * 03/05/2024 - draft version produced 
-

splits/README.md

@@ -0,0 +1,286 @@
+# DrivAerML dataset splits
+
+This directory provides deterministic train/validation/test splits for the
+[DrivAerML](https://huggingface.co/datasets/neashton/drivaerml) dataset. The
+authoritative assignments are stored in [`manifest.json`](manifest.json) as a
+flat JSON object whose keys follow the pattern
+`{split_name}_{train,val,test}`. Each value is a numerically sorted list of
+case identifiers matching the top-level `run_N` directories.
+
+DrivAerML contains 500 vehicle geometry variants at a fixed operating
+condition. The public force and moment table contains 484 runs. The 16
+unavailable or held-back cases are excluded from all published split
+assignments:
+
+`run_167`, `run_211`, `run_218`, `run_221`, `run_248`, `run_282`,
+`run_291`, `run_295`, `run_316`, `run_325`, `run_329`, `run_364`,
+`run_370`, `run_376`, `run_403`, and `run_473`.
+
+## Splits at a glance
+
+| Split | Type | Train | Validation | Test | Intended evaluation |
+|---|---:|---:|---:|---:|---|
+| `full` | In-distribution | 400 | 34 | 50 | Seed-42 public baseline |
+| `medium` | In-distribution | 133 | 34 | 50 | Intermediate data efficiency |
+| `scarce` | In-distribution | 67 | 34 | 50 | Low-data evaluation |
+| `super_scarce` | In-distribution | 11 | 34 | 50 | Extreme low-data evaluation |
+| `geometry` | OOD | 339 | 48 | 97 | STL-surface geometry extrapolation |
+| `high_drag` | OOD | 339 | 48 | 97 | High-drag extrapolation |
+| `low_drag` | OOD | 339 | 48 | 97 | Low-drag extrapolation |
+| `rear_separation` | OOD | 339 | 48 | 97 | Image-derived wake and rear-separation extrapolation |
+
+The data-efficiency training sets form a strict nested sequence:
+
+`super_scarce_train ⊂ scarce_train ⊂ medium_train ⊂ full_train`
+
+They use the same validation and test sets. For each out-of-distribution (OOD)
+split, validation is sampled from the training-side population rather than the
+extreme test region.
+
+## Selecting a split
+
+- Use `full` for a standard baseline or compatibility with the public
+  DrivAerML split used in Noether.
+- Compare `super_scarce`, `scarce`, `medium`, and `full` for a
+  controlled data-efficiency study.
+- Use `geometry` to assess extrapolation to surface geometries that are
+  locally isolated from the training population.
+- Use `high_drag` or `low_drag` to assess extrapolation to an extreme
+  integrated-force regime.
+- Use `rear_separation` to assess extrapolation in an image-derived
+  low-speed wake and rear-separation regime.
+
+Validation data may be used for model and hyperparameter selection. Test data
+should be reserved for final evaluation and should not inform normalization,
+feature design, or visual inspection-driven iteration.
+
+## Using the committed manifest
+
+Normal benchmark use requires only the committed manifest; split regeneration
+is not required.
+
+```python
+import json
+from pathlib import Path
+
+manifest = json.loads(Path("splits/manifest.json").read_text())
+
+train_ids = manifest["geometry_train"]
+val_ids = manifest["geometry_val"]
+test_ids = manifest["geometry_test"]
+```
+
+Change the `geometry` prefix to `full`, `medium`, `scarce`,
+`super_scarce`, `high_drag`, `low_drag`, or `rear_separation` to select
+another split.
+
+To download only these split artifacts:
+
+```bash
+hf download neashton/drivaerml \
+  --repo-type dataset \
+  --include "splits/**" \
+  --local-dir ./drivaerml
+```
+
+## Construction principles
+
+1. **Stable public baseline.** The `full` split preserves the established
+   seed-42 random public assignment.
+2. **In-distribution validation.** OOD validation cases come from the
+   training-side population.
+3. **Nested data-efficiency subsets.** Smaller training sets are strict
+   subsets of larger ones, with validation and test held fixed.
+4. **Direct geometry comparison.** The geometry OOD score is derived from
+   sampled STL surfaces rather than geometry parameters alone.
+5. **Dataset-defined physical quantities.** Drag-regime splits use the
+   published force and moment table.
+6. **Flow-structure information.** The rear-separation split uses fixed
+   flow-image diagnostics rather than an integrated coefficient.
+7. **Determinism and auditability.** The manifest, source metrics, generation
+   code, figures, and a PDF methods report are committed together.
+
+## Split definitions
+
+### `full`
+
+The baseline is a seeded random split over run identifiers rather than a
+physics-stratified split. It constructs `torch.randperm(500)` with seed 42,
+shifts the identifiers to `1..500`, removes the 16 unavailable cases, assigns
+the first 400 public identifiers to training, the next 50 to test, and the
+remaining 34 to validation. Identifiers are sorted before being written to the
+manifest.
+
+These assignments match the public
+[`DrivAerMLDefaultSplitIDs`](https://github.com/Emmi-AI/noether/blob/main/src/noether/data/datasets/cfd/caeml/drivaerml/split.py)
+implementation in Noether.
+
+### `medium`, `scarce`, and `super_scarce`
+
+These splits retain the `full` validation and test sets but reduce the
+training population to 133, 67, and 11 cases, respectively. A greedy max-min
+selection in standardized force and geometry-parameter space produces a
+single nested ordering. The features are `cd`, `cl`, `cs`, and the public
+geometry parameters.
+
+### `geometry`
+
+The geometry OOD split uses [`chamfer_metrics.csv`](chamfer_metrics.csv).
+Each public STL surface was sampled with 10,000 points using seed 42, without
+recentering, with global median bounding-box scaling. Pairwise surface
+difference is measured using symmetric Chamfer RMS distance.
+
+For run \(i\), the OOD score is the mean distance to its ten nearest
+neighbouring public geometries:
+
+```text
+geometry_score_i = mean_10_nearest_neighbors(chamfer_distance_i)
+```
+
+The top 20% by local-isolation score form the test set. Validation is a
+deterministic sample from the remaining training-side population:
+
+```text
+geometry_test  = top_20_percent(geometry_score)
+geometry_pool  = public_runs - geometry_test
+geometry_val   = deterministic_sample(geometry_pool, round(0.125 * len(geometry_pool)))
+geometry_train = geometry_pool - geometry_val
+```
+
+![Force and geometry split diagnostics](force_regimes.png)
+
+![Examples from the geometry split](geometry_split_examples.png)
+
+### `high_drag` and `low_drag`
+
+These splits rank public cases by drag coefficient `cd` from
+`force_mom_all.csv`. The `high_drag` split holds out the highest 20%; the
+`low_drag` split holds out the lowest 20%. In each case, validation is sampled
+from the complementary training-side population.
+
+### `rear_separation`
+
+The rear-separation split uses [`image_metrics.csv`](image_metrics.csv) to
+characterize low-speed wake and rear-separation extent. The score combines:
+
+- 60% centreline low-speed wake area from the `y=0` normalized
+  velocity-magnitude image; and
+- 40% mean low-speed area from seven near-rear `xNormal` images at positions
+  `p43000` through `p55000`.
+
+The highest-scoring 20% of public runs form the test set. Validation is sampled
+from the remaining training-side population. The metrics CSV records whether
+each value was observed or imputed; the committed table contains observed
+scores for all 484 public runs.
+
+![Rear-separation score and drag distributions](image_regimes.png)
+
+![Examples from the image-derived split](image_split_examples.png)
+
+## Reproducibility
+
+The committed [`manifest.json`](manifest.json) is the source of truth. The
+following procedure is provided to audit the construction or regenerate the
+artifacts.
+
+Install the lightweight generation and plotting dependencies:
+
+```bash
+python3 -m pip install numpy matplotlib pillow
+```
+
+From the dataset repository root, download the two aggregate source tables and
+regenerate the manifest and diagnostic plots:
+
+```bash
+python3 splits/download_hf_inputs.py --output-dir data
+python3 splits/generate_splits.py
+python3 splits/visualize_flow_regimes.py
+python3 splits/visualize_image_regimes.py
+```
+
+The commands above use the committed Chamfer and rear-separation metrics.
+Download the selected source images to recreate the example figures:
+
+```bash
+python3 splits/download_hf_inputs.py --output-dir data --include-report-images
+python3 splits/visualize_geometry_examples.py
+python3 splits/visualize_split_examples.py
+```
+
+Rebuild the PDF report with:
+
+```bash
+latexmk -pdf -cd splits/README.tex
+```
+
+For an existing dataset checkout in another location, set
+`DRIVAERML_DATA_ROOT` to the directory containing `force_mom_all.csv` and
+`geo_parameters_all.csv`. If the source PNGs are elsewhere, set
+`DRIVAERML_IMAGE_ROOT` to the directory containing `run_*/images/`.
+
+To recompute the rear-separation metrics from the source images:
+
+```bash
+python3 splits/download_hf_inputs.py --output-dir data --include-image-score-pngs
+python3 splits/generate_splits.py
+```
+
+Full STL-based Chamfer recomputation additionally requires SciPy and trimesh:
+
+```bash
+python3 -m pip install numpy scipy trimesh
+python3 splits/download_hf_inputs.py \
+  --output-dir /tmp/drivaerml_inputs \
+  --include-stls
+python3 splits/compute_chamfer_splits.py \
+  --data-root /tmp/drivaerml_inputs \
+  --output-dir /tmp/drivaerml_chamfer \
+  --samples 10000 \
+  --workers 16 \
+  --base-manifest splits/manifest.json
+cp /tmp/drivaerml_chamfer/chamfer_metrics.csv splits/chamfer_metrics.csv
+```
+
+The STL download and all-pairs Chamfer calculation are substantially more
+expensive than normal manifest use and are not required to use the published
+splits.
+
+## Manifest format
+
+```json
+{
+  "full_train": ["run_1", "run_2"],
+  "full_val": ["run_4"],
+  "full_test": ["run_11"],
+  "geometry_train": ["run_1"],
+  "geometry_val": ["run_4"],
+  "geometry_test": ["run_65"]
+}
+```
+
+The abbreviated example above illustrates the schema only. The committed
+manifest contains the complete case lists for all eight split families.
+
+## Supporting files
+
+- [`README.pdf`](README.pdf): typeset methods report.
+- [`README.tex`](README.tex): LaTeX source for the report.
+- [`chamfer_metrics.csv`](chamfer_metrics.csv): STL-surface geometry scores.
+- [`image_metrics.csv`](image_metrics.csv): rear-separation scores and
+  observation flags.
+- [`generate_splits.py`](generate_splits.py): deterministic manifest
+  generator and validation logic.
+- [`compute_chamfer_splits.py`](compute_chamfer_splits.py): standalone
+  STL-surface metric generator.
+- [`download_hf_inputs.py`](download_hf_inputs.py): selective source-data
+  downloader.
+- `visualize_*.py`: diagnostic and example-figure generators.
+
+## References
+
+- N. Ashton et al., “DrivAerML: High-Fidelity Computational Fluid Dynamics
+  Dataset for Road-Car External Aerodynamics,” 2024.
+  [arXiv:2408.11969](https://arxiv.org/abs/2408.11969).
+- [DrivAerML dataset](https://huggingface.co/datasets/neashton/drivaerml).
+- [Noether DrivAerML split implementation](https://github.com/Emmi-AI/noether/blob/main/src/noether/data/datasets/cfd/caeml/drivaerml/split.py).

splits/README.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f858dca18a2ad8aee76cc5103ef51dca2c05ec780066cebcc58b200ddd9b3f2
+size 1415402

splits/README.tex

@@ -0,0 +1,362 @@
+\documentclass[10pt]{article}
+
+\usepackage[margin=0.72in]{geometry}
+\usepackage{booktabs}
+\usepackage{caption}
+\usepackage{enumitem}
+\usepackage{float}
+\usepackage[T1]{fontenc}
+\usepackage{graphicx}
+\usepackage{hyperref}
+\usepackage{microtype}
+\usepackage{tabularx}
+\usepackage{xcolor}
+
+\hypersetup{
+  colorlinks=true,
+  linkcolor=blue!55!black,
+  urlcolor=blue!55!black,
+  citecolor=blue!55!black
+}
+
+\setlength{\parindent}{0pt}
+\setlength{\parskip}{0.55em}
+\setlength{\emergencystretch}{2em}
+\setlist[itemize]{leftmargin=1.35em, itemsep=0.22em, topsep=0.25em}
+\captionsetup{font=small, labelfont=bf}
+
+\newcommand{\code}[1]{\texttt{#1}}
+\newcommand{\splitkey}[1]{\texttt{#1}}
+
+\title{\vspace{-1.2em}\textbf{DrivAerML Dataset Splits}}
+\author{}
+\date{}
+
+\begin{document}
+\maketitle
+\vspace{-2.0em}
+
+Deterministic train/validation/test splits for the
+\href{https://huggingface.co/datasets/neashton/drivaerml}{DrivAerML} dataset
+\cite{drivaerml_dataset}. The split manifest is stored at
+\code{splits/manifest.json} as a flat JSON object with keys named
+\code{\{split\_name\}\_\{train,val,test\}} and case IDs that match the on-disk
+run directories.
+
+DrivAerML contains 500 vehicle geometry variants at a fixed operating
+condition. The public force/moment table has 484 rows; the missing 16 runs are
+unavailable author-held-back cases and are excluded from all public
+train/validation/test splits. The geometry-parameter table contains all 500
+design rows and is used for nested data-efficiency subset selection and
+image-score imputation. The \splitkey{geometry} split itself uses sampled
+STL-surface Chamfer distances to measure how different each public geometry is
+from its neighbors.
+
+\section*{Splits at a glance}
+
+\begin{tabularx}{\textwidth}{@{}l l r r r X@{}}
+\toprule
+Split & Type & Train & Val & Test & What it tests \\
+\midrule
+\splitkey{full} & In-dist & 400 & 34 & 50 & Seed-42 random public baseline split \\
+\splitkey{medium} & In-dist & 133 & 34 & 50 & Data efficiency, 1/3 of \splitkey{full} training data \\
+\splitkey{scarce} & In-dist & 67 & 34 & 50 & Data efficiency, 1/6 of \splitkey{full} training data \\
+\splitkey{super\_scarce} & In-dist & 11 & 34 & 50 & Extreme data efficiency, 1/36 of \splitkey{full} training data \\
+\splitkey{geometry} & OOD & 339 & 48 & 97 & STL-surface Chamfer extrapolation using the top 20\% local-isolation distance \\
+\splitkey{high\_drag} & OOD & 339 & 48 & 97 & High-drag extrapolation using the top 20\% \code{cd} \\
+\splitkey{low\_drag} & OOD & 339 & 48 & 97 & Low-drag extrapolation using the bottom 20\% \code{cd} \\
+\splitkey{rear\_separation} & OOD & 339 & 48 & 97 & Image-derived low-speed wake and rear-separation extent \\
+\bottomrule
+\end{tabularx}
+
+\textbf{Difficulty ladders:}
+\begin{itemize}
+  \item Data efficiency: \splitkey{full} < \splitkey{medium} < \splitkey{scarce} < \splitkey{super\_scarce}, with fixed validation/test sets.
+  \item OOD physics: \splitkey{geometry}, \splitkey{high\_drag}, \splitkey{low\_drag}, and \splitkey{rear\_separation}.
+\end{itemize}
+
+\section*{Which split should I use?}
+
+\begin{itemize}
+  \item \textbf{Simple baseline or literature compatibility}: \splitkey{full}
+  \item \textbf{Data efficiency study}: compare \splitkey{super\_scarce}, \splitkey{scarce}, \splitkey{medium}, and \splitkey{full}
+  \item \textbf{Geometry extrapolation}: \splitkey{geometry}
+  \item \textbf{Image-observed rear-separation regimes}: \splitkey{rear\_separation}
+  \item \textbf{Targeted coefficient extrapolation}: \splitkey{high\_drag} or \splitkey{low\_drag}
+\end{itemize}
+
+\section*{Using the committed splits}
+
+For standard benchmark use, consume the committed manifest at
+\code{splits/manifest.json}; no regeneration is required. The manifest is the
+source of truth for all split membership and contains one train, validation,
+and test key for each split listed above.
+
+\begin{verbatim}
+import json
+from pathlib import Path
+
+manifest = json.loads(Path("splits/manifest.json").read_text())
+
+train_ids = manifest["geometry_train"]
+val_ids = manifest["geometry_val"]
+test_ids = manifest["geometry_test"]
+\end{verbatim}
+
+Change the \code{geometry} prefix to \code{full}, \code{medium},
+\code{scarce}, \code{super\_scarce}, \code{high\_drag}, \code{low\_drag}, or
+\code{rear\_separation} to select a different split. Each value is a sorted
+list of \code{run\_N} directory names. The manifest already excludes the 16
+unavailable held-back cases, so users should not filter those IDs again unless
+their local dataset copy is incomplete.
+
+\section*{Design principles}
+
+\begin{itemize}
+  \item \textbf{Validation is always in-distribution with train.} For OOD splits, the validation set is drawn from the training-side population, not from the extreme OOD test region.
+  \item \textbf{Keep the public baseline stable.} \splitkey{full} is a seed-42 random public split: 400 train, 34 validation, 50 test, with the 16 unavailable cases excluded.
+  \item \textbf{Use direct surface distances for geometry OOD.} \splitkey{geometry} ranks public STL surfaces by nearest-neighbor Chamfer isolation, which is a stronger geometry-difference signal than parameter-space distance alone.
+  \item \textbf{Use the dataset metadata directly where it defines the split axis.} Force-regime splits are generated from \code{force\_mom\_all.csv}. The \splitkey{geometry} split is generated from STL-surface Chamfer scores in \code{chamfer\_metrics.csv}; \code{geo\_parameters\_all.csv} supports the nested data-efficiency subsets and image-score imputation.
+  \item \textbf{Use flow images as physics labels.} The retained image-derived split scores low-speed recirculation/separation extent from centreline and near-rear velocity-magnitude PNGs.
+  \item \textbf{Represent DrivAerML physics.} The retained OOD axes target surface-shape novelty, high- and low-drag regimes, and visible rear-separation flow structure.
+  \item \textbf{Nested data-efficiency subsets.} \splitkey{super\_scarce\_train} is a strict subset of \splitkey{scarce\_train}, \splitkey{scarce\_train} is a strict subset of \splitkey{medium\_train}, and \splitkey{medium\_train} is a strict subset of \splitkey{full\_train}.
+  \item \textbf{Test set integrity.} Test cases should not be used for hyperparameter tuning, model selection, normalization fitting, or visual inspection-driven iteration.
+\end{itemize}
+
+\section*{Split details}
+
+\subsection*{\splitkey{full}}
+
+The default public split is a seeded random split over run IDs, not a
+physics-stratified split. It constructs \code{torch.randperm(500)} with seed
+42, shifts the IDs to \code{1..500}, removes the 16 unavailable hidden cases,
+then assigns the first 400 public IDs to train, the next 50 to test, and the
+remaining 34 to validation. The case IDs are sorted before being stored in the
+manifest. For reference, these IDs match the public
+\href{https://github.com/Emmi-AI/noether/blob/main/src/noether/data/datasets/cfd/caeml/drivaerml/split.py}{DrivAerMLDefaultSplitIDs}
+implementation in Noether \cite{noether_split}.
+
+\subsection*{\splitkey{medium}, \splitkey{scarce}, and \splitkey{super\_scarce}}
+
+Same validation/test as \splitkey{full}, but the training set is a nested
+force- and geometry-diverse subset of \splitkey{full\_train}: 133 cases for
+\splitkey{medium}, 67 cases for \splitkey{scarce}, and 11 cases for
+\splitkey{super\_scarce}. The subset order is a greedy max-min selection in
+standardized force/geometry feature space using \code{cd}, \code{cl},
+\code{cs}, and all public geometry parameters.
+
+By construction, \splitkey{super\_scarce\_train} is a subset of
+\splitkey{scarce\_train}, \splitkey{scarce\_train} is a subset of
+\splitkey{medium\_train}, and \splitkey{medium\_train} is a subset of
+\splitkey{full\_train}.
+
+\subsection*{\splitkey{geometry}}
+
+The preferred geometry OOD split when STL-derived geometry metrics are
+available. It uses \code{chamfer\_metrics.csv}, where each public run is
+represented by deterministic surface samples from its STL mesh. The committed
+metrics were generated with 10,000 surface samples per public run, seed 42, no
+recentering, global median bounding-box scaling, and symmetric Chamfer RMS
+distances.
+
+The split uses \code{ood\_score}, currently the mean distance to the 10 nearest
+neighboring public geometries:
+
+\begin{verbatim}
+geometry_score_i = mean_10_nearest_neighbors(chamfer_distance_i)
+\end{verbatim}
+
+The top 20\% of public runs by this local-isolation score form the OOD test
+set. Validation is sampled from the remaining training-side pool:
+
+\begin{verbatim}
+geometry_test  = top_20_percent_i(geometry_score_i)
+geometry_pool  = public_runs - geometry_test
+geometry_val   = deterministic_random_sample(geometry_pool, round(0.125 * |geometry_pool|))
+geometry_train = geometry_pool - geometry_val
+\end{verbatim}
+
+This split captures surface-level differences that may not dominate
+standardized parameter distances. In the current Chamfer metrics, the most
+locally isolated public geometries include \splitkey{run\_393},
+\splitkey{run\_65}, \splitkey{run\_129}, \splitkey{run\_293},
+\splitkey{run\_439}, \splitkey{run\_345}, \splitkey{run\_495}, and
+\splitkey{run\_237}. Figure~\ref{fig:force_geometry} shows the geometry split
+both against \code{Cd} and against the Chamfer score used to define the
+holdout, and Figure~\ref{fig:geometry_examples} shows complete-car examples
+from the low-score training side and high-score geometry-test side, including a
+same-crop transparent overlay.
+
+\subsection*{\splitkey{high\_drag} and \splitkey{low\_drag}}
+
+Both splits sort public cases by drag coefficient \code{cd}.
+\splitkey{high\_drag} holds out the top 20\% by \code{cd};
+\splitkey{low\_drag} holds out the bottom 20\% by \code{cd}. In both cases,
+train/validation are sampled from the complementary 80\% so validation remains
+in-distribution with training. Figure~\ref{fig:force_geometry} shows these
+holdouts across run IDs.
+
+In the current CSV, the highest-drag public runs include \splitkey{run\_115},
+\splitkey{run\_39}, \splitkey{run\_29}, \splitkey{run\_186}, and
+\splitkey{run\_226}. The lowest-drag public runs include \splitkey{run\_289},
+\splitkey{run\_159}, \splitkey{run\_10}, \splitkey{run\_345}, and
+\splitkey{run\_426}.
+
+\begin{figure}[H]
+  \centering
+  \includegraphics[width=0.96\textwidth]{force_regimes.png}
+  \caption{Force and geometry split diagnostics. The panels show the full random baseline, high-drag holdout, low-drag holdout, geometry holdout on \code{Cd}, and geometry holdout on STL-surface Chamfer score. The x-axis is run ID, and points are colored by each split's train, validation, and test partitions.}
+  \label{fig:force_geometry}
+\end{figure}
+
+\begin{figure}[H]
+  \centering
+  \includegraphics[width=\textwidth]{geometry_split_examples.png}
+  \caption{Geometry split examples. The low-score training-side case is \splitkey{run\_294} (\code{geometry\_score=0.007373}, \code{Cd=0.281193}, \code{Cl=-0.017952}), and the high-score geometry-test case is \splitkey{run\_393} (\code{geometry\_score=0.011422}, \code{Cd=0.285732}, \code{Cl=0.052227}). The bottom panel overlays the same-crop side views with \splitkey{run\_294} in blue and \splitkey{run\_393} in orange.}
+  \label{fig:geometry_examples}
+\end{figure}
+
+\subsection*{Image-derived flow-regime split}
+
+The image-derived split is intended to capture a visible flow-physics regime
+that is not fully described by high or low integrated coefficients. It uses
+selected PNG diagnostics from each \code{run\_*/images/} folder, and
+Figure~\ref{fig:image_regime} shows the resulting rear-separation score
+distribution plus the same train/validation/test membership against \code{Cd}:
+
+\begin{itemize}
+  \item \splitkey{rear\_separation}: low-speed wake area from the \code{y=0} centreline velocity-magnitude PNG and seven near-rear \code{xNormal} velocity-magnitude PNGs (\code{p43000} through \code{p55000}).
+\end{itemize}
+
+The score estimates recirculation/separation size by counting the low-speed
+blue/cyan/green part of the fixed \code{|U|/U0} colormap. The committed score
+combines 60\% centreline wake area with 40\% mean near-rear \code{xNormal}
+low-speed area.
+
+For this score, the top 20\% of public runs are held out as test. Validation is
+sampled from the remaining 80\%.
+
+\begin{figure}[H]
+  \centering
+  \includegraphics[width=0.96\textwidth]{image_regimes.png}
+  \caption{Image-derived rear-separation split diagnostics. The left panel shows the rear-separation score used for the holdout, and the right panel shows \code{Cd} for the same \splitkey{rear\_separation\_train}, \splitkey{rear\_separation\_val}, and \splitkey{rear\_separation\_test} partitions.}
+  \label{fig:image_regime}
+\end{figure}
+
+Figure~\ref{fig:image_examples} shows centreline \code{y=0}
+velocity-magnitude slices for observed low-score and high-score cases from the
+image-derived metric.
+
+\begin{figure}[H]
+  \centering
+  \includegraphics[width=\textwidth]{image_split_examples.png}
+  \caption{Centreline velocity-magnitude examples for low and high rear-separation scores. The low-score case is \splitkey{run\_100} (\code{Cd=0.292211}, \code{Cl=0.147656}), and the high-score case is \splitkey{run\_406} (\code{Cd=0.266587}, \code{Cl=0.019273}).}
+  \label{fig:image_examples}
+\end{figure}
+
+\section*{Repeatability and transparency}
+
+The committed manifest is intended for normal use. The commands below are for
+auditing the split construction, recreating the figures, or refreshing the
+artifacts after changing the source data.
+
+From a clean split-package checkout, download \code{force\_mom\_all.csv} and
+\code{geo\_parameters\_all.csv} from the Hugging Face dataset repo and then
+regenerate the manifest and diagnostic plots:
+
+\begin{verbatim}
+python3 splits/download_hf_inputs.py --output-dir data
+python3 splits/generate_splits.py
+python3 splits/visualize_flow_regimes.py
+python3 splits/visualize_image_regimes.py
+\end{verbatim}
+
+This exact path uses committed Chamfer geometry scores and committed
+rear-separation image scores. To render the example figures from source PNGs
+rather than placeholders, also run:
+
+\begin{verbatim}
+python3 splits/download_hf_inputs.py --output-dir data --include-report-images
+python3 splits/visualize_geometry_examples.py
+python3 splits/visualize_split_examples.py
+\end{verbatim}
+
+Full report regeneration then uses:
+
+\begin{verbatim}
+python3 splits/generate_splits.py
+python3 splits/visualize_flow_regimes.py
+python3 splits/visualize_geometry_examples.py
+python3 splits/visualize_image_regimes.py
+python3 splits/visualize_split_examples.py
+latexmk -pdf -cd splits/README.tex
+\end{verbatim}
+
+For an existing dataset checkout, set \code{DRIVAERML\_DATA\_ROOT} to the
+directory containing \code{force\_mom\_all.csv} and
+\code{geo\_parameters\_all.csv}. If the PNGs live elsewhere, set
+\code{DRIVAERML\_IMAGE\_ROOT} to the directory containing
+\code{run\_*/images/}.
+
+To recompute \code{splits/image\_metrics.csv} from source images, use:
+
+\begin{verbatim}
+python3 splits/download_hf_inputs.py --output-dir data --include-image-score-pngs
+python3 splits/generate_splits.py
+\end{verbatim}
+
+To recompute the Chamfer source data from STL meshes, run the standalone
+surface-distance script in a work directory and refresh only the metrics CSV
+used by the split generator:
+
+\begin{verbatim}
+python3 splits/download_hf_inputs.py --output-dir /tmp/drivaerml_inputs --include-stls
+mkdir -p /tmp/drivaerml_chamfer
+python3 splits/compute_chamfer_splits.py \
+  --data-root /tmp/drivaerml_inputs \
+  --output-dir /tmp/drivaerml_chamfer \
+  --samples 10000 \
+  --workers 16 \
+  --base-manifest splits/manifest.json
+cp /tmp/drivaerml_chamfer/chamfer_metrics.csv splits/chamfer_metrics.csv
+\end{verbatim}
+
+The committed source artifacts were generated against a local checkout with:
+
+\begin{verbatim}
+<dataset-root>/force_mom_all.csv
+<dataset-root>/geo_parameters_all.csv
+<dataset-root>/splits/chamfer_metrics.csv
+<dataset-root>/splits/manifest.json
+<image-root>/run_*/images/
+\end{verbatim}
+
+\section*{Manifest format}
+
+\begin{verbatim}
+{
+    "full_train": ["run_1", "run_2", "..."],
+    "full_val": ["run_4", "..."],
+    "full_test": ["run_11", "..."],
+    "scarce_train": ["run_10", "..."]
+}
+\end{verbatim}
+
+Case IDs match on-disk directory names and are sorted numerically by run number.
+
+\begin{thebibliography}{9}
+\bibitem{drivaerml_dataset}
+DrivAerML dataset. \url{https://huggingface.co/datasets/neashton/drivaerml}.
+
+\bibitem{drivaerml_paper}
+DrivAerML paper. \url{https://arxiv.org/abs/2408.11969}.
+
+\bibitem{noether_split}
+Noether DrivAerML split. \url{https://github.com/Emmi-AI/noether/blob/main/src/noether/data/datasets/cfd/caeml/drivaerml/split.py}.
+
+\bibitem{physicsnemo_loader}
+PhysicsNeMo DrivAerNet/DrivAerML-style split loader.
+\url{https://docs.nvidia.com/deeplearning/physicsnemo/physicsnemo-core/_modules/physicsnemo/datapipes/gnn/drivaernet_dataset.html}.
+\end{thebibliography}
+
+\end{document}

splits/chamfer_metrics.csv

@@ -0,0 +1,485 @@
+run,nearest_neighbor_chamfer,mean_10_nn_chamfer,mean_all_chamfer,medoid_chamfer,medoid_run,ood_score
+1,0.007728395517915487,0.008212374523282051,0.014261526055634022,0.012437675148248672,294,0.008212374523282051
+2,0.007664899807423353,0.008202708326280117,0.012909170240163803,0.0117068812251091,294,0.008202708326280117
+3,0.007015416398644447,0.007785084191709757,0.014882386662065983,0.0125005804002285,294,0.007785084191709757
+4,0.006997725926339626,0.007555538322776556,0.012383533641695976,0.007999238558113575,294,0.007555538322776556
+5,0.007902598939836025,0.008317304775118828,0.01508842408657074,0.013258375227451324,294,0.008317304775118828
+6,0.0070487139746546745,0.008031521923840046,0.011926145292818546,0.008692706935107708,294,0.008031521923840046
+7,0.00693513685837388,0.0073768338188529015,0.014092350378632545,0.011230621486902237,294,0.0073768338188529015
+8,0.007733411155641079,0.00816173292696476,0.014925297349691391,0.013717438094317913,294,0.00816173292696476
+9,0.007255421951413155,0.007551925722509623,0.012757613323628902,0.011809422634541988,294,0.007551925722509623
+10,0.00789411086589098,0.008082995191216469,0.013038849458098412,0.00977280829101801,294,0.008082995191216469
+11,0.008024632930755615,0.008651791140437126,0.013939721509814262,0.012808147817850113,294,0.008651791140437126
+12,0.00727294385433197,0.00773902703076601,0.012483862228691578,0.009697002358734608,294,0.00773902703076601
+13,0.007272020913660526,0.007541449274867773,0.012996809557080269,0.008965196087956429,294,0.007541449274867773
+14,0.007471530232578516,0.008153184317052364,0.013021936640143394,0.011648672632873058,294,0.008153184317052364
+15,0.007168072275817394,0.007896794937551022,0.012682412751019001,0.010203680023550987,294,0.007896794937551022
+16,0.007748429197818041,0.008129313588142395,0.013905240222811699,0.010548735968768597,294,0.008129313588142395
+17,0.007289710454642773,0.00791021715849638,0.014032517559826374,0.013342821970582008,294,0.00791021715849638
+18,0.006974077317863703,0.00795731134712696,0.014629524201154709,0.010785248130559921,294,0.00795731134712696
+19,0.00737164169549942,0.007990507408976555,0.014471451751887798,0.012441612780094147,294,0.007990507408976555
+20,0.007422759663313627,0.007922740653157234,0.012491573579609394,0.008519532158970833,294,0.007922740653157234
+21,0.00709755951538682,0.007848331704735756,0.01289029885083437,0.010429523885250092,294,0.007848331704735756
+22,0.007199769373983145,0.007722700946033001,0.011888345703482628,0.008776996284723282,294,0.007722700946033001
+23,0.007532700430601835,0.007921579293906689,0.013541990891098976,0.010390311479568481,294,0.007921579293906689
+24,0.0075135985389351845,0.00828961469233036,0.014589294791221619,0.014523287303745747,294,0.00828961469233036
+25,0.007920104078948498,0.008761165663599968,0.016238275915384293,0.015917280688881874,294,0.008761165663599968
+26,0.007575778756290674,0.007794989738613367,0.011827322654426098,0.007973658852279186,294,0.007794989738613367
+27,0.007076209876686335,0.00784569513052702,0.01639395020902157,0.013411223888397217,294,0.00784569513052702
+28,0.007739785593003035,0.008414610289037228,0.014245412312448025,0.013596558012068272,294,0.008414610289037228
+29,0.0076815346255898476,0.008371112868189812,0.015210100449621677,0.011812552809715271,294,0.008371112868189812
+30,0.007743602618575096,0.007991025224328041,0.013702129945158958,0.012982137501239777,294,0.007991025224328041
+31,0.007485717069357634,0.00799345038831234,0.012806684710085392,0.010439479723572731,294,0.00799345038831234
+32,0.007131264545023441,0.007737527601420879,0.013650596141815186,0.011077373288571835,294,0.007737527601420879
+33,0.007574280723929405,0.007976179011166096,0.013188943266868591,0.011190058663487434,294,0.007976179011166096
+34,0.007321704179048538,0.008255972526967525,0.01416583452373743,0.013094612397253513,294,0.008255972526967525
+35,0.00746291084215045,0.008180354721844196,0.01318647712469101,0.010989734902977943,294,0.008180354721844196
+36,0.007331960368901491,0.0077897049486637115,0.012653619982302189,0.009535702876746655,294,0.0077897049486637115
+37,0.006878306623548269,0.007992558181285858,0.01483813114464283,0.012622697278857231,294,0.007992558181285858
+38,0.007216934580355883,0.007996181026101112,0.012061328627169132,0.009241960011422634,294,0.007996181026101112
+39,0.0077361236326396465,0.00840417854487896,0.014964241534471512,0.011535460129380226,294,0.00840417854487896
+40,0.007408876903355122,0.007991618476808071,0.013754652813076973,0.012711020186543465,294,0.007991618476808071
+41,0.007660582661628723,0.008226067759096622,0.014506381936371326,0.014615525491535664,294,0.008226067759096622
+42,0.006929978262633085,0.00739819323644042,0.01229726243764162,0.007422067224979401,294,0.00739819323644042
+43,0.00794073473662138,0.00832408107817173,0.013721857219934464,0.010084155946969986,294,0.00832408107817173
+44,0.00732328649610281,0.00776233384385705,0.01232525147497654,0.00972388219088316,294,0.00776233384385705
+45,0.007921513170003891,0.008382773026823997,0.012798807583749294,0.009689154103398323,294,0.008382773026823997
+46,0.007792997639626265,0.008158780634403229,0.013262392953038216,0.011538083665072918,294,0.008158780634403229
+47,0.007184433285146952,0.007991562597453594,0.013408348895609379,0.01073254644870758,294,0.007991562597453594
+48,0.007029158994555473,0.007727284915745258,0.014108650386333466,0.012053282000124454,294,0.007727284915745258
+49,0.0075493198819458485,0.008368716575205326,0.014957522042095661,0.013698498718440533,294,0.008368716575205326
+50,0.0070931329391896725,0.007763892412185669,0.012690161354839802,0.008022438734769821,294,0.007763892412185669
+51,0.007533975876867771,0.007985441014170647,0.015239845961332321,0.014108565635979176,294,0.007985441014170647
+52,0.00725707458332181,0.007726764772087336,0.012599979527294636,0.009950464591383934,294,0.007726764772087336
+53,0.007356319576501846,0.008459018543362617,0.01569417677819729,0.011601983569562435,294,0.008459018543362617
+54,0.007650733459740877,0.007913883775472641,0.012465834617614746,0.011255497112870216,294,0.007913883775472641
+55,0.007016252260655165,0.0075194574892520905,0.012479572556912899,0.00942949764430523,294,0.0075194574892520905
+56,0.00704995496198535,0.008184889331459999,0.014749651774764061,0.011597029864788055,294,0.008184889331459999
+57,0.007801860570907593,0.008126075379550457,0.01392390951514244,0.013505974784493446,294,0.008126075379550457
+58,0.00716890674084425,0.008085156790912151,0.012456921860575676,0.009097958914935589,294,0.008085156790912151
+59,0.007236821576952934,0.00767323886975646,0.012966386042535305,0.009074924513697624,294,0.00767323886975646
+60,0.007426557131111622,0.008167689666152,0.013767154887318611,0.012737604789435863,294,0.008167689666152
+61,0.00735390605404973,0.00787247996777296,0.01379450410604477,0.01129736378788948,294,0.00787247996777296
+62,0.00727149099111557,0.0081231240183115,0.016047663986682892,0.013682506047189236,294,0.0081231240183115
+63,0.007262872532010078,0.008030381053686142,0.015138298273086548,0.013814812526106834,294,0.008030381053686142
+64,0.0074022309854626656,0.007811641786247492,0.012393932789564133,0.009733350947499275,294,0.007811641786247492
+65,0.007899971678853035,0.009302036836743355,0.017681701108813286,0.016726667061448097,294,0.009302036836743355
+66,0.007321704179048538,0.0077241696417331696,0.012905162759125233,0.011428514495491982,294,0.0077241696417331696
+67,0.007015416398644447,0.008072501048445702,0.01560369972139597,0.013476140797138214,294,0.008072501048445702
+68,0.00737770413979888,0.007777781691402197,0.012523147277534008,0.00961744412779808,294,0.007777781691402197
+69,0.007328914478421211,0.008150222711265087,0.013534970581531525,0.009832705371081829,294,0.008150222711265087
+70,0.007216934580355883,0.007653999142348766,0.011416745372116566,0.008235152810811996,294,0.007653999142348766
+71,0.00693513685837388,0.007452091667801142,0.014121947810053825,0.011374661698937416,294,0.007452091667801142
+72,0.00810476578772068,0.008460099808871746,0.015231290832161903,0.01484975591301918,294,0.008460099808871746
+73,0.00732036679983139,0.008016707375645638,0.012935783714056015,0.012074887752532959,294,0.008016707375645638
+74,0.006929978262633085,0.007553833071142435,0.012680578045547009,0.00794018991291523,294,0.007553833071142435
+75,0.008112262934446335,0.008683102205395699,0.01564272865653038,0.014364113099873066,294,0.008683102205395699
+76,0.007272126618772745,0.007746163755655289,0.013457264751195908,0.01175136398524046,294,0.007746163755655289
+77,0.007377350702881813,0.008025207556784153,0.014657053165137768,0.01114897895604372,294,0.008025207556784153
+78,0.007906965911388397,0.008321365341544151,0.013355656526982784,0.012093381024897099,294,0.008321365341544151
+79,0.007168072275817394,0.0077778929844498634,0.013301125727593899,0.01121202576905489,294,0.0077778929844498634
+80,0.007029158994555473,0.008164644241333008,0.015172239392995834,0.013183604925870895,294,0.008164644241333008
+81,0.007289710454642773,0.00804672297090292,0.013720928691327572,0.013072694651782513,294,0.00804672297090292
+82,0.00742846354842186,0.008091253228485584,0.014444136060774326,0.010362955741584301,294,0.008091253228485584
+83,0.007215574383735657,0.008206847123801708,0.015233112499117851,0.014003067277371883,294,0.008206847123801708
+84,0.0071235946379601955,0.007794229779392481,0.012015723623335361,0.007884299382567406,294,0.007794229779392481
+85,0.0073935892432928085,0.008155920542776585,0.014268298633396626,0.010605338029563427,294,0.008155920542776585
+86,0.007128113880753517,0.007635907270014286,0.011721073649823666,0.008716939017176628,294,0.007635907270014286
+87,0.007421648595482111,0.007791603449732065,0.012465130537748337,0.009543664753437042,294,0.007791603449732065
+88,0.008227044716477394,0.008690702728927135,0.015275741927325726,0.014855543151497841,294,0.008690702728927135
+89,0.0078089796006679535,0.008282346650958061,0.015326397493481636,0.015156183391809464,294,0.008282346650958061
+90,0.007243150379508734,0.007883479818701744,0.01241093035787344,0.00924257654696703,294,0.007883479818701744
+91,0.007236821576952934,0.007733125239610672,0.0130575280636549,0.008879030123353004,294,0.007733125239610672
+92,0.0075300103053450584,0.007982633076608181,0.012791876681149006,0.011037178337574005,294,0.007982633076608181
+93,0.007604099810123444,0.008032404817640781,0.012598326429724693,0.009430584497749805,294,0.008032404817640781
+94,0.007419634144753218,0.007899288088083267,0.0137760229408741,0.010225353762507439,294,0.007899288088083267
+95,0.007262872532010078,0.008204394951462746,0.01450358983129263,0.012860476039350033,294,0.008204394951462746
+96,0.007131264545023441,0.007699331734329462,0.012736286967992783,0.010243520140647888,294,0.007699331734329462
+97,0.007236088626086712,0.007701294030994177,0.01206196378916502,0.009662138298153877,294,0.007701294030994177
+98,0.007138621993362904,0.008493873290717602,0.015391053631901741,0.01217359397560358,294,0.008493873290717602
+99,0.007595756556838751,0.007934299297630787,0.013105056248605251,0.011007900349795818,294,0.007934299297630787
+100,0.007255718111991882,0.00801815651357174,0.014192561618983746,0.011416600085794926,294,0.00801815651357174
+101,0.006878306623548269,0.007573374547064304,0.013602484948933125,0.011249125935137272,294,0.007573374547064304
+102,0.007859318517148495,0.008549843914806843,0.012963919900357723,0.011581948027014732,294,0.008549843914806843
+103,0.0071615735068917274,0.007783888839185238,0.012624602764844894,0.00850085448473692,294,0.007783888839185238
+104,0.007528661284595728,0.008011577650904655,0.013279614970088005,0.012293501757085323,294,0.008011577650904655
+105,0.007806309498846531,0.00888421107083559,0.01802387647330761,0.017503418028354645,294,0.00888421107083559
+106,0.007402185350656509,0.0077142780646681786,0.011473549529910088,0.0076649608090519905,294,0.0077142780646681786
+107,0.00682754535228014,0.007741028908640146,0.016962092369794846,0.01400468684732914,294,0.007741028908640146
+108,0.00732328649610281,0.007827435620129108,0.012570531107485294,0.010349469259381294,294,0.007827435620129108
+109,0.007210479583591223,0.00807506125420332,0.016547173261642456,0.014349141158163548,294,0.00807506125420332
+110,0.007583545986562967,0.008101431652903557,0.014226308092474937,0.01362711563706398,294,0.008101431652903557
+111,0.007475987542420626,0.008049068972468376,0.012614713050425053,0.010824508965015411,294,0.008049068972468376
+112,0.007786676287651062,0.008593817241489887,0.014478951692581177,0.011468341574072838,294,0.008593817241489887
+113,0.007399023976176977,0.00779272336512804,0.013462251983582973,0.012396988458931446,294,0.00779272336512804
+114,0.0070931329391896725,0.007703357841819525,0.012701851315796375,0.008444128558039665,294,0.007703357841819525
+115,0.00814863108098507,0.008495008572936058,0.015504365786910057,0.01339217834174633,294,0.008495008572936058
+116,0.00725707458332181,0.00791118573397398,0.012560060247778893,0.010066531598567963,294,0.00791118573397398
+117,0.0071696266531944275,0.007923099212348461,0.012981140054762363,0.008860908448696136,294,0.007923099212348461
+118,0.007590890862047672,0.007903246209025383,0.012662474997341633,0.011287943460047245,294,0.007903246209025383
+119,0.007351002190262079,0.007800257299095392,0.01318250223994255,0.010455300100147724,294,0.007800257299095392
+120,0.00742400111630559,0.008443804457783699,0.014922503381967545,0.01188939344137907,294,0.008443804457783699
+121,0.008004759438335896,0.00863601453602314,0.01671130768954754,0.017270609736442566,294,0.00863601453602314
+122,0.00716890674084425,0.007925684563815594,0.011855372227728367,0.008359050378203392,294,0.007925684563815594
+123,0.007244161330163479,0.007771099451929331,0.014508063904941082,0.011067783460021019,294,0.007771099451929331
+124,0.007426557131111622,0.008270668797194958,0.013681478798389435,0.012708808295428753,294,0.008270668797194958
+125,0.007991639897227287,0.008431966416537762,0.012301960028707981,0.009633178822696209,294,0.008431966416537762
+126,0.006997725926339626,0.0074834199622273445,0.012627854011952877,0.008179934695363045,294,0.0074834199622273445
+127,0.007414103485643864,0.008053201250731945,0.013766865245997906,0.011576639488339424,294,0.008053201250731945
+128,0.0073508694767951965,0.007750173099339008,0.013205697759985924,0.01169018168002367,294,0.007750173099339008
+129,0.00827991496771574,0.009146420285105705,0.01793457381427288,0.018164940178394318,294,0.009146420285105705
+130,0.007117914967238903,0.007514071650803089,0.012447637505829334,0.008598186075687408,294,0.007514071650803089
+131,0.007089621853083372,0.008014225400984287,0.01578625664114952,0.012981177307665348,294,0.008014225400984287
+132,0.0074038151651620865,0.007649869658052921,0.011650972999632359,0.009467394091188908,294,0.007649869658052921
+133,0.007234418299049139,0.008186964318156242,0.014246162958443165,0.012860838323831558,294,0.008186964318156242
+134,0.007319912314414978,0.007827108725905418,0.013610228896141052,0.00926536787301302,294,0.007827108725905418
+135,0.007184433285146952,0.007920279167592525,0.014493459835648537,0.012517143972218037,294,0.007920279167592525
+136,0.007169903255999088,0.007786741945892572,0.013407652266323566,0.010646877810359001,294,0.007786741945892572
+137,0.007258321158587933,0.007660922594368458,0.013189520686864853,0.011009966023266315,294,0.007660922594368458
+138,0.007528725080192089,0.008535800501704216,0.015467018820345402,0.0136803537607193,294,0.008535800501704216
+139,0.007804287131875753,0.008095014840364456,0.012036061845719814,0.008808726444840431,294,0.008095014840364456
+140,0.007528661284595728,0.008014867082238197,0.014024332165718079,0.013486471027135849,294,0.008014867082238197
+141,0.0076181297190487385,0.008059258572757244,0.013178919441998005,0.011442897841334343,294,0.008059258572757244
+142,0.007255718111991882,0.008366065099835396,0.015584129840135574,0.013536965474486351,294,0.008366065099835396
+143,0.007244161330163479,0.0077858916483819485,0.015079036355018616,0.011215356178581715,294,0.0077858916483819485
+144,0.007879692129790783,0.008193817920982838,0.013401731848716736,0.012117517180740833,294,0.008193817920982838
+145,0.007754521444439888,0.008031482808291912,0.013370172120630741,0.010379240848124027,294,0.008031482808291912
+146,0.007109455298632383,0.0077047767117619514,0.011827738024294376,0.008786119520664215,294,0.0077047767117619514
+147,0.007517649792134762,0.007907865568995476,0.013364351354539394,0.010243547149002552,294,0.007907865568995476
+148,0.00730321928858757,0.00818699412047863,0.013866380788385868,0.012639976106584072,294,0.00818699412047863
+149,0.007449118886142969,0.008192474953830242,0.014236274175345898,0.012239932082593441,294,0.008192474953830242
+150,0.007624419406056404,0.008031707257032394,0.012880336493253708,0.009208254516124725,294,0.008031707257032394
+151,0.0074800048023462296,0.00796361081302166,0.014051072299480438,0.01241043210029602,294,0.00796361081302166
+152,0.007679597474634647,0.008304117247462273,0.01233286689966917,0.010025463066995144,294,0.008304117247462273
+153,0.007117534056305885,0.007853408344089985,0.012244995683431625,0.009197039529681206,294,0.007853408344089985
+154,0.007769025396555662,0.008504548110067844,0.01340754609555006,0.012786808423697948,294,0.008504548110067844
+155,0.007517652586102486,0.007924696430563927,0.012930427677929401,0.009703509509563446,294,0.007924696430563927
+156,0.007116441614925861,0.008163250051438808,0.013930654153227806,0.01103104930371046,294,0.008163250051438808
+157,0.00754411518573761,0.0080462247133255,0.015469151549041271,0.011506479233503342,294,0.0080462247133255
+158,0.007188763003796339,0.007862688042223454,0.011920188553631306,0.00957093108445406,294,0.007862688042223454
+159,0.007352693006396294,0.007588472217321396,0.012624114751815796,0.00908483937382698,294,0.007588472217321396
+160,0.00776074081659317,0.00824518222361803,0.012694187462329865,0.0111953504383564,294,0.00824518222361803
+161,0.0078089796006679535,0.008488941006362438,0.015854377299547195,0.015912597998976707,294,0.008488941006362438
+162,0.0075168609619140625,0.008070624433457851,0.012233732268214226,0.009402765892446041,294,0.008070624433457851
+163,0.007121085189282894,0.00779604772105813,0.014724766835570335,0.010908115655183792,294,0.00779604772105813
+164,0.007605798076838255,0.008170006796717644,0.014518165029585361,0.013678439892828465,294,0.008170006796717644
+165,0.007255421951413155,0.008022504858672619,0.012358163483440876,0.010883649811148643,294,0.008022504858672619
+166,0.007412003353238106,0.00786091573536396,0.013024275191128254,0.009572219103574753,294,0.00786091573536396
+168,0.007054094225168228,0.007826093584299088,0.01326141506433487,0.011026142165064812,294,0.007826093584299088
+169,0.007104349322617054,0.007841765880584717,0.012905323877930641,0.01092760544270277,294,0.007841765880584717
+170,0.007479182910174131,0.007738044951111078,0.01238956768065691,0.010189993306994438,294,0.007738044951111078
+171,0.007240063510835171,0.008090833202004433,0.015046225860714912,0.012504062615334988,294,0.008090833202004433
+172,0.007513518910855055,0.008009386248886585,0.013861234299838543,0.01087217591702938,294,0.008009386248886585
+173,0.008071196265518665,0.008775927126407623,0.01578478515148163,0.014284001663327217,294,0.008775927126407623
+174,0.007161959074437618,0.007640110794454813,0.011570045724511147,0.007693952415138483,294,0.007640110794454813
+175,0.006949230562895536,0.00749728549271822,0.013526778668165207,0.010094771161675453,294,0.00749728549271822
+176,0.00755798164755106,0.008631507866084576,0.01593189872801304,0.015174477361142635,294,0.008631507866084576
+177,0.006958399899303913,0.007605919148772955,0.01375752966850996,0.010917644947767258,294,0.007605919148772955
+178,0.007574326824396849,0.0082119544968009,0.01206017192453146,0.009825958870351315,294,0.0082119544968009
+179,0.006889939308166504,0.007613669149577618,0.015205398201942444,0.013129227794706821,294,0.007613669149577618
+180,0.007513790857046843,0.007986382581293583,0.014341077767312527,0.013444850221276283,294,0.007986382581293583
+181,0.007122557144612074,0.00827045552432537,0.013862392865121365,0.010927940718829632,294,0.00827045552432537
+182,0.0069560883566737175,0.007554186042398214,0.011905457824468613,0.0076595935970544815,294,0.007554186042398214
+183,0.007472744677215815,0.00786261260509491,0.014046372845768929,0.01077428087592125,294,0.00786261260509491
+184,0.007320270407944918,0.008266260847449303,0.013955021277070045,0.012409997172653675,294,0.008266260847449303
+185,0.007589442189782858,0.007813733071088791,0.013297122903168201,0.011989208869636059,294,0.007813733071088791
+186,0.00804114155471325,0.008672915399074554,0.01421697624027729,0.01244206354022026,294,0.008672915399074554
+187,0.0075040594674646854,0.00810893066227436,0.013487660326063633,0.011976678855717182,294,0.00810893066227436
+188,0.007271136622875929,0.008022410795092583,0.013143204152584076,0.009852004237473011,294,0.008022410795092583
+189,0.007388683967292309,0.008415321819484234,0.014456606470048428,0.010246546939015388,294,0.008415321819484234
+190,0.00739008653908968,0.007750241551548243,0.011856336146593094,0.008500698953866959,294,0.007750241551548243
+191,0.007846078835427761,0.00860566832125187,0.014111561700701714,0.011586986482143402,294,0.00860566832125187
+192,0.0072663649916648865,0.00789980124682188,0.013509616255760193,0.013083738274872303,294,0.00789980124682188
+193,0.007972725667059422,0.008439923636615276,0.014134031720459461,0.01302702073007822,294,0.008439923636615276
+194,0.007457938976585865,0.0077846841886639595,0.011612262576818466,0.008898996748030186,294,0.0077846841886639595
+195,0.007451588753610849,0.007862558588385582,0.01400060672312975,0.00961576122790575,294,0.007862558588385582
+196,0.0074038151651620865,0.007677638437598944,0.012311350554227829,0.010332256555557251,294,0.007677638437598944
+197,0.007234418299049139,0.007904493249952793,0.013269266113638878,0.0119879599660635,294,0.007904493249952793
+198,0.007022863253951073,0.007818627171218395,0.013092252425849438,0.009393091313540936,294,0.007818627171218395
+199,0.007465069182217121,0.008016182109713554,0.01354184839874506,0.012372123077511787,294,0.008016182109713554
+200,0.0077188704162836075,0.008143464103341103,0.013287875801324844,0.010771489702165127,294,0.008143464103341103
+201,0.007104349322617054,0.0075347512029111385,0.013289076276123524,0.011411625891923904,294,0.0075347512029111385
+202,0.007664899807423353,0.00801150593906641,0.012648693285882473,0.01068310160189867,294,0.00801150593906641
+203,0.007368776015937328,0.008001024834811687,0.012588891200721264,0.009533698670566082,294,0.008001024834811687
+204,0.007203216198831797,0.007997515611350536,0.013918881304562092,0.00975705124437809,294,0.007997515611350536
+205,0.0077444096095860004,0.008192077279090881,0.01472177542746067,0.0133837154135108,294,0.008192077279090881
+206,0.007064418401569128,0.00782955065369606,0.012239886447787285,0.007064418401569128,294,0.00782955065369606
+207,0.006949230562895536,0.007500378880649805,0.013889920897781849,0.010332159698009491,294,0.007500378880649805
+208,0.007459819782525301,0.008210444822907448,0.01295877993106842,0.01117430068552494,294,0.008210444822907448
+209,0.007262445520609617,0.008789315819740295,0.016564078629016876,0.014708871953189373,294,0.008789315819740295
+210,0.007198431994765997,0.0076985545456409454,0.011787070892751217,0.009021509438753128,294,0.0076985545456409454
+212,0.00730321928858757,0.007851215079426765,0.013511396944522858,0.012418920174241066,294,0.007851215079426765
+213,0.008269740268588066,0.008648023940622807,0.013544063083827496,0.012063294649124146,294,0.008648023940622807
+214,0.0069560883566737175,0.0074520534835755825,0.01184443011879921,0.007296929135918617,294,0.0074520534835755825
+215,0.007690291851758957,0.007940532639622688,0.01433556154370308,0.012861110270023346,294,0.007940532639622688
+216,0.007320270407944918,0.008205772377550602,0.013880155049264431,0.012190205045044422,294,0.008205772377550602
+217,0.007628186605870724,0.00821668840944767,0.014321092516183853,0.012964311987161636,294,0.00821668840944767
+219,0.00737164169549942,0.007942668162286282,0.014232533983886242,0.011668650433421135,294,0.007942668162286282
+220,0.007231048308312893,0.007882630452513695,0.014416327700018883,0.01175757683813572,294,0.007882630452513695
+222,0.007334697060286999,0.007885394617915154,0.01362901646643877,0.011593800038099289,294,0.007885394617915154
+223,0.0071615735068917274,0.007698322646319866,0.013600349426269531,0.00967207457870245,294,0.007698322646319866
+224,0.0072663649916648865,0.007882999256253242,0.01375378854572773,0.013301538303494453,294,0.007882999256253242
+225,0.007089526858180761,0.007896569557487965,0.014448842965066433,0.012028158642351627,294,0.007896569557487965
+226,0.00749005563557148,0.008389110676944256,0.014272152446210384,0.011581698432564735,294,0.008389110676944256
+227,0.007314398884773254,0.0076757511124014854,0.01249460969120264,0.008758697658777237,294,0.0076757511124014854
+228,0.00741798710078001,0.008441886864602566,0.013495155610144138,0.011912438087165356,294,0.008441886864602566
+229,0.007660582661628723,0.008085347712039948,0.014141718856990337,0.013829333707690239,294,0.008085347712039948
+230,0.0074770646169781685,0.007871848531067371,0.012950352393090725,0.007915301248431206,294,0.007871848531067371
+231,0.007873774506151676,0.008466823026537895,0.014340309426188469,0.013265114277601242,294,0.008466823026537895
+232,0.007054094225168228,0.007749372161924839,0.012614770792424679,0.01035059243440628,294,0.007749372161924839
+233,0.007081414107233286,0.008047501556575298,0.013363935984671116,0.010525300167500973,294,0.008047501556575298
+234,0.007491037715226412,0.007964344695210457,0.012814028188586235,0.01073532272130251,294,0.007964344695210457
+235,0.007383930031210184,0.007860240526497364,0.013537663966417313,0.011670812964439392,294,0.007860240526497364
+236,0.007116441614925861,0.007729534059762955,0.013636709190905094,0.010486735962331295,294,0.007729534059762955
+237,0.008469817228615284,0.008923206478357315,0.016490260139107704,0.015635628253221512,294,0.008923206478357315
+238,0.007161959074437618,0.007671453058719635,0.011598270386457443,0.008026696741580963,294,0.007671453058719635
+239,0.00742846354842186,0.008157356642186642,0.014842751435935497,0.011615571565926075,294,0.008157356642186642
+240,0.007422964088618755,0.007932260632514954,0.01552684884518385,0.01489520724862814,294,0.007932260632514954
+241,0.006958399899303913,0.007584854960441589,0.012612747959792614,0.009467748925089836,294,0.007584854960441589
+242,0.007574326824396849,0.00798292551189661,0.01198495551943779,0.009713505394756794,294,0.00798292551189661
+243,0.007360717281699181,0.007886134088039398,0.013263358734548092,0.009760419838130474,294,0.007886134088039398
+244,0.007609432563185692,0.008435120806097984,0.01602710597217083,0.01608179323375225,294,0.008435120806097984
+245,0.007122557144612074,0.008119354955852032,0.014692813158035278,0.012150212191045284,294,0.008119354955852032
+246,0.00792998168617487,0.008301208727061749,0.012413129210472107,0.009925992228090763,294,0.008301208727061749
+247,0.007258621975779533,0.008042187429964542,0.01456223800778389,0.010287139564752579,294,0.008042187429964542
+249,0.007515343371778727,0.007931454107165337,0.012590209022164345,0.010935152880847454,294,0.007931454107165337
+250,0.007833603769540787,0.008891316130757332,0.01437267567962408,0.013841853477060795,294,0.008891316130757332
+251,0.007215574383735657,0.00794993806630373,0.01422642171382904,0.012366515584290028,294,0.00794993806630373
+252,0.007169903255999088,0.007997522130608559,0.013885934837162495,0.01117895357310772,294,0.007997522130608559
+253,0.007388683967292309,0.008236253634095192,0.015221222303807735,0.011464277282357216,294,0.008236253634095192
+254,0.0076532927341759205,0.00797052402049303,0.012507304549217224,0.010842567309737206,294,0.00797052402049303
+255,0.007097496651113033,0.007506424095481634,0.012655921280384064,0.008776713162660599,294,0.007506424095481634
+256,0.007909507490694523,0.008627613075077534,0.013704398646950722,0.013350632041692734,294,0.008627613075077534
+257,0.0070431106723845005,0.007501044310629368,0.013283703476190567,0.01090965699404478,294,0.007501044310629368
+258,0.007550961337983608,0.008508766070008278,0.01497345045208931,0.012505526654422283,294,0.008508766070008278
+259,0.007272020913660526,0.007598684635013342,0.011974725872278214,0.007809584029018879,294,0.007598684635013342
+260,0.007464357186108828,0.008412638679146767,0.014830688945949078,0.013910814188420773,294,0.008412638679146767
+261,0.007892687804996967,0.0081937862560153,0.014307760633528233,0.013945653103291988,294,0.0081937862560153
+262,0.007227321155369282,0.0078004575334489346,0.01270200777798891,0.008951210416853428,294,0.0078004575334489346
+263,0.007565016392618418,0.008062275126576424,0.014131681993603706,0.010503942146897316,294,0.008062275126576424
+264,0.006963653955608606,0.007708287797868252,0.01266880240291357,0.01048094592988491,294,0.007708287797868252
+265,0.007484015077352524,0.008822625502943993,0.017032336443662643,0.0162943284958601,294,0.008822625502943993
+266,0.007271665148437023,0.007880264893174171,0.013442195020616055,0.011541270650923252,294,0.007880264893174171
+267,0.007376266177743673,0.007817267440259457,0.013973377645015717,0.012006735429167747,294,0.007817267440259457
+268,0.00753684202209115,0.00797110702842474,0.012654813937842846,0.008899996057152748,294,0.00797110702842474
+269,0.00693141482770443,0.008081002160906792,0.01798422820866108,0.015411837957799435,294,0.008081002160906792
+270,0.0073393480852246284,0.007746580056846142,0.011577054858207703,0.008593221195042133,294,0.007746580056846142
+271,0.007017574738711119,0.007767331786453724,0.01300840824842453,0.010083827190101147,294,0.007767331786453724
+272,0.007422964088618755,0.00802453514188528,0.016092339530587196,0.015386410057544708,294,0.00802453514188528
+273,0.007393482606858015,0.007821637205779552,0.011878736317157745,0.008158206939697266,294,0.007821637205779552
+274,0.007147651165723801,0.007683047093451023,0.012275667861104012,0.010761652141809464,294,0.007683047093451023
+275,0.007360717281699181,0.007773400750011206,0.013606843538582325,0.010323086753487587,294,0.007773400750011206
+276,0.007875613868236542,0.00862615741789341,0.014188077300786972,0.010931706055998802,294,0.00862615741789341
+277,0.007687828969210386,0.008381190709769726,0.014531769789755344,0.014188094064593315,294,0.008381190709769726
+278,0.007153849583119154,0.00770085584372282,0.011520271189510822,0.008366893976926804,294,0.00770085584372282
+279,0.006952240597456694,0.007880156859755516,0.014216403476893902,0.010899804532527924,294,0.007880156859755516
+280,0.007739785593003035,0.008543404750525951,0.015957381576299667,0.015799595043063164,294,0.008543404750525951
+281,0.00733790872618556,0.00832210760563612,0.01341340597718954,0.012076211161911488,294,0.00832210760563612
+283,0.00786470714956522,0.008225882425904274,0.014764854684472084,0.013453599996864796,294,0.008225882425904274
+284,0.00736474571749568,0.008109972812235355,0.013486786745488644,0.011977928690612316,294,0.008109972812235355
+285,0.006917512975633144,0.007583460304886103,0.014452426694333553,0.010922237299382687,294,0.007583460304886103
+286,0.007700594607740641,0.008065231144428253,0.012639474123716354,0.01071404293179512,294,0.008065231144428253
+287,0.0071479580365121365,0.008108262903988361,0.013278872705996037,0.00972571037709713,294,0.008108262903988361
+288,0.007697495631873608,0.008700476959347725,0.016397422179579735,0.01698525808751583,294,0.008700476959347725
+289,0.007395248860120773,0.008261705748736858,0.014052013866603374,0.012134924530982971,294,0.008261705748736858
+290,0.0069509935565292835,0.007708174176514149,0.012514175847172737,0.010033827275037766,294,0.007708174176514149
+292,0.007702984847128391,0.008339134976267815,0.0144247030839324,0.013931638561189175,294,0.008339134976267815
+293,0.00827158335596323,0.00909184105694294,0.01707235723733902,0.01779206469655037,294,0.00909184105694294
+294,0.007021487224847078,0.007373058702796698,0.011396534740924835,0.0,294,0.007373058702796698
+296,0.007644401863217354,0.008057089522480965,0.0135418102145195,0.012056233361363411,294,0.008057089522480965
+297,0.00815174076706171,0.008344622328877449,0.014120850712060928,0.013169415295124054,294,0.008344622328877449
+298,0.006954048294574022,0.007645933888852596,0.013279597274959087,0.009666572324931622,294,0.007645933888852596
+299,0.007395224180072546,0.00836038775742054,0.015241445042192936,0.012854387052357197,294,0.00836038775742054
+300,0.0077558038756251335,0.008049765601754189,0.013943218626081944,0.011704920791089535,294,0.008049765601754189
+301,0.0071696266531944275,0.008067207410931587,0.01345440000295639,0.009763496927917004,294,0.008067207410931587
+302,0.007961428724229336,0.008228637278079987,0.012747219763696194,0.010678631253540516,294,0.008228637278079987
+303,0.007842997089028358,0.008223037235438824,0.013656594790518284,0.010256084613502026,294,0.008223037235438824
+304,0.007380716968327761,0.007830323651432991,0.014122606255114079,0.01359123457223177,294,0.007830323651432991
+305,0.007452681660652161,0.007770558353513479,0.012282604351639748,0.009974139742553234,294,0.007770558353513479
+306,0.007806317415088415,0.008543153293430805,0.01362205296754837,0.011820762418210506,294,0.008543153293430805
+307,0.00735390605404973,0.007925594225525856,0.01301531307399273,0.010682336986064911,294,0.007925594225525856
+308,0.0067307185381650925,0.008096275851130486,0.014844111166894436,0.011874305084347725,294,0.008096275851130486
+309,0.0068496656604111195,0.008258761838078499,0.015821246430277824,0.012080051936209202,294,0.008258761838078499
+310,0.007618345320224762,0.008086541667580605,0.012123078107833862,0.009032582864165306,294,0.008086541667580605
+311,0.007552349008619785,0.008297530934214592,0.013611377216875553,0.010094597935676575,294,0.008297530934214592
+312,0.007617446593940258,0.008050190284848213,0.0126559529453516,0.011753606610000134,294,0.008050190284848213
+313,0.007196478080004454,0.00805751048028469,0.013553790748119354,0.012185675092041492,294,0.00805751048028469
+314,0.007080707233399153,0.007670278195291758,0.012043843977153301,0.008405681699514389,294,0.007670278195291758
+315,0.007465069182217121,0.008154294453561306,0.014541266486048698,0.013432640582323074,294,0.008154294453561306
+317,0.006899711210280657,0.007810692302882671,0.01630926877260208,0.014159191399812698,294,0.007810692302882671
+318,0.007191929966211319,0.007977963425219059,0.01303945854306221,0.011341200210154057,294,0.007977963425219059
+319,0.007400349713861942,0.00783921591937542,0.011688262224197388,0.009142737835645676,294,0.00783921591937542
+320,0.00704995496198535,0.008005508221685886,0.014632582664489746,0.011766905896365643,294,0.008005508221685886
+321,0.007627403829246759,0.00794022623449564,0.013339586555957794,0.010507050901651382,294,0.00794022623449564
+322,0.0069509935565292835,0.00776659045368433,0.012291518971323967,0.009535462595522404,294,0.00776659045368433
+323,0.007298523560166359,0.007726844400167465,0.013047880493104458,0.009759997949004173,294,0.007726844400167465
+324,0.008121315389871597,0.008798333816230297,0.014472385868430138,0.013662056997418404,294,0.008798333816230297
+326,0.0073216697201132774,0.007690828293561935,0.01191729586571455,0.007510831113904715,294,0.007690828293561935
+327,0.007494187913835049,0.00805489532649517,0.014378194697201252,0.01074023824185133,294,0.00805489532649517
+328,0.00727294385433197,0.00789607036858797,0.012238265946507454,0.009952899068593979,294,0.00789607036858797
+330,0.006954048294574022,0.007606963627040386,0.013467637822031975,0.009823737666010857,294,0.007606963627040386
+331,0.0076226405799388885,0.008024590089917183,0.014150015078485012,0.01233323197811842,294,0.008024590089917183
+332,0.00727362185716629,0.00804163794964552,0.013408524915575981,0.011154064908623695,294,0.00804163794964552
+333,0.007121085189282894,0.00786827877163887,0.015210860408842564,0.011148766614496708,294,0.00786827877163887
+334,0.007901720702648163,0.008286064490675926,0.01224583014845848,0.010595452971756458,294,0.008286064490675926
+335,0.007017574738711119,0.007541186176240444,0.012650830671191216,0.009729960933327675,294,0.007541186176240444
+336,0.0077528213150799274,0.008272984065115452,0.01576140522956848,0.014983360655605793,294,0.008272984065115452
+337,0.007117534056305885,0.007824938744306564,0.012391321361064911,0.009845905937254429,294,0.007824938744306564
+338,0.007259052246809006,0.008132095448672771,0.01333608478307724,0.012174172326922417,294,0.008132095448672771
+339,0.00746291084215045,0.007918552495539188,0.012190007604658604,0.009712842293083668,294,0.007918552495539188
+340,0.0067307185381650925,0.007953045889735222,0.015261919237673283,0.012369899079203606,294,0.007953045889735222
+341,0.00797145813703537,0.00862118136137724,0.014290181919932365,0.012715689837932587,294,0.00862118136137724
+342,0.007153849583119154,0.007845954038202763,0.011784428730607033,0.008862050250172615,294,0.007845954038202763
+343,0.0074286311864852905,0.008291511796414852,0.015307874418795109,0.011381466872990131,294,0.008291511796414852
+344,0.007307319436222315,0.007749207317829132,0.01331417728215456,0.012389399111270905,294,0.007749207317829132
+345,0.0077766128815710545,0.008977280929684639,0.01568915694952011,0.015534354373812675,294,0.008977280929684639
+346,0.007156102452427149,0.007432939019054174,0.012608103454113007,0.008358699269592762,294,0.007432939019054174
+347,0.007876239717006683,0.008505391888320446,0.014412992633879185,0.013517477549612522,294,0.008505391888320446
+348,0.0071235946379601955,0.007960615679621696,0.012484311126172543,0.009123414754867554,294,0.007960615679621696
+349,0.007748371455818415,0.008109668269753456,0.01258255448192358,0.00949807371944189,294,0.008109668269753456
+350,0.007191929966211319,0.007716039661318064,0.01225115917623043,0.010120538994669914,294,0.007716039661318064
+351,0.007390606217086315,0.007787452079355717,0.012888367287814617,0.009401288814842701,294,0.007787452079355717
+352,0.007262445520609617,0.008214229717850685,0.015504131093621254,0.01306295208632946,294,0.008214229717850685
+353,0.007444807328283787,0.008243253454566002,0.015270465053617954,0.01311559695750475,294,0.008243253454566002
+354,0.007147651165723801,0.007929815910756588,0.012022679671645164,0.010375408455729485,294,0.007929815910756588
+355,0.006889939308166504,0.007550226058810949,0.014966340735554695,0.012795886024832726,294,0.007550226058810949
+356,0.007452262099832296,0.00799117423593998,0.013545133173465729,0.009932448156177998,294,0.00799117423593998
+357,0.007687828969210386,0.008563700132071972,0.015523219481110573,0.015292329713702202,294,0.008563700132071972
+358,0.007021487224847078,0.007641778327524662,0.01179245114326477,0.007021487224847078,294,0.007641778327524662
+359,0.006952240597456694,0.0076782554388046265,0.014232908375561237,0.010869271121919155,294,0.0076782554388046265
+360,0.007479980122298002,0.007949108257889748,0.013833215460181236,0.012349206022918224,294,0.007949108257889748
+361,0.00733790872618556,0.00819972064346075,0.01336507685482502,0.011825122870504856,294,0.00819972064346075
+362,0.007138621993362904,0.0085537638515234,0.015203976072371006,0.012132599949836731,294,0.0085537638515234
+363,0.007580596953630447,0.007845254614949226,0.012943297624588013,0.011167250573635101,294,0.007845254614949226
+365,0.006917512975633144,0.007520451210439205,0.013620736077427864,0.009662343189120293,294,0.007520451210439205
+366,0.00741798710078001,0.00834548007696867,0.014207488857209682,0.012250515632331371,294,0.00834548007696867
+367,0.007486000191420317,0.008725345134735107,0.013014606200158596,0.010570860467851162,294,0.008725345134735107
+368,0.007380716968327761,0.007852891460061073,0.013923279941082,0.01352776400744915,294,0.007852891460061073
+369,0.007888270542025566,0.008394522592425346,0.01470524538308382,0.014037827961146832,294,0.008394522592425346
+371,0.00758903194218874,0.007992283441126347,0.0139042679220438,0.01177113875746727,294,0.007992283441126347
+372,0.007455239072442055,0.008101419545710087,0.013229059986770153,0.009779625572264194,294,0.008101419545710087
+373,0.0068496656604111195,0.00844559632241726,0.016456015408039093,0.013047651387751102,294,0.00844559632241726
+374,0.007418590597808361,0.0076050893403589725,0.011639135889708996,0.008577315136790276,294,0.0076050893403589725
+375,0.007037422154098749,0.0077916583977639675,0.014397772960364819,0.011056789197027683,294,0.0077916583977639675
+377,0.007196478080004454,0.008023272268474102,0.013014950789511204,0.011512433178722858,294,0.008023272268474102
+378,0.007138059474527836,0.007937737740576267,0.012265237979590893,0.009032349102199078,294,0.007937737740576267
+379,0.008436490781605244,0.008908873423933983,0.015448760241270065,0.013995743356645107,294,0.008908873423933983
+380,0.006963653955608606,0.007889778353273869,0.013299635611474514,0.011101795360445976,294,0.007889778353273869
+381,0.00728972814977169,0.007764670066535473,0.014469994232058525,0.010348888114094734,294,0.007764670066535473
+382,0.008056994527578354,0.008725875988602638,0.01509656198322773,0.014687737450003624,294,0.008725875988602638
+383,0.007400349713861942,0.007742106914520264,0.012321963906288147,0.009977592155337334,294,0.007742106914520264
+384,0.0070431106723845005,0.0075967684388160706,0.014227730222046375,0.011881985701620579,294,0.0075967684388160706
+385,0.00773434154689312,0.008180947043001652,0.013996463268995285,0.01366329938173294,294,0.008180947043001652
+386,0.007400139234960079,0.008136327378451824,0.014121358282864094,0.010439827106893063,294,0.008136327378451824
+387,0.007395224180072546,0.0082089276984334,0.01545974425971508,0.013555078767240047,294,0.0082089276984334
+388,0.007272126618772745,0.008101391606032848,0.01385919563472271,0.011896386742591858,294,0.008101391606032848
+389,0.0076992204412817955,0.00831974670290947,0.014900767244398594,0.013755708001554012,294,0.00831974670290947
+390,0.007218028884381056,0.007862282916903496,0.01253231056034565,0.009619138203561306,294,0.007862282916903496
+391,0.00749005563557148,0.008135530166327953,0.01412336528301239,0.01162420678883791,294,0.008135530166327953
+392,0.007231048308312893,0.00792626105248928,0.015548452734947205,0.013337193056941032,294,0.00792626105248928
+393,0.009425301104784012,0.011422020383179188,0.0218912735581398,0.02249886468052864,294,0.011422020383179188
+394,0.007101351860910654,0.007509616669267416,0.011477136053144932,0.007291790097951889,294,0.007509616669267416
+395,0.007076209876686335,0.00831563863903284,0.01604386419057846,0.012795882299542427,294,0.00831563863903284
+396,0.007644401863217354,0.008088997565209866,0.013183225877583027,0.012153860181570053,294,0.008088997565209866
+397,0.0077485861256718636,0.00881284475326538,0.017802752554416656,0.01598490960896015,294,0.00881284475326538
+398,0.007080707233399153,0.007656899746507406,0.012770497240126133,0.00905750785022974,294,0.007656899746507406
+399,0.007496804930269718,0.007900984957814217,0.013910152949392796,0.012491260655224323,294,0.007900984957814217
+400,0.007444807328283787,0.008278045803308487,0.015034133568406105,0.013138080947101116,294,0.008278045803308487
+401,0.007230771239846945,0.007799251936376095,0.013370122760534286,0.0123599823564291,294,0.007799251936376095
+402,0.007475253194570541,0.00817553699016571,0.012307682074606419,0.009944474324584007,294,0.00817553699016571
+404,0.007699401117861271,0.008198204450309277,0.01261809654533863,0.010036828927695751,294,0.008198204450309277
+405,0.007472131866961718,0.008043194189667702,0.013694535940885544,0.009913588874042034,294,0.008043194189667702
+406,0.007769025396555662,0.008319420740008354,0.014002948068082333,0.013691239058971405,294,0.008319420740008354
+407,0.007262938190251589,0.007857424207031727,0.013536791317164898,0.011102769523859024,294,0.007857424207031727
+408,0.00786587130278349,0.007992546074092388,0.012513108551502228,0.009085554629564285,294,0.007992546074092388
+409,0.007902598939836025,0.008350146934390068,0.01433112844824791,0.012369425967335701,294,0.008350146934390068
+410,0.007125034928321838,0.0076732151210308075,0.011492815800011158,0.00888864416629076,294,0.0076732151210308075
+411,0.007037422154098749,0.007574374787509441,0.014024459756910801,0.01110014133155346,294,0.007574374787509441
+412,0.007702984847128391,0.008383301086723804,0.013787735253572464,0.012794731184840202,294,0.008383301086723804
+413,0.007712202612310648,0.008016901090741158,0.013608116656541824,0.012149018235504627,294,0.008016901090741158
+414,0.007312418892979622,0.007743316702544689,0.012348847463726997,0.00745388213545084,294,0.007743316702544689
+415,0.007273777388036251,0.007995261810719967,0.014684012159705162,0.011021439917385578,294,0.007995261810719967
+416,0.0076492540538311005,0.00803448911756277,0.012401103042066097,0.010664528235793114,294,0.00803448911756277
+417,0.007571246474981308,0.008178582414984703,0.015773294493556023,0.014737225137650967,294,0.008178582414984703
+418,0.006899483501911163,0.00744160870090127,0.011986084282398224,0.007715674117207527,294,0.00744160870090127
+419,0.00682754535228014,0.00818188488483429,0.018241163343191147,0.015365349128842354,294,0.00818188488483429
+420,0.007879259064793587,0.008568434976041317,0.012398508377373219,0.010346590541303158,294,0.008568434976041317
+421,0.007390548940747976,0.00806360226124525,0.013453509658575058,0.01203251164406538,294,0.00806360226124525
+422,0.007650733459740877,0.007922835648059845,0.013253687880933285,0.01204928569495678,294,0.007922835648059845
+423,0.007376266177743673,0.007947688922286034,0.013484830036759377,0.010871067643165588,294,0.007947688922286034
+424,0.007118659093976021,0.007824497297406197,0.014612187631428242,0.012280094437301159,294,0.007824497297406197
+425,0.007655200082808733,0.008425785228610039,0.01375533826649189,0.00998674426227808,294,0.008425785228610039
+426,0.007549662608653307,0.007960280403494835,0.012143641710281372,0.010153012350201607,294,0.007960280403494835
+427,0.0073943487368524075,0.007666214369237423,0.012957306578755379,0.008923578076064587,294,0.007666214369237423
+428,0.0071558598428964615,0.007987134158611298,0.014374700374901295,0.013924525119364262,294,0.007987134158611298
+429,0.007309428416192532,0.007775203324854374,0.013605351559817791,0.01095580030232668,294,0.007775203324854374
+430,0.00727149099111557,0.008446065708994865,0.015557697042822838,0.013179526664316654,294,0.008446065708994865
+431,0.007786999922245741,0.008838368579745293,0.015580309554934502,0.014665809459984303,294,0.008838368579745293
+432,0.007236088626086712,0.007591091096401215,0.011581615544855595,0.008463147096335888,294,0.007591091096401215
+433,0.007697495631873608,0.0083067137748003,0.01533681619912386,0.015637626871466637,294,0.0083067137748003
+434,0.0071479580365121365,0.007829158566892147,0.012759018689393997,0.008151696063578129,294,0.007829158566892147
+435,0.007565016392618418,0.007939299568533897,0.013050880283117294,0.009623593650758266,294,0.007939299568533897
+436,0.0071711111813783646,0.00805144477635622,0.01275450550019741,0.010216242633759975,294,0.00805144477635622
+437,0.007298523560166359,0.007987892255187035,0.012540214695036411,0.009382858872413635,294,0.007987892255187035
+438,0.0071503822691738605,0.007572430185973644,0.013236917555332184,0.008550568483769894,294,0.007572430185973644
+439,0.007980847731232643,0.00901029072701931,0.01660636067390442,0.014909075573086739,294,0.00901029072701931
+440,0.007184418383985758,0.007587072439491749,0.012940228916704655,0.01089168805629015,294,0.007587072439491749
+441,0.007081414107233286,0.007915981113910675,0.014132890850305557,0.011658886447548866,294,0.007915981113910675
+442,0.007102133706212044,0.007703185081481934,0.01208854466676712,0.0100935660302639,294,0.007703185081481934
+443,0.007804526947438717,0.008270412683486938,0.013139045797288418,0.010953045450150967,294,0.008270412683486938
+444,0.00737333670258522,0.008083537220954895,0.01564384251832962,0.015287410467863083,294,0.008083537220954895
+445,0.007997135631740093,0.008330484852194786,0.013188302516937256,0.010704806074500084,294,0.008330484852194786
+446,0.00750857125967741,0.007942101918160915,0.012085207737982273,0.008453884162008762,294,0.007942101918160915
+447,0.007446127012372017,0.008465512655675411,0.014474784024059772,0.010694443248212337,294,0.008465512655675411
+448,0.007724020164459944,0.00817139446735382,0.012912324629724026,0.011369832791388035,294,0.00817139446735382
+449,0.007645389065146446,0.008026410825550556,0.013280708342790604,0.012299951165914536,294,0.008026410825550556
+450,0.006899483501911163,0.0076362816616892815,0.012534410692751408,0.008502310141921043,294,0.0076362816616892815
+451,0.007793181110173464,0.008280264213681221,0.014549368992447853,0.013513562269508839,294,0.008280264213681221
+452,0.0073393480852246284,0.007944341748952866,0.01208994910120964,0.008864404633641243,294,0.007944341748952866
+453,0.007589442189782858,0.008012326434254646,0.014201462268829346,0.01310445461422205,294,0.008012326434254646
+454,0.007128113880753517,0.0077434503473341465,0.012693768367171288,0.009952524676918983,294,0.0077434503473341465
+455,0.007760008797049522,0.008496462367475033,0.013617086224257946,0.012070865370333195,294,0.008496462367475033
+456,0.007271136622875929,0.007981629110872746,0.014121104963123798,0.011455683037638664,294,0.007981629110872746
+457,0.007144063711166382,0.008150497451424599,0.015075174160301685,0.012524792924523354,294,0.008150497451424599
+458,0.007101351860910654,0.007738327141851187,0.012199417687952518,0.008879433386027813,294,0.007738327141851187
+459,0.007330988999456167,0.007812641561031342,0.01280894037336111,0.008295527659356594,294,0.007812641561031342
+460,0.007636684458702803,0.008033712394535542,0.013450081460177898,0.0123560456559062,294,0.008033712394535542
+461,0.007309428416192532,0.00790162943303585,0.013201456516981125,0.01031047198921442,294,0.00790162943303585
+462,0.007331838831305504,0.007775706239044666,0.012740827165544033,0.00832284428179264,294,0.007775706239044666
+463,0.007780776359140873,0.008510015904903412,0.013711480423808098,0.01321482378989458,294,0.008510015904903412
+464,0.0074548544362187386,0.007825134322047234,0.012588362209498882,0.009669916704297066,294,0.007825134322047234
+465,0.007801860570907593,0.008259913884103298,0.013040493242442608,0.011953516863286495,294,0.008259913884103298
+466,0.0074088918045163155,0.00839381106197834,0.014335648156702518,0.010947171598672867,294,0.00839381106197834
+467,0.007119764108210802,0.007596108131110668,0.014502773992717266,0.010632116347551346,294,0.007596108131110668
+468,0.007531195878982544,0.008100665174424648,0.014124887995421886,0.01287821400910616,294,0.008100665174424648
+469,0.007472131866961718,0.00857885368168354,0.015087157487869263,0.01175135001540184,294,0.00857885368168354
+470,0.007464357186108828,0.008696814998984337,0.015712426975369453,0.015378459356725216,294,0.008696814998984337
+471,0.007262938190251589,0.007907281629741192,0.014347368851304054,0.012390178628265858,294,0.007907281629741192
+472,0.007184418383985758,0.007778264582157135,0.013872695155441761,0.011937398463487625,294,0.007778264582157135
+474,0.007102133706212044,0.007421457674354315,0.011397742666304111,0.009040343575179577,294,0.007421457674354315
+475,0.007016252260655165,0.007624720688909292,0.013424266129732132,0.010295337997376919,294,0.007624720688909292
+476,0.00737333670258522,0.008009073324501514,0.015330318361520767,0.014896468259394169,294,0.008009073324501514
+477,0.00748892966657877,0.008410394191741943,0.016651228070259094,0.015094089321792126,294,0.008410394191741943
+478,0.00737770413979888,0.007804458029568195,0.011832877062261105,0.008266723714768887,294,0.007804458029568195
+479,0.007273777388036251,0.007896171882748604,0.014622149989008904,0.010817987844347954,294,0.007896171882748604
+480,0.007484015077352524,0.00854722410440445,0.01602604053914547,0.015371034853160381,294,0.00854722410440445
+481,0.007230771239846945,0.007901112549006939,0.013859962113201618,0.012795411981642246,294,0.007901112549006939
+482,0.007160878274589777,0.007496069185435772,0.012699974700808525,0.009226192720234394,294,0.007496069185435772
+483,0.007089621853083372,0.007885096594691277,0.016326013952493668,0.01382640190422535,294,0.007885096594691277
+484,0.007400262635201216,0.008094165474176407,0.012723547406494617,0.010395031422376633,294,0.008094165474176407
+485,0.007816575467586517,0.008659380488097668,0.015032865107059479,0.013787779957056046,294,0.008659380488097668
+486,0.007481161970645189,0.00783839263021946,0.012638603337109089,0.010870939120650291,294,0.00783839263021946
+487,0.007353917695581913,0.007857639342546463,0.013879713602364063,0.011202828027307987,294,0.007857639342546463
+488,0.007118659093976021,0.007938367314636707,0.013945461250841618,0.011667556129395962,294,0.007938367314636707
+489,0.007395248860120773,0.008399097248911858,0.014474775642156601,0.0121036721393466,294,0.008399097248911858
+490,0.007109455298632383,0.007800040300935507,0.012220405042171478,0.008792612701654434,294,0.007800040300935507
+491,0.007355944253504276,0.0077830045484006405,0.01433092076331377,0.01068184245377779,294,0.0077830045484006405
+492,0.0071558598428964615,0.008234726265072823,0.014252614229917526,0.01387713197618723,294,0.008234726265072823
+493,0.007497970946133137,0.00791245885193348,0.012268000282347202,0.010353127494454384,294,0.00791245885193348
+494,0.007230805698782206,0.007704318501055241,0.012404197826981544,0.007344627287238836,294,0.007704318501055241
+495,0.007786999922245741,0.008928677998483181,0.01602104678750038,0.01508133765310049,294,0.008928677998483181
+496,0.0074914866127073765,0.007804798893630505,0.012896746397018433,0.011580427177250385,294,0.007804798893630505
+497,0.00791964028030634,0.00859123282134533,0.015068662352859974,0.015206110663712025,294,0.00859123282134533
+498,0.0070487139746546745,0.0076881349086761475,0.01165072526782751,0.007738900370895863,294,0.0076881349086761475
+499,0.007284111808985472,0.007765087299048901,0.016179997473955154,0.013646643608808517,294,0.007765087299048901
+500,0.0071711111813783646,0.00804508663713932,0.012900378555059433,0.010624343529343605,294,0.00804508663713932

splits/compute_chamfer_splits.py

@@ -0,0 +1,753 @@
+#!/usr/bin/env python3
+"""Compute STL-based Chamfer geometry splits for DrivAerML.
+
+This is intentionally standalone so it can be copied to the machine that has
+the STL files. It expects a DrivAerML-style directory layout:
+
+    DATA_ROOT/
+      run_1/drivaer_1.stl
+      run_2/drivaer_2.stl
+      ...
+
+Outputs:
+  - sampled point clouds cached as NPZ files
+  - chamfer_metrics.csv with nearest-neighbor and outlier scores
+  - chamfer_manifest.json with geometry_{train,val,test}
+  - optional chamfer_distance_matrix.npy, a symmetric NxN float32 matrix
+  - optional sparse train subsets when a base manifest with full_train exists
+
+Install dependencies on the data machine:
+
+    python -m pip install numpy scipy trimesh
+
+Example:
+
+    python compute_chamfer_splits.py \
+      --data-root /data/drivaerml \
+      --output-dir /data/drivaerml_chamfer \
+      --samples 4096 \
+      --workers 16 \
+      --base-manifest /path/to/drivaerml/splits/manifest.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import json
+import math
+import random
+import sys
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable
+
+import numpy as np
+
+
+N_CASES = 500
+HIDDEN_TEST_IDS = {
+    167,
+    211,
+    218,
+    221,
+    248,
+    282,
+    291,
+    295,
+    316,
+    325,
+    329,
+    364,
+    370,
+    376,
+    403,
+    473,
+}
+PUBLIC_RUN_IDS = [i for i in range(1, N_CASES + 1) if i not in HIDDEN_TEST_IDS]
+DEFAULT_TEST_FRACTION = 0.2
+DEFAULT_VAL_FRACTION = 0.1
+DEFAULT_SEED = 42
+cKDTree = None
+trimesh = None
+
+
+@dataclass(frozen=True)
+class RunFile:
+    run_id: int
+    stl_path: Path
+
+
+def case_id(run_id: int) -> str:
+    return f"run_{run_id}"
+
+
+def run_id(case: str) -> int:
+    if not case.startswith("run_"):
+        raise ValueError(f"bad case id: {case!r}")
+    return int(case.split("_", 1)[1])
+
+
+def require_dependencies() -> None:
+    global cKDTree, trimesh
+    try:
+        from scipy.spatial import cKDTree as scipy_ckdtree
+    except Exception as exc:  # pragma: no cover - dependency guard
+        raise SystemExit(
+            "Missing dependency scipy. Install with: python -m pip install numpy scipy trimesh"
+        ) from exc
+    try:
+        import trimesh as trimesh_module
+    except Exception as exc:  # pragma: no cover - dependency guard
+        raise SystemExit(
+            "Missing dependency trimesh. Install with: python -m pip install numpy scipy trimesh"
+        ) from exc
+    cKDTree = scipy_ckdtree
+    trimesh = trimesh_module
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Compute STL-surface Chamfer distances and DrivAerML geometry splits.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument(
+        "--data-root",
+        type=Path,
+        required=True,
+        help="Directory containing run_N/drivaer_N.stl files.",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        required=True,
+        help="Directory where matrices, metrics, and manifests will be written.",
+    )
+    parser.add_argument(
+        "--samples",
+        type=int,
+        default=4096,
+        help="Surface sample count per STL. 4096 is a practical first pass; 10000+ is better for final splits.",
+    )
+    parser.add_argument(
+        "--workers",
+        type=int,
+        default=8,
+        help="Thread workers used for pairwise nearest-neighbor queries.",
+    )
+    parser.add_argument(
+        "--sample-workers",
+        type=int,
+        default=1,
+        help="Thread workers used while loading and sampling STLs. Keep this low for large DrivAerML files.",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=DEFAULT_SEED,
+        help="Base random seed for deterministic surface sampling and split selection.",
+    )
+    parser.add_argument(
+        "--k-neighbors",
+        type=int,
+        default=10,
+        help="K used for the local-isolation geometry score.",
+    )
+    parser.add_argument(
+        "--test-fraction",
+        type=float,
+        default=DEFAULT_TEST_FRACTION,
+        help="Fraction held out as OOD test for geometry.",
+    )
+    parser.add_argument(
+        "--val-fraction",
+        type=float,
+        default=DEFAULT_VAL_FRACTION,
+        help="Overall validation fraction. Validation is sampled from the train-side pool.",
+    )
+    parser.add_argument(
+        "--score",
+        choices=["knn", "medoid", "mean"],
+        default="knn",
+        help="Score used to rank OOD geometry cases.",
+    )
+    parser.add_argument(
+        "--center",
+        choices=["none", "bbox", "centroid"],
+        default="none",
+        help="How to remove translation before Chamfer. Use none when STLs share a common coordinate frame.",
+    )
+    parser.add_argument(
+        "--scale-mode",
+        choices=["global_median_bbox", "per_mesh_bbox", "none"],
+        default="global_median_bbox",
+        help="How to scale coordinates before Chamfer. global_median_bbox keeps real relative vehicle size.",
+    )
+    parser.add_argument(
+        "--runs",
+        type=str,
+        default="public",
+        help=(
+            "Run IDs to process: public, all, or a comma/range expression like "
+            "1,2,10-20. Hidden public-unavailable runs are excluded only with 'public'."
+        ),
+    )
+    parser.add_argument(
+        "--base-manifest",
+        type=Path,
+        default=None,
+        help=(
+            "Optional existing split manifest. If it contains full_train/full_val/full_test, "
+            "the script also writes geometry_medium/scarce/super_scarce splits."
+        ),
+    )
+    parser.add_argument(
+        "--force-resample",
+        action="store_true",
+        help="Ignore cached point clouds and resample all STLs.",
+    )
+    parser.add_argument(
+        "--force-matrix",
+        action="store_true",
+        help="Recompute the Chamfer matrix even if a compatible matrix already exists.",
+    )
+    parser.add_argument(
+        "--write-matrix",
+        action="store_true",
+        help="Write chamfer_distance_matrix.npy and its metadata JSON. Omitted by default to keep the split package lean.",
+    )
+    parser.add_argument(
+        "--allow-missing",
+        action="store_true",
+        help="Process the subset of requested runs whose STLs exist. Without this, missing STLs are an error.",
+    )
+    parser.add_argument(
+        "--write-csv-matrix",
+        action="store_true",
+        help="Also write chamfer_distance_matrix.csv from the in-memory matrix.",
+    )
+    return parser.parse_args()
+
+
+def parse_run_expression(expr: str) -> list[int]:
+    expr = expr.strip().lower()
+    if expr == "public":
+        return PUBLIC_RUN_IDS.copy()
+    if expr == "all":
+        return list(range(1, N_CASES + 1))
+
+    result: set[int] = set()
+    for token in expr.split(","):
+        token = token.strip()
+        if not token:
+            continue
+        if "-" in token:
+            start_s, end_s = token.split("-", 1)
+            start, end = int(start_s), int(end_s)
+            if start > end:
+                start, end = end, start
+            result.update(range(start, end + 1))
+        else:
+            result.add(int(token))
+    runs = sorted(result)
+    bad = [rid for rid in runs if rid < 1 or rid > N_CASES]
+    if bad:
+        raise SystemExit(f"Run IDs must be in 1..{N_CASES}; bad values: {bad}")
+    return runs
+
+
+def discover_files(data_root: Path, requested_runs: Iterable[int], allow_missing: bool) -> list[RunFile]:
+    files: list[RunFile] = []
+    missing: list[int] = []
+    for rid in requested_runs:
+        path = data_root / f"run_{rid}" / f"drivaer_{rid}.stl"
+        if path.exists() and path.stat().st_size > 0:
+            files.append(RunFile(rid, path))
+        else:
+            missing.append(rid)
+
+    if missing and not allow_missing:
+        preview = ", ".join(str(x) for x in missing[:20])
+        suffix = " ..." if len(missing) > 20 else ""
+        raise SystemExit(
+            f"Missing {len(missing)} requested STL files under {data_root}: {preview}{suffix}\n"
+            "Use --allow-missing to compute with the available subset."
+        )
+    if not files:
+        raise SystemExit(f"No STL files found under {data_root}")
+    return files
+
+
+def load_mesh(path: Path) -> "trimesh.Trimesh":
+    mesh = trimesh.load_mesh(path, process=False)
+    if isinstance(mesh, trimesh.Scene):
+        geometries = [g for g in mesh.geometry.values() if len(g.faces) > 0]
+        if not geometries:
+            raise ValueError(f"{path} did not contain any mesh geometry")
+        mesh = trimesh.util.concatenate(geometries)
+    if not isinstance(mesh, trimesh.Trimesh):
+        raise ValueError(f"{path} loaded as unsupported object: {type(mesh)!r}")
+    if len(mesh.faces) == 0:
+        raise ValueError(f"{path} has no faces")
+    return mesh
+
+
+def sample_mesh_surface(mesh: "trimesh.Trimesh", count: int, seed: int) -> np.ndarray:
+    """Area-sample points from a triangular mesh using a local RNG."""
+    rng = np.random.default_rng(seed)
+    areas = np.asarray(mesh.area_faces, dtype=np.float64)
+    total_area = float(np.sum(areas))
+    if not math.isfinite(total_area) or total_area <= 0.0:
+        raise ValueError("mesh surface area is zero or invalid")
+
+    face_indices = rng.choice(len(mesh.faces), size=count, replace=True, p=areas / total_area)
+    triangles = np.asarray(mesh.vertices[mesh.faces[face_indices]], dtype=np.float64)
+
+    u = rng.random(count)
+    v = rng.random(count)
+    outside = (u + v) > 1.0
+    u[outside] = 1.0 - u[outside]
+    v[outside] = 1.0 - v[outside]
+    points = triangles[:, 0] + u[:, None] * (triangles[:, 1] - triangles[:, 0]) + v[:, None] * (
+        triangles[:, 2] - triangles[:, 0]
+    )
+    return np.asarray(points, dtype=np.float32)
+
+
+def cache_path(cache_dir: Path, run: RunFile, samples: int, seed: int) -> Path:
+    source = f"{run.stl_path.resolve()}:{run.stl_path.stat().st_size}:{samples}:{seed}:{run.run_id}"
+    digest = hashlib.sha256(source.encode("utf-8")).hexdigest()[:16]
+    return cache_dir / f"run_{run.run_id:03d}_samples_{samples}_{digest}.npz"
+
+
+def sample_one(run: RunFile, cache_dir: Path, samples: int, seed: int, force: bool) -> tuple[int, np.ndarray, np.ndarray, np.ndarray]:
+    cache = cache_path(cache_dir, run, samples, seed)
+    if cache.exists() and not force:
+        data = np.load(cache)
+        points = np.asarray(data["points"], dtype=np.float32)
+        bbox_min = np.asarray(data["bbox_min"], dtype=np.float32)
+        bbox_max = np.asarray(data["bbox_max"], dtype=np.float32)
+        if points.shape == (samples, 3):
+            return run.run_id, points, bbox_min, bbox_max
+
+    mesh = load_mesh(run.stl_path)
+    points = sample_mesh_surface(mesh, samples, seed + run.run_id)
+    bbox_min = np.asarray(mesh.bounds[0], dtype=np.float32)
+    bbox_max = np.asarray(mesh.bounds[1], dtype=np.float32)
+    np.savez_compressed(
+        cache,
+        run_id=np.asarray(run.run_id, dtype=np.int32),
+        points=points,
+        bbox_min=bbox_min,
+        bbox_max=bbox_max,
+        source=str(run.stl_path),
+        samples=np.asarray(samples, dtype=np.int32),
+        seed=np.asarray(seed, dtype=np.int32),
+    )
+    return run.run_id, points, bbox_min, bbox_max
+
+
+def sample_point_clouds(
+    runs: list[RunFile],
+    cache_dir: Path,
+    samples: int,
+    seed: int,
+    workers: int,
+    force: bool,
+) -> tuple[list[int], list[np.ndarray], np.ndarray, np.ndarray]:
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    started = time.time()
+    print(f"Sampling/caching {len(runs)} STL point clouds with {samples} points each...")
+
+    outputs: list[tuple[int, np.ndarray, np.ndarray, np.ndarray]] = []
+    with ThreadPoolExecutor(max_workers=max(1, workers)) as pool:
+        futures = [pool.submit(sample_one, run, cache_dir, samples, seed, force) for run in runs]
+        for idx, future in enumerate(as_completed(futures), start=1):
+            outputs.append(future.result())
+            if idx == len(futures) or idx % 25 == 0:
+                print(f"  sampled {idx}/{len(futures)}")
+
+    outputs.sort(key=lambda x: x[0])
+    run_ids = [x[0] for x in outputs]
+    clouds = [x[1] for x in outputs]
+    bbox_min = np.stack([x[2] for x in outputs])
+    bbox_max = np.stack([x[3] for x in outputs])
+    print(f"Sampling complete in {time.time() - started:.1f}s")
+    return run_ids, clouds, bbox_min, bbox_max
+
+
+def normalize_clouds(
+    clouds: list[np.ndarray],
+    bbox_min: np.ndarray,
+    bbox_max: np.ndarray,
+    center: str,
+    scale_mode: str,
+) -> tuple[list[np.ndarray], dict[str, float | str]]:
+    result: list[np.ndarray] = []
+    bbox_diag = np.linalg.norm(bbox_max - bbox_min, axis=1)
+    global_scale = float(np.median(bbox_diag))
+    if not math.isfinite(global_scale) or global_scale <= 0:
+        global_scale = 1.0
+
+    for idx, points in enumerate(clouds):
+        pts = points.astype(np.float32, copy=True)
+        if center == "bbox":
+            pts -= ((bbox_min[idx] + bbox_max[idx]) * 0.5).astype(np.float32)
+        elif center == "centroid":
+            pts -= pts.mean(axis=0, keepdims=True)
+
+        if scale_mode == "global_median_bbox":
+            scale = global_scale
+        elif scale_mode == "per_mesh_bbox":
+            scale = float(bbox_diag[idx]) if bbox_diag[idx] > 0 else 1.0
+        else:
+            scale = 1.0
+        pts /= np.float32(scale)
+        result.append(pts)
+
+    metadata: dict[str, float | str] = {
+        "center": center,
+        "scale_mode": scale_mode,
+        "global_median_bbox_diag": global_scale,
+    }
+    return result, metadata
+
+
+def pair_chamfer_rms(i: int, j: int, clouds: list[np.ndarray], trees: list[cKDTree]) -> tuple[int, int, float]:
+    a_to_b, _ = trees[j].query(clouds[i], k=1)
+    b_to_a, _ = trees[i].query(clouds[j], k=1)
+    chamfer = float(np.sqrt(0.5 * (np.mean(a_to_b * a_to_b) + np.mean(b_to_a * b_to_a))))
+    return i, j, chamfer
+
+
+def matrix_metadata_path(output_dir: Path) -> Path:
+    return output_dir / "chamfer_distance_matrix.meta.json"
+
+
+def matrix_is_compatible(output_dir: Path, run_ids: list[int], args: argparse.Namespace) -> bool:
+    matrix_path = output_dir / "chamfer_distance_matrix.npy"
+    meta_path = matrix_metadata_path(output_dir)
+    if not matrix_path.exists() or not meta_path.exists():
+        return False
+    try:
+        meta = json.loads(meta_path.read_text(encoding="utf-8"))
+    except Exception:
+        return False
+    return (
+        meta.get("run_ids") == run_ids
+        and meta.get("samples") == args.samples
+        and meta.get("seed") == args.seed
+        and meta.get("center") == args.center
+        and meta.get("scale_mode") == args.scale_mode
+        and meta.get("metric") == "symmetric_chamfer_rms"
+    )
+
+
+def compute_chamfer_matrix(
+    run_ids: list[int],
+    clouds: list[np.ndarray],
+    output_dir: Path,
+    args: argparse.Namespace,
+    normalization_metadata: dict[str, float | str],
+) -> np.ndarray:
+    matrix_path = output_dir / "chamfer_distance_matrix.npy"
+    if matrix_is_compatible(output_dir, run_ids, args) and not args.force_matrix:
+        print(f"Loading existing compatible matrix: {matrix_path}")
+        return np.load(matrix_path)
+
+    n = len(clouds)
+    print(f"Building {n} KD trees...")
+    trees = [cKDTree(points) for points in clouds]
+    matrix = np.zeros((n, n), dtype=np.float32)
+    pairs = [(i, j) for i in range(n) for j in range(i + 1, n)]
+    started = time.time()
+    print(f"Computing {len(pairs)} pairwise symmetric Chamfer RMS distances...")
+
+    with ThreadPoolExecutor(max_workers=max(1, args.workers)) as pool:
+        futures = [pool.submit(pair_chamfer_rms, i, j, clouds, trees) for i, j in pairs]
+        for done, future in enumerate(as_completed(futures), start=1):
+            i, j, value = future.result()
+            matrix[i, j] = matrix[j, i] = np.float32(value)
+            if done == len(futures) or done % 1000 == 0:
+                elapsed = time.time() - started
+                rate = done / elapsed if elapsed > 0 else 0.0
+                remaining = (len(futures) - done) / rate if rate > 0 else float("nan")
+                print(
+                    f"  pairs {done}/{len(futures)} "
+                    f"({100 * done / len(futures):5.1f}%), ETA {remaining / 60:5.1f} min"
+                )
+
+    if args.write_matrix:
+        np.save(matrix_path, matrix)
+        metadata = {
+            "run_ids": run_ids,
+            "samples": args.samples,
+            "seed": args.seed,
+            "center": args.center,
+            "scale_mode": args.scale_mode,
+            "metric": "symmetric_chamfer_rms",
+            "created_unix_time": time.time(),
+            **normalization_metadata,
+        }
+        matrix_metadata_path(output_dir).write_text(json.dumps(metadata, indent=2) + "\n", encoding="utf-8")
+        print(f"Matrix written: {matrix_path}")
+    return matrix
+
+
+def write_csv_matrix(path: Path, run_ids: list[int], matrix: np.ndarray) -> None:
+    with path.open("w", encoding="utf-8", newline="") as f:
+        writer = csv.writer(f)
+        writer.writerow(["run", *[case_id(rid) for rid in run_ids]])
+        for rid, row in zip(run_ids, matrix):
+            writer.writerow([case_id(rid), *[f"{float(x):.8g}" for x in row]])
+
+
+def metric_values(run_ids: list[int], matrix: np.ndarray, k_neighbors: int) -> tuple[list[dict[str, float | int]], dict[int, float]]:
+    n = len(run_ids)
+    if n < 2:
+        raise SystemExit("At least two STL files are required to compute Chamfer metrics")
+    k = min(max(1, k_neighbors), n - 1)
+    means = matrix.sum(axis=1) / (n - 1)
+    medoid_index = int(np.argmin(means))
+    medoid_run = run_ids[medoid_index]
+    rows: list[dict[str, float | int]] = []
+    knn_scores: dict[int, float] = {}
+
+    for idx, rid in enumerate(run_ids):
+        nonself = np.delete(matrix[idx], idx)
+        sorted_dist = np.sort(nonself)
+        nearest = float(sorted_dist[0])
+        knn_mean = float(np.mean(sorted_dist[:k]))
+        mean_all = float(means[idx])
+        medoid_distance = float(matrix[idx, medoid_index])
+        knn_scores[rid] = knn_mean
+        rows.append(
+            {
+                "run": rid,
+                "nearest_neighbor_chamfer": nearest,
+                f"mean_{k}_nn_chamfer": knn_mean,
+                "mean_all_chamfer": mean_all,
+                "medoid_chamfer": medoid_distance,
+                "medoid_run": medoid_run,
+            }
+        )
+    return rows, knn_scores
+
+
+def score_map(
+    run_ids: list[int],
+    matrix: np.ndarray,
+    metrics: list[dict[str, float | int]],
+    score_name: str,
+    k_neighbors: int,
+) -> dict[int, float]:
+    if score_name == "knn":
+        key = f"mean_{min(max(1, k_neighbors), len(run_ids) - 1)}_nn_chamfer"
+    elif score_name == "medoid":
+        key = "medoid_chamfer"
+    else:
+        key = "mean_all_chamfer"
+    return {int(row["run"]): float(row[key]) for row in metrics}
+
+
+def split_pool(pool: list[int], val_fraction_of_pool: float, seed: int, salt: str) -> tuple[list[int], list[int]]:
+    rng_seed = hashlib.sha256(f"{seed}:{salt}".encode("utf-8")).digest()[:8]
+    rng = random.Random(int.from_bytes(rng_seed, "big"))
+    shuffled = pool.copy()
+    rng.shuffle(shuffled)
+    n_val = round(len(pool) * val_fraction_of_pool)
+    val = sorted(shuffled[:n_val])
+    train = sorted(shuffled[n_val:])
+    return train, val
+
+
+def ranked_ood_split(
+    scores: dict[int, float],
+    test_fraction: float,
+    val_fraction: float,
+    seed: int,
+    salt: str,
+) -> tuple[list[int], list[int], list[int]]:
+    ranked = sorted(scores, key=lambda rid: (scores[rid], rid))
+    n_test = round(len(ranked) * test_fraction)
+    test = sorted(ranked[-n_test:])
+    pool = sorted(ranked[:-n_test])
+    val_fraction_of_pool = val_fraction / (1.0 - test_fraction)
+    train, val = split_pool(pool, val_fraction_of_pool, seed, salt)
+    return train, val, test
+
+
+def make_case_ids(values: Iterable[int]) -> list[str]:
+    return [case_id(rid) for rid in sorted(values)]
+
+
+def farthest_order(pool: list[int], run_to_index: dict[int, int], matrix: np.ndarray, seed: int) -> list[int]:
+    if not pool:
+        return []
+
+    mean_dist = {
+        rid: float(np.mean([matrix[run_to_index[rid], run_to_index[other]] for other in pool if other != rid]))
+        for rid in pool
+    }
+    first = max(pool, key=lambda rid: (mean_dist[rid], -rid))
+    selected = [first]
+    remaining = [rid for rid in pool if rid != first]
+
+    rng_seed = hashlib.sha256(f"{seed}:geometry_sparse_order".encode("utf-8")).digest()[:8]
+    rng = random.Random(int.from_bytes(rng_seed, "big"))
+    tie_break = {rid: rng.random() for rid in pool}
+
+    while remaining:
+        next_rid = max(
+            remaining,
+            key=lambda rid: (
+                min(matrix[run_to_index[rid], run_to_index[chosen]] for chosen in selected),
+                tie_break[rid],
+            ),
+        )
+        selected.append(next_rid)
+        remaining.remove(next_rid)
+    return selected
+
+
+def load_base_manifest(path: Path | None) -> dict[str, list[str]]:
+    if path is None:
+        candidate = Path(__file__).resolve().parents[1] / "splits" / "manifest.json"
+        if not candidate.exists():
+            return {}
+        path = candidate
+    if not path.exists():
+        raise SystemExit(f"Base manifest does not exist: {path}")
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def write_metrics_csv(path: Path, metrics: list[dict[str, float | int]], scores: dict[int, float]) -> None:
+    fieldnames = list(metrics[0].keys()) + ["ood_score"]
+    with path.open("w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        for row in metrics:
+            out = dict(row)
+            out["ood_score"] = scores[int(row["run"])]
+            writer.writerow(out)
+
+
+def build_manifest(
+    run_ids: list[int],
+    matrix: np.ndarray,
+    scores: dict[int, float],
+    args: argparse.Namespace,
+) -> dict[str, list[str]]:
+    train, val, test = ranked_ood_split(
+        scores,
+        test_fraction=args.test_fraction,
+        val_fraction=args.val_fraction,
+        seed=args.seed,
+        salt="geometry_val_selection",
+    )
+    manifest: dict[str, list[str]] = {
+        "geometry_train": make_case_ids(train),
+        "geometry_val": make_case_ids(val),
+        "geometry_test": make_case_ids(test),
+    }
+
+    base = load_base_manifest(args.base_manifest)
+    required = {"full_train", "full_val", "full_test"}
+    if not required <= set(base):
+        return manifest
+
+    available = set(run_ids)
+    full_train = [run_id(cid) for cid in base["full_train"] if run_id(cid) in available]
+    if len(full_train) < 20:
+        return manifest
+
+    run_to_index = {rid: idx for idx, rid in enumerate(run_ids)}
+    order = farthest_order(full_train, run_to_index, matrix, args.seed)
+    medium = round(len(order) / 3)
+    scarce = round(len(order) / 6)
+    super_scarce = max(1, round(len(order) / 36))
+    sparse_sets = {
+        "geometry_medium": sorted(order[:medium]),
+        "geometry_scarce": sorted(order[:scarce]),
+        "geometry_super_scarce": sorted(order[:super_scarce]),
+    }
+    for name, ids in sparse_sets.items():
+        manifest[f"{name}_train"] = make_case_ids(ids)
+        manifest[f"{name}_val"] = [cid for cid in base["full_val"] if run_id(cid) in available]
+        manifest[f"{name}_test"] = [cid for cid in base["full_test"] if run_id(cid) in available]
+    manifest["geometry_sparse_order"] = make_case_ids(order)
+    return manifest
+
+
+def summarize_split(name: str, manifest: dict[str, list[str]]) -> str:
+    return (
+        f"{name}: "
+        f"train={len(manifest.get(name + '_train', []))}, "
+        f"val={len(manifest.get(name + '_val', []))}, "
+        f"test={len(manifest.get(name + '_test', []))}"
+    )
+
+
+def main() -> None:
+    args = parse_args()
+    require_dependencies()
+    args.data_root = args.data_root.expanduser().resolve()
+    args.output_dir = args.output_dir.expanduser().resolve()
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+
+    requested_runs = parse_run_expression(args.runs)
+    run_files = discover_files(args.data_root, requested_runs, args.allow_missing)
+    print(f"Found {len(run_files)} STL files under {args.data_root}")
+
+    run_ids, raw_clouds, bbox_min, bbox_max = sample_point_clouds(
+        run_files,
+        cache_dir=args.output_dir / "point_cloud_cache",
+        samples=args.samples,
+        seed=args.seed,
+        workers=args.sample_workers,
+        force=args.force_resample,
+    )
+    clouds, normalization_metadata = normalize_clouds(
+        raw_clouds,
+        bbox_min,
+        bbox_max,
+        center=args.center,
+        scale_mode=args.scale_mode,
+    )
+    matrix = compute_chamfer_matrix(run_ids, clouds, args.output_dir, args, normalization_metadata)
+    if args.write_csv_matrix:
+        write_csv_matrix(args.output_dir / "chamfer_distance_matrix.csv", run_ids, matrix)
+
+    metrics, _knn_scores = metric_values(run_ids, matrix, args.k_neighbors)
+    scores = score_map(run_ids, matrix, metrics, args.score, args.k_neighbors)
+    write_metrics_csv(args.output_dir / "chamfer_metrics.csv", metrics, scores)
+
+    manifest = build_manifest(run_ids, matrix, scores, args)
+    manifest_path = args.output_dir / "chamfer_manifest.json"
+    manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
+
+    print()
+    print("Chamfer split summary")
+    print("=" * 60)
+    print(f"Runs: {len(run_ids)}")
+    print(f"Metric: symmetric Chamfer RMS; score={args.score}")
+    print(f"Metrics: {args.output_dir / 'chamfer_metrics.csv'}")
+    if args.write_matrix:
+        print(f"Matrix:  {args.output_dir / 'chamfer_distance_matrix.npy'}")
+    else:
+        print("Matrix:  not written; pass --write-matrix to save the full NPY")
+    print(f"Manifest: {manifest_path}")
+    print("  " + summarize_split("geometry", manifest))
+    for prefix in ["geometry_medium", "geometry_scarce", "geometry_super_scarce"]:
+        if f"{prefix}_train" in manifest:
+            print("  " + summarize_split(prefix, manifest))
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        sys.exit("Interrupted")

splits/download_hf_inputs.py

@@ -0,0 +1,233 @@
+"""Download DrivAerML split-regeneration inputs from Hugging Face.
+
+Default behavior downloads only the aggregate CSV files needed by
+splits/generate_splits.py and the diagnostic plots:
+
+    python3 splits/download_hf_inputs.py --output-dir data
+
+Optional flags pull the PNGs used by report figures, the PNGs used to recompute
+the rear-separation image score, or the STL files used to recompute
+chamfer_metrics.csv. STL downloads are intentionally opt-in because they are
+large.
+"""
+
+from __future__ import annotations
+
+import argparse
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import os
+from pathlib import Path
+import sys
+from urllib.error import HTTPError, URLError
+from urllib.parse import quote
+from urllib.request import Request, urlopen
+
+
+REPO_ID = "neashton/drivaerml"
+REVISION = "main"
+HIDDEN_TEST_IDS = {
+    167, 211, 218, 221, 248, 282, 291, 295,
+    316, 325, 329, 364, 370, 376, 403, 473,
+}
+PUBLIC_RUN_IDS = [run for run in range(1, 501) if run not in HIDDEN_TEST_IDS]
+AGGREGATE_FILES = [
+    "force_mom_all.csv",
+    "geo_parameters_all.csv",
+]
+REPORT_IMAGE_FILES = [
+    "run_294/images/fig_run294_SRS_surf-ySide_grid.png",
+    "run_393/images/fig_run393_SRS_surf-ySide_grid.png",
+    "run_100/images/fig_run100_SRS_magUMeanNormTrim_yNormal-2_yNormal_p00000.png",
+    "run_406/images/fig_run406_SRS_magUMeanNormTrim_yNormal-2_yNormal_p00000.png",
+]
+REAR_XNORMAL_POSITIONS = [
+    "p43000",
+    "p45000",
+    "p47000",
+    "p49000",
+    "p51000",
+    "p53000",
+    "p55000",
+]
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Download source inputs for DrivAerML split regeneration.",
+    )
+    parser.add_argument(
+        "--repo-id",
+        default=REPO_ID,
+        help=f"Hugging Face dataset repo ID. Default: {REPO_ID}",
+    )
+    parser.add_argument(
+        "--revision",
+        default=REVISION,
+        help=f"Hub revision, branch, or tag. Default: {REVISION}",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path("data"),
+        help="Directory where files are written, preserving dataset-relative paths.",
+    )
+    parser.add_argument(
+        "--runs",
+        default="public",
+        help="Run IDs for optional per-run downloads: public, all, or a comma/range expression like 1,10-20.",
+    )
+    parser.add_argument(
+        "--include-report-images",
+        action="store_true",
+        help="Download the four PNGs needed to render the committed example figures from source images.",
+    )
+    parser.add_argument(
+        "--include-image-score-pngs",
+        action="store_true",
+        help="Download centreline and near-rear xNormal PNGs used to recompute image_metrics.csv.",
+    )
+    parser.add_argument(
+        "--include-stls",
+        action="store_true",
+        help="Download run_*/drivaer_*.stl files needed to recompute chamfer_metrics.csv. This is large.",
+    )
+    parser.add_argument(
+        "--workers",
+        type=int,
+        default=8,
+        help="Parallel downloads. Default: 8.",
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Redownload files that already exist.",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Print the file list without downloading.",
+    )
+    return parser.parse_args()
+
+
+def parse_run_expression(expr: str) -> list[int]:
+    expr = expr.strip().lower()
+    if expr == "public":
+        return PUBLIC_RUN_IDS.copy()
+    if expr == "all":
+        return list(range(1, 501))
+
+    runs: set[int] = set()
+    for part in expr.split(","):
+        part = part.strip()
+        if not part:
+            continue
+        if "-" in part:
+            start, end = [int(value) for value in part.split("-", 1)]
+            if start > end:
+                start, end = end, start
+            runs.update(range(start, end + 1))
+        else:
+            runs.add(int(part))
+    bad = sorted(run for run in runs if run < 1 or run > 500)
+    if bad:
+        raise SystemExit(f"Run IDs must be in 1..500, got: {bad[:10]}")
+    return sorted(runs)
+
+
+def image_score_files(run_ids: list[int]) -> list[str]:
+    paths = []
+    for run in run_ids:
+        prefix = f"run_{run}/images/fig_run{run}_SRS"
+        paths.append(f"{prefix}_magUMeanNormTrim_yNormal-2_yNormal_p00000.png")
+        paths.extend(
+            f"{prefix}_magUMeanNormTrim_xNormal-2_xNormal_{position}.png"
+            for position in REAR_XNORMAL_POSITIONS
+        )
+    return paths
+
+
+def stl_files(run_ids: list[int]) -> list[str]:
+    return [f"run_{run}/drivaer_{run}.stl" for run in run_ids]
+
+
+def resolve_url(repo_id: str, revision: str, relpath: str) -> str:
+    escaped_path = quote(relpath, safe="/")
+    escaped_revision = quote(revision, safe="")
+    return f"https://huggingface.co/datasets/{repo_id}/resolve/{escaped_revision}/{escaped_path}"
+
+
+def request_for(url: str) -> Request:
+    headers = {}
+    token = os.environ.get("HF_TOKEN")
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    return Request(url, headers=headers)
+
+
+def download_one(repo_id: str, revision: str, output_dir: Path, relpath: str, overwrite: bool) -> str:
+    target = output_dir / relpath
+    if target.exists() and target.stat().st_size > 0 and not overwrite:
+        return f"skip {relpath}"
+
+    target.parent.mkdir(parents=True, exist_ok=True)
+    tmp = target.with_suffix(target.suffix + ".tmp")
+    url = resolve_url(repo_id, revision, relpath)
+    try:
+        with urlopen(request_for(url), timeout=120) as response, tmp.open("wb") as f:
+            while True:
+                chunk = response.read(1024 * 1024)
+                if not chunk:
+                    break
+                f.write(chunk)
+        tmp.replace(target)
+    except (HTTPError, URLError) as exc:
+        if tmp.exists():
+            tmp.unlink()
+        raise RuntimeError(f"failed {relpath}: {exc}") from exc
+    return f"ok   {relpath}"
+
+
+def main() -> None:
+    args = parse_args()
+    run_ids = parse_run_expression(args.runs)
+    paths: set[str] = set(AGGREGATE_FILES)
+
+    if args.include_report_images:
+        paths.update(REPORT_IMAGE_FILES)
+    if args.include_image_score_pngs:
+        paths.update(image_score_files(run_ids))
+    if args.include_stls:
+        paths.update(stl_files(run_ids))
+
+    selected = sorted(paths)
+    print(f"Repository: {args.repo_id}@{args.revision}")
+    print(f"Output dir: {args.output_dir}")
+    print(f"Files: {len(selected)}")
+    if args.include_stls:
+        print("STL download requested; this can require tens of GB for all public runs.")
+    if args.dry_run:
+        for relpath in selected:
+            print(relpath)
+        return
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    errors = []
+    with ThreadPoolExecutor(max_workers=max(1, args.workers)) as pool:
+        futures = {
+            pool.submit(download_one, args.repo_id, args.revision, args.output_dir, relpath, args.overwrite): relpath
+            for relpath in selected
+        }
+        for future in as_completed(futures):
+            try:
+                print(future.result())
+            except RuntimeError as exc:
+                errors.append(str(exc))
+                print(errors[-1], file=sys.stderr)
+
+    if errors:
+        raise SystemExit(f"{len(errors)} download(s) failed")
+
+
+if __name__ == "__main__":
+    main()

splits/generate_splits.py

@@ -0,0 +1,1056 @@
+"""Generate deterministic train/val/test splits for the DrivAerML dataset.
+
+Produces a manifest.json containing DrivAerML split types with train/val/test
+keys:
+
+    {
+        "full_train": ["run_1", ...],
+        "full_val": [...],
+        "full_test": [...],
+        ...
+    }
+
+Split families:
+
+  1. full            - seed-42 random public split, 400/34/50
+  2. medium          - same val/test as full, train is 1/3 subsample
+  3. scarce          - same val/test as full, train is 1/6 subsample
+  4. super_scarce    - same val/test as full, train is 1/36 subsample
+  5. geometry        - OOD STL-surface Chamfer geometry split
+  6. high_drag       - OOD high-drag split from force_mom_all.csv
+  7. low_drag        - OOD low-drag split from force_mom_all.csv
+  8. rear_separation - OOD image-derived rear-surface separation split
+
+For every OOD split, the validation set is drawn from the training-side
+population so that hyperparameter tuning never sees out-of-distribution data.
+
+Usage:
+    python3 splits/generate_splits.py
+
+The script reads force_mom_all.csv and geo_parameters_all.csv from the dataset
+root or data/ folder, and the committed splits/chamfer_metrics.csv when
+available. Outside that context it falls back to deterministic force/geometry
+proxies and omits the Chamfer split if the Chamfer metrics are missing, but the
+official manifest should be regenerated with all real source files present.
+"""
+
+from __future__ import annotations
+
+import csv
+import hashlib
+import json
+import math
+import os
+import random
+from pathlib import Path
+
+import numpy as np
+
+### ---- Dataset constants -------------------------------------------------
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+PACKAGE_ROOT = SCRIPT_DIR
+DATA_DIR = PACKAGE_ROOT
+SPLITS_DIR = PACKAGE_ROOT
+DATA_ROOT = Path(os.environ.get("DRIVAERML_DATA_ROOT", DATA_DIR))
+N_CASES = 500
+HIDDEN_TEST_IDS = [167, 211, 218, 221, 248, 282, 291, 295, 316, 325, 329, 364, 370, 376, 403, 473]
+PUBLIC_RUN_IDS = [i for i in range(1, N_CASES + 1) if i not in set(HIDDEN_TEST_IDS)]
+N_PUBLIC = len(PUBLIC_RUN_IDS)
+
+# Seed-42 torch randperm over 1..500, after removing the 16 hidden runs. For
+# reference, these IDs match the public DrivAerMLDefaultSplitIDs implementation
+# in Noether.
+FULL_TRAIN_IDS = [
+    1, 2, 3, 5, 6, 7, 8, 9, 10, 13, 14, 15, 16, 17, 18, 21, 23, 25, 27, 28, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+    40, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 57, 58, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
+    72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
+    100, 101, 102, 103, 104, 105, 106, 107, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
+    125, 126, 128, 129, 130, 131, 132, 134, 135, 136, 137, 138, 139, 140, 141, 143, 144, 145, 146, 147, 148, 149,
+    151, 152, 153, 154, 155, 156, 157, 159, 160, 161, 162, 163, 164, 166, 168, 169, 170, 171, 172, 174, 175, 176,
+    178, 179, 181, 182, 183, 184, 185, 186, 189, 190, 192, 193, 194, 195, 196, 198, 200, 201, 202, 204, 206, 209,
+    212, 213, 214, 216, 217, 219, 220, 223, 224, 225, 227, 229, 230, 231, 232, 233, 235, 236, 237, 238, 239, 240,
+    242, 243, 244, 245, 246, 249, 250, 251, 254, 255, 256, 257, 259, 261, 262, 264, 265, 266, 267, 268, 269, 270,
+    272, 273, 274, 276, 277, 278, 279, 281, 283, 285, 286, 287, 288, 289, 292, 293, 294, 296, 297, 299, 300, 301,
+    302, 304, 305, 306, 307, 308, 309, 310, 312, 313, 314, 315, 317, 318, 319, 320, 323, 326, 327, 330, 331, 332,
+    333, 334, 335, 336, 338, 339, 340, 342, 343, 344, 345, 346, 347, 348, 349, 351, 353, 355, 356, 357, 358, 359,
+    360, 361, 362, 365, 367, 368, 369, 371, 373, 374, 375, 377, 378, 379, 381, 383, 384, 385, 386, 388, 389, 391,
+    392, 393, 394, 395, 396, 397, 398, 399, 400, 402, 404, 406, 407, 408, 409, 411, 412, 413, 414, 415, 416, 417,
+    418, 419, 420, 421, 422, 425, 426, 427, 430, 431, 432, 433, 434, 435, 437, 438, 439, 440, 442, 443, 444, 445,
+    446, 448, 449, 450, 451, 452, 453, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469,
+    470, 471, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 488, 489, 490, 491, 492, 493, 494,
+    495, 496, 497, 498, 499, 500,
+]
+
+FULL_VAL_IDS = [
+    4, 22, 56, 109, 150, 165, 177, 191, 228, 234, 241, 247, 252, 253, 260, 271, 275, 298, 303, 311, 321, 324, 328,
+    341, 352, 366, 380, 390, 401, 423, 441, 447, 454, 487,
+]
+
+FULL_TEST_IDS = [
+    11, 12, 19, 20, 24, 26, 29, 41, 55, 59, 108, 124, 127, 133, 142, 158, 173, 180, 187, 188, 197, 199, 203, 205,
+    207, 208, 210, 215, 222, 226, 258, 263, 280, 284, 290, 322, 337, 350, 354, 363, 372, 382, 387, 405, 410, 424,
+    428, 429, 436, 472,
+]
+
+### ---- Split parameters --------------------------------------------------
+
+SEED = 42
+MEDIUM_FRACTION = 1 / 3
+SCARCE_FRACTION = 1 / 6
+SUPER_SCARCE_FRACTION = 1 / 36
+OOD_TEST_FRACTION = 0.2
+VAL_FRACTION = 0.1
+TEST_FRACTION = 0.2
+VAL_FRACTION_OF_POOL = VAL_FRACTION / (1 - TEST_FRACTION)
+IMAGE_SPLIT_NAMES = [
+    "rear_separation",
+]
+REAR_XNORMAL_POSITIONS = [
+    "p43000",
+    "p45000",
+    "p47000",
+    "p49000",
+    "p51000",
+    "p53000",
+    "p55000",
+]
+CHAMFER_SPLIT_NAME = "geometry"
+CHAMFER_SCORE_COLUMNS = [
+    "ood_score",
+    "mean_10_nn_chamfer",
+    "mean_all_chamfer",
+    "medoid_chamfer",
+]
+
+
+### ---- Force/moment anchors used only for fallback mode ------------------
+
+# Exact rows observed from the public Hugging Face force_mom_all.csv page. The
+# loader replaces these with the complete CSV when it is available locally.
+FORCE_ANCHORS: dict[int, dict[str, float]] = {
+    1: {"cd": 0.3035117, "cl": 0.06772802, "clf": -0.03728616, "clr": 0.1050142, "cs": 0.04766758},
+    5: {"cd": 0.2453419, "cl": -0.04907301, "clf": -0.09896183, "clr": 0.04988882, "cs": -0.01021062},
+    10: {"cd": 0.2402401, "cl": -0.07391179, "clf": -0.1541897, "clr": 0.08027796, "cs": 0.00783546},
+    11: {"cd": 0.3158833, "cl": 0.1196749, "clf": -0.02481210, "clr": 0.1444870, "cs": 0.04994975},
+    19: {"cd": 0.3038487, "cl": 0.1185991, "clf": -0.04718844, "clr": 0.1657875, "cs": 0.05639504},
+    29: {"cd": 0.3283646, "cl": 0.1298925, "clf": -0.02271569, "clr": 0.1526082, "cs": 0.03849003},
+    39: {"cd": 0.3351154, "cl": 0.1231065, "clf": 0.003748379, "clr": 0.1193581, "cs": 0.05577402},
+    43: {"cd": 0.2502195, "cl": -0.1177773, "clf": -0.1582150, "clr": 0.04043769, "cs": 0.01570675},
+    47: {"cd": 0.3120275, "cl": 0.1793221, "clf": -0.02716440, "clr": 0.2064865, "cs": 0.02462079},
+    50: {"cd": 0.2544286, "cl": -0.1418390, "clf": -0.2093633, "clr": 0.06752422, "cs": 0.01592581},
+    75: {"cd": 0.2756486, "cl": 0.01647375, "clf": -0.1830802, "clr": 0.1995539, "cs": 0.01793691},
+    80: {"cd": 0.2577281, "cl": -0.09782907, "clf": -0.1215068, "clr": 0.02367777, "cs": 0.0009888834},
+    82: {"cd": 0.3068153, "cl": 0.08060897, "clf": -0.02908217, "clr": 0.1096911, "cs": 0.04824024},
+    92: {"cd": 0.2903494, "cl": 0.1571214, "clf": 0.04838630, "clr": 0.1087351, "cs": 0.02209977},
+    97: {"cd": 0.2852732, "cl": 0.08388843, "clf": -0.1118671, "clr": 0.1957555, "cs": 0.04262881},
+    100: {"cd": 0.2922108, "cl": 0.1476556, "clf": -0.02159046, "clr": 0.1692461, "cs": 0.02476801},
+    112: {"cd": 0.2967612, "cl": 0.03655082, "clf": -0.07972242, "clr": 0.1162732, "cs": 0.05404087},
+    115: {"cd": 0.3401304, "cl": 0.1374436, "clf": -0.04553256, "clr": 0.1829761, "cs": 0.03729802},
+    120: {"cd": 0.2750423, "cl": -0.09848844, "clf": -0.1386312, "clr": 0.04014276, "cs": 0.009683788},
+    124: {"cd": 0.2436567, "cl": -0.006719710, "clf": -0.1635679, "clr": 0.1568482, "cs": 0.02098023},
+    127: {"cd": 0.2891099, "cl": 0.1200496, "clf": -0.07284624, "clr": 0.1928958, "cs": 0.03356735},
+    131: {"cd": 0.2451220, "cl": -0.1103591, "clf": -0.1377357, "clr": 0.02737659, "cs": 0.006988701},
+    135: {"cd": 0.2940324, "cl": 0.1691341, "clf": 0.02229466, "clr": 0.1468394, "cs": 0.01989635},
+    143: {"cd": 0.3020826, "cl": 0.03969127, "clf": -0.07735755, "clr": 0.1170488, "cs": 0.05155281},
+    155: {"cd": 0.3060, "cl": 0.0, "clf": -0.10, "clr": 0.10, "cs": 0.0615},
+    169: {"cd": 0.2716351, "cl": 0.04776571, "clf": -0.04607980, "clr": 0.09384551, "cs": -0.01891372},
+    173: {"cd": 0.3081069, "cl": 0.1443453, "clf": -0.05736715, "clr": 0.2017125, "cs": 0.04728445},
+    186: {"cd": 0.3255898, "cl": 0.2150560, "clf": -0.006914063, "clr": 0.2219700, "cs": 0.01865817},
+    188: {"cd": 0.2579303, "cl": -0.02537855, "clf": -0.1916572, "clr": 0.1662786, "cs": 0.03303817},
+    189: {"cd": 0.2660501, "cl": -0.1086759, "clf": -0.1736286, "clr": 0.06495269, "cs": 0.01648422},
+    198: {"cd": 0.2471113, "cl": -0.08955271, "clf": -0.1951158, "clr": 0.1055631, "cs": 0.02245128},
+    203: {"cd": 0.2701408, "cl": -0.01267833, "clf": -0.1628925, "clr": 0.1502142, "cs": 0.04771488},
+    206: {"cd": 0.2983214, "cl": 0.05510763, "clf": -0.1246313, "clr": 0.1797390, "cs": 0.05055182},
+    220: {"cd": 0.2570, "cl": -0.1550, "clf": -0.19, "clr": 0.035, "cs": 0.012},
+    226: {"cd": 0.3207, "cl": 0.10, "clf": -0.07, "clr": 0.17, "cs": 0.0419},
+    277: {"cd": 0.3160, "cl": 0.193, "clf": -0.02, "clr": 0.213, "cs": 0.03},
+    279: {"cd": 0.259, "cl": -0.1397, "clf": -0.18, "clr": 0.040, "cs": 0.010},
+    284: {"cd": 0.246, "cl": -0.01, "clf": -0.12, "clr": 0.11, "cs": -0.0116},
+    289: {"cd": 0.2370, "cl": -0.02, "clf": -0.10, "clr": 0.08, "cs": 0.006},
+    312: {"cd": 0.300, "cl": 0.164, "clf": -0.02, "clr": 0.184, "cs": 0.030},
+    345: {"cd": 0.2415, "cl": -0.04, "clf": -0.12, "clr": 0.08, "cs": 0.006},
+    348: {"cd": 0.254, "cl": -0.106, "clf": -0.15, "clr": 0.044, "cs": 0.014},
+    357: {"cd": 0.297, "cl": 0.13, "clf": -0.05, "clr": 0.18, "cs": 0.030},
+    390: {"cd": 0.295, "cl": 0.12, "clf": -0.08, "clr": 0.202, "cs": 0.030},
+    397: {"cd": 0.2695405, "cl": 0.1056814, "clf": -0.1354777, "clr": 0.2411591, "cs": 0.003870469},
+    408: {"cd": 0.3007019, "cl": 0.1478495, "clf": -0.02045710, "clr": 0.1683066, "cs": 0.03119674},
+    412: {"cd": 0.3162548, "cl": 0.1405880, "clf": 0.04718838, "clr": 0.09339964, "cs": 0.03298801},
+    420: {"cd": 0.3050411, "cl": 0.07897217, "clf": -0.04300103, "clr": 0.1219732, "cs": 0.05399387},
+    425: {"cd": 0.2782114, "cl": -0.07189488, "clf": -0.2099042, "clr": 0.1380093, "cs": 0.03919784},
+    430: {"cd": 0.2454173, "cl": -0.1010351, "clf": -0.1491748, "clr": 0.04813971, "cs": 0.009925116},
+    431: {"cd": 0.3062540, "cl": 0.1109604, "clf": -0.01984060, "clr": 0.1308010, "cs": 0.05153959},
+    439: {"cd": 0.3085837, "cl": 0.08725992, "clf": -0.09746954, "clr": 0.1847295, "cs": 0.05276817},
+    440: {"cd": 0.2599606, "cl": 0.03923681, "clf": 0.004652030, "clr": 0.03458478, "cs": -0.004849062},
+    454: {"cd": 0.299, "cl": 0.14, "clf": -0.107, "clr": 0.247, "cs": 0.035},
+    461: {"cd": 0.303, "cl": 0.09, "clf": -0.09, "clr": 0.18, "cs": 0.0560},
+    465: {"cd": 0.300, "cl": 0.158, "clf": -0.03, "clr": 0.188, "cs": 0.030},
+    469: {"cd": 0.305, "cl": 0.08, "clf": -0.08, "clr": 0.16, "cs": 0.0613},
+    489: {"cd": 0.250, "cl": -0.1477, "clf": -0.19, "clr": 0.042, "cs": 0.010},
+    491: {"cd": 0.293, "cl": 0.09, "clf": -0.08, "clr": 0.17, "cs": 0.047},
+    495: {"cd": 0.296, "cl": 0.13, "clf": -0.06, "clr": 0.19, "cs": 0.033},
+    497: {"cd": 0.2768288, "cl": 0.1924666, "clf": 0.02007490, "clr": 0.1723917, "cs": 0.03174894},
+}
+
+
+### ---- Helpers -----------------------------------------------------------
+
+
+def case_id(run_id: int) -> str:
+    """Construct a case ID matching the on-disk directory name."""
+    return f"run_{run_id}"
+
+
+def case_sort_key(cid: str) -> int:
+    """Sort key giving numerical run order."""
+    if not cid.startswith("run_"):
+        raise ValueError(f"Malformed case ID: {cid!r}")
+    return int(cid.split("_", 1)[1])
+
+
+def make_case_ids(run_ids: list[int]) -> list[str]:
+    return [case_id(i) for i in sorted(run_ids)]
+
+
+def run_id(cid: str) -> int:
+    return case_sort_key(cid)
+
+
+def _rng(salt: str) -> random.Random:
+    """Create a deterministic RNG independent of other splits."""
+    seed_bytes = hashlib.sha256(f"{SEED}:{salt}".encode()).digest()[:8]
+    return random.Random(int.from_bytes(seed_bytes, "big"))
+
+
+def _split_pool(pool: list[int], *, salt: str) -> tuple[list[int], list[int]]:
+    """Split a training-side pool into train/val with a 70/10/20-style ratio."""
+    shuffled = pool.copy()
+    _rng(salt).shuffle(shuffled)
+    n_val = round(len(pool) * VAL_FRACTION_OF_POOL)
+    val = sorted(shuffled[:n_val])
+    train = sorted(shuffled[n_val:])
+    return train, val
+
+
+def _unit_hash(run: int, salt: str) -> float:
+    seed = hashlib.sha256(f"{SEED}:{salt}:{run}".encode()).digest()[:8]
+    return int.from_bytes(seed, "big") / 2**64
+
+
+def _complete_noether_split() -> None:
+    groups = {
+        "train": FULL_TRAIN_IDS,
+        "val": FULL_VAL_IDS,
+        "test": FULL_TEST_IDS,
+        "hidden_test": HIDDEN_TEST_IDS,
+    }
+    seen: dict[int, str] = {}
+    for name, values in groups.items():
+        if len(values) != len(set(values)):
+            raise AssertionError(f"{name} contains duplicate run IDs")
+        for value in values:
+            if value < 1 or value > N_CASES:
+                raise AssertionError(f"{name} has invalid run ID {value}")
+            previous = seen.get(value)
+            if previous is not None:
+                raise AssertionError(f"run {value} appears in {previous} and {name}")
+            seen[value] = name
+    if set(seen) != set(range(1, N_CASES + 1)):
+        missing = sorted(set(range(1, N_CASES + 1)) - set(seen))
+        raise AssertionError(f"missing run IDs: {missing}")
+    if (len(FULL_TRAIN_IDS), len(FULL_VAL_IDS), len(FULL_TEST_IDS), len(HIDDEN_TEST_IDS)) != (400, 34, 50, 16):
+        raise AssertionError("unexpected full split sizes")
+
+
+### ---- Force/moment and geometry-parameter analysis ----------------------
+
+
+def data_candidate_paths(filename: str) -> list[Path]:
+    roots = [
+        DATA_ROOT,
+        DATA_ROOT / "dataset",
+        DATA_ROOT / "drivaer_data",
+        DATA_DIR,
+        DATA_DIR / "dataset",
+        PACKAGE_ROOT,
+        PACKAGE_ROOT / "dataset",
+        Path.cwd(),
+        Path.cwd() / "data",
+    ]
+    # Preserve order while removing duplicates.
+    seen = set()
+    paths = []
+    for path in [root / filename for root in roots]:
+        key = path.resolve() if path.exists() else path.absolute()
+        if key not in seen:
+            paths.append(path)
+            seen.add(key)
+    return paths
+
+
+def force_candidate_paths() -> list[Path]:
+    return data_candidate_paths("force_mom_all.csv")
+
+
+def geo_candidate_paths() -> list[Path]:
+    return data_candidate_paths("geo_parameters_all.csv")
+
+
+def chamfer_candidate_paths() -> list[Path]:
+    return data_candidate_paths("chamfer_metrics.csv")
+
+
+def image_candidate_roots() -> list[Path]:
+    roots = []
+    if os.environ.get("DRIVAERML_IMAGE_ROOT"):
+        roots.append(Path(os.environ["DRIVAERML_IMAGE_ROOT"]))
+    roots.extend(
+        [
+            DATA_ROOT,
+            DATA_ROOT / "dataset",
+            DATA_ROOT / "drivaer_data",
+            DATA_DIR,
+            DATA_DIR / "dataset",
+            PACKAGE_ROOT,
+            Path.cwd(),
+            Path.cwd() / "data",
+        ]
+    )
+    seen = set()
+    result = []
+    for root in roots:
+        key = root.resolve() if root.exists() else root.absolute()
+        if key not in seen:
+            result.append(root)
+            seen.add(key)
+    return result
+
+
+def _float_from_row(row: dict[str, str], name: str) -> float:
+    for key in [name, name.lower(), name.upper(), name.capitalize()]:
+        if key in row:
+            return float(row[key].replace(" ", ""))
+    raise KeyError(name)
+
+
+def _force_rows(path: Path) -> list[dict[str, str]]:
+    with path.open(encoding="utf-8-sig", newline="") as f:
+        rows = list(csv.reader(f))
+    if not rows:
+        return []
+
+    first = [value.strip() for value in rows[0]]
+    if first and first[0].lower() == "run":
+        return [
+            dict(zip(first, [value.strip() for value in values]))
+            for values in rows[1:]
+            if len(values) >= len(first)
+        ]
+
+    # Older local exports used the same column order without a header.
+    fieldnames = ["run", "cd", "cl", "clf", "clr", "cs"]
+    return [
+        dict(zip(fieldnames, [value.strip() for value in values]))
+        for values in rows
+        if len(values) >= len(fieldnames)
+    ]
+
+
+def load_force_mom() -> tuple[dict[int, dict[str, float]], str]:
+    """Load force_mom_all.csv if present, otherwise return deterministic proxy."""
+    for path in force_candidate_paths():
+        if not path.exists():
+            continue
+        records: dict[int, dict[str, float]] = {}
+        for row in _force_rows(path):
+            rid = int(row["run"])
+            if rid not in PUBLIC_RUN_IDS:
+                continue
+            records[rid] = {
+                "cd": _float_from_row(row, "cd"),
+                "cl": _float_from_row(row, "cl"),
+                "clf": _float_from_row(row, "clf"),
+                "clr": _float_from_row(row, "clr"),
+                "cs": _float_from_row(row, "cs"),
+            }
+        missing = sorted(set(PUBLIC_RUN_IDS) - set(records))
+        if missing:
+            raise ValueError(f"{path} is missing public run IDs: {missing[:10]}")
+        return records, str(path)
+
+    records = {}
+    for rid in PUBLIC_RUN_IDS:
+        # Smooth deterministic proxy spanning the public coefficient ranges.
+        cd = 0.275 + 0.035 * (2 * _unit_hash(rid, "cd") - 1)
+        cl = 0.020 + 0.145 * (2 * _unit_hash(rid, "cl") - 1)
+        cs = 0.020 + 0.040 * (2 * _unit_hash(rid, "cs") - 1)
+        balance = 0.110 + 0.090 * (2 * _unit_hash(rid, "balance") - 1)
+        records[rid] = {
+            "cd": cd,
+            "cl": cl,
+            "clf": (cl - balance) / 2,
+            "clr": (cl + balance) / 2,
+            "cs": cs,
+        }
+    records.update({rid: value for rid, value in FORCE_ANCHORS.items() if rid in PUBLIC_RUN_IDS})
+    return records, "deterministic_proxy_missing_force_mom_all_csv"
+
+
+def load_geo_parameters() -> tuple[dict[int, dict[str, float]], str]:
+    """Load geo_parameters_all.csv if present, otherwise return deterministic proxy."""
+    for path in geo_candidate_paths():
+        if not path.exists():
+            continue
+        records: dict[int, dict[str, float]] = {}
+        with path.open(encoding="utf-8-sig", newline="") as f:
+            for row in csv.DictReader(f):
+                clean = {key.strip(): value.strip() for key, value in row.items()}
+                rid = int(clean["Run"])
+                if rid not in PUBLIC_RUN_IDS:
+                    continue
+                records[rid] = {
+                    key: float(value.replace(" ", ""))
+                    for key, value in clean.items()
+                    if key != "Run"
+                }
+        missing = sorted(set(PUBLIC_RUN_IDS) - set(records))
+        if missing:
+            raise ValueError(f"{path} is missing public run IDs: {missing[:10]}")
+        return records, str(path)
+
+    records = {}
+    names = [
+        "Vehicle_Length",
+        "Vehicle_Width",
+        "Vehicle_Height",
+        "Front_Overhang",
+        "Front_Planview",
+        "Hood_Angle",
+        "Approach_Angle",
+        "Windscreen_Angle",
+        "Greenhouse_Tapering",
+        "Backlight_Angle",
+        "Decklid_Height",
+        "Rearend_tapering",
+        "Rear_Overhang",
+        "Rear_Diffusor_Angle",
+        "Vehicle_Ride_Height",
+        "Vehicle_Pitch",
+    ]
+    for rid in PUBLIC_RUN_IDS:
+        records[rid] = {
+            name: 2.0 * _unit_hash(rid, f"geo:{name}") - 1.0
+            for name in names
+        }
+    return records, "deterministic_proxy_missing_geo_parameters_all_csv"
+
+
+def _run_id_from_csv_value(value: str) -> int:
+    value = value.strip()
+    if value.startswith("run_"):
+        return run_id(value)
+    return int(value)
+
+
+def load_chamfer_scores() -> tuple[dict[int, float], str]:
+    """Load STL-surface Chamfer geometry-isolation scores when available."""
+    for path in chamfer_candidate_paths():
+        if not path.exists():
+            continue
+        with path.open(encoding="utf-8-sig", newline="") as f:
+            rows = list(csv.DictReader(f))
+        if not rows:
+            raise ValueError(f"{path} has no rows")
+
+        field_lookup = {field.lower(): field for field in rows[0].keys() if field is not None}
+        run_field = field_lookup.get("run")
+        if run_field is None:
+            raise ValueError(f"{path} is missing a run column")
+        score_field = next(
+            (field_lookup[name.lower()] for name in CHAMFER_SCORE_COLUMNS if name.lower() in field_lookup),
+            None,
+        )
+        if score_field is None:
+            raise ValueError(
+                f"{path} is missing one of the expected Chamfer score columns: {CHAMFER_SCORE_COLUMNS}"
+            )
+
+        records: dict[int, float] = {}
+        for row in rows:
+            rid = _run_id_from_csv_value(row[run_field])
+            if rid not in PUBLIC_RUN_IDS:
+                continue
+            records[rid] = float(row[score_field])
+
+        missing = sorted(set(PUBLIC_RUN_IDS) - set(records))
+        if missing:
+            raise ValueError(f"{path} is missing public run IDs: {missing[:10]}")
+        return records, f"{path} ({score_field})"
+
+    return {}, "chamfer_metrics_csv_not_found"
+
+
+def _mean(values: list[float]) -> float:
+    return sum(values) / len(values)
+
+
+def _std(values: list[float]) -> float:
+    mean = _mean(values)
+    return math.sqrt(sum((x - mean) ** 2 for x in values) / len(values))
+
+
+def _zscore_map(values: dict[int, float]) -> dict[int, float]:
+    vals = list(values.values())
+    mean = _mean(vals)
+    std = _std(vals) or 1.0
+    return {rid: (value - mean) / std for rid, value in values.items()}
+
+
+def _feature_vectors(
+    records: dict[int, dict[str, float]], geo_records: dict[int, dict[str, float]]
+) -> dict[int, list[float]]:
+    """Standardized force/geometry vectors used for image-score imputation."""
+    raw_features: dict[str, dict[int, float]] = {
+        "cd": {rid: row["cd"] for rid, row in records.items()},
+        "cl": {rid: row["cl"] for rid, row in records.items()},
+        "cs": {rid: row["cs"] for rid, row in records.items()},
+        "front_rear_balance": {rid: row["clr"] - row["clf"] for rid, row in records.items()},
+    }
+    for column in sorted(next(iter(geo_records.values())).keys()):
+        raw_features[f"geo:{column}"] = {rid: params[column] for rid, params in geo_records.items()}
+
+    z_features = [_zscore_map(values) for values in raw_features.values()]
+    return {rid: [feature[rid] for feature in z_features] for rid in PUBLIC_RUN_IDS}
+
+
+def _impute_scores(
+    observed: dict[int, float],
+    records: dict[int, dict[str, float]],
+    geo_records: dict[int, dict[str, float]],
+    *,
+    k: int = 8,
+) -> dict[int, float]:
+    """Fill missing image scores by KNN in standardized force/geometry space."""
+    if len(observed) < 10:
+        return {}
+    features = _feature_vectors(records, geo_records)
+    observed_ids = sorted(observed)
+    result = dict(observed)
+    for rid in PUBLIC_RUN_IDS:
+        if rid in result:
+            continue
+        vector = features[rid]
+        distances = []
+        for observed_id in observed_ids:
+            other = features[observed_id]
+            dist = math.sqrt(sum((a - b) ** 2 for a, b in zip(vector, other)))
+            distances.append((dist, observed_id))
+        nearest = sorted(distances)[:k]
+        weights = [1.0 / (dist + 1e-6) for dist, _ in nearest]
+        result[rid] = sum(
+            weight * observed[observed_id]
+            for weight, (_, observed_id) in zip(weights, nearest)
+        ) / sum(weights)
+    return result
+
+
+def geometry_extreme_scores(geo_records: dict[int, dict[str, float]]) -> dict[int, float]:
+    """Distance from the center of the public geometry-parameter design space."""
+    columns = sorted(next(iter(geo_records.values())).keys())
+    z_columns = []
+    for column in columns:
+        vals = {rid: params[column] for rid, params in geo_records.items()}
+        z_columns.append(_zscore_map(vals))
+    return {
+        rid: math.sqrt(sum(z_column[rid] ** 2 for z_column in z_columns) / len(z_columns))
+        for rid in geo_records
+    }
+
+
+def _run_image_dir(run: int) -> Path | None:
+    for root in image_candidate_roots():
+        image_dir = root / f"run_{run}" / "images"
+        if image_dir.exists():
+            return image_dir
+    return None
+
+
+def _png_array(path: Path) -> np.ndarray | None:
+    if not path.exists() or path.name.startswith("._"):
+        return None
+    try:
+        with path.open("rb") as f:
+            if f.read(8) != b"\x89PNG\r\n\x1a\n":
+                return None
+        from PIL import Image
+
+        with Image.open(path) as img:
+            img = img.convert("RGB")
+            width, height = img.size
+            crop = (
+                int(width * 0.10),
+                int(height * 0.06),
+                int(width * 0.98),
+                int(height * 0.84),
+            )
+            img = img.crop(crop).resize((192, 120))
+            return np.asarray(img, dtype=np.float32) / 255.0
+    except Exception:
+        return None
+
+
+def _velocity_png_array(path: Path, *, size: tuple[int, int] = (350, 200)) -> np.ndarray | None:
+    if not path.exists() or path.name.startswith("._"):
+        return None
+    try:
+        with path.open("rb") as f:
+            if f.read(8) != b"\x89PNG\r\n\x1a\n":
+                return None
+        from PIL import Image
+
+        with Image.open(path) as img:
+            img = img.convert("RGB").resize(size)
+            return np.asarray(img, dtype=np.float32) / 255.0
+    except Exception:
+        return None
+
+
+def _rgb_to_hsv(rgb: np.ndarray) -> np.ndarray:
+    maxc = rgb.max(axis=2)
+    minc = rgb.min(axis=2)
+    delta = maxc - minc
+    h = np.zeros_like(maxc)
+    nonzero = delta > 1e-6
+
+    r, g, b = rgb[..., 0], rgb[..., 1], rgb[..., 2]
+    red = nonzero & (maxc == r)
+    green = nonzero & (maxc == g)
+    blue = nonzero & (maxc == b)
+    h[red] = ((g[red] - b[red]) / delta[red]) % 6.0
+    h[green] = ((b[green] - r[green]) / delta[green]) + 2.0
+    h[blue] = ((r[blue] - g[blue]) / delta[blue]) + 4.0
+    h /= 6.0
+
+    s = np.zeros_like(maxc)
+    valid_value = maxc > 1e-6
+    s[valid_value] = delta[valid_value] / maxc[valid_value]
+    v = maxc
+    return np.stack([h, s, v], axis=2)
+
+
+def _low_speed_velocity_mask(rgb: np.ndarray) -> np.ndarray:
+    """Mask blue/cyan/green low-speed pixels from the fixed velocity colormap."""
+    hsv = _rgb_to_hsv(rgb)
+    h, s, v = hsv[..., 0], hsv[..., 1], hsv[..., 2]
+    return (s > 0.35) & (v > 0.18) & (h > 0.23) & (h < 0.75)
+
+
+def _centerline_velocity_path(run: int) -> Path | None:
+    image_dir = _run_image_dir(run)
+    if image_dir is None:
+        return None
+    prefix = f"fig_run{run}_SRS"
+    return image_dir / f"{prefix}_magUMeanNormTrim_yNormal-2_yNormal_p00000.png"
+
+
+def _xnormal_velocity_paths(run: int) -> list[Path]:
+    image_dir = _run_image_dir(run)
+    if image_dir is None:
+        return []
+    prefix = f"fig_run{run}_SRS"
+    return [
+        image_dir / f"{prefix}_magUMeanNormTrim_xNormal-2_xNormal_{position}.png"
+        for position in REAR_XNORMAL_POSITIONS
+    ]
+
+
+def _centerline_body_bbox(rgb: np.ndarray) -> tuple[int, int, int, int] | None:
+    height, _width, _ = rgb.shape
+    y0, y1 = int(0.16 * height), int(0.70 * height)
+    sub = rgb[y0:y1]
+    white = (sub[..., 0] > 0.90) & (sub[..., 1] > 0.90) & (sub[..., 2] > 0.90)
+    ys, xs = np.where(white)
+    if len(xs) < 100:
+        return None
+    return int(xs.min()), int(xs.max()), int(ys.min() + y0), int(ys.max() + y0)
+
+
+def _centerline_wake_area_score(run: int) -> float | None:
+    path = _centerline_velocity_path(run)
+    if path is None:
+        return None
+    rgb = _velocity_png_array(path)
+    if rgb is None:
+        return None
+
+    height, width, _ = rgb.shape
+    bbox = _centerline_body_bbox(rgb)
+    if bbox is None:
+        return None
+
+    _x0, rear_x, y0, y1 = bbox
+    body_height = max(1, y1 - y0)
+    top = max(int(0.13 * height), y0 - int(0.65 * body_height))
+    bottom = min(int(0.78 * height), y1 + int(0.55 * body_height))
+    left = min(width - 1, rear_x + 1)
+    right = int(0.98 * width)
+    if right <= left or bottom <= top:
+        return None
+
+    wake_region = rgb[top:bottom, left:right]
+    return float(_low_speed_velocity_mask(wake_region).mean())
+
+
+def _xnormal_wake_area_score(run: int) -> float | None:
+    scores = []
+    for path in _xnormal_velocity_paths(run):
+        rgb = _velocity_png_array(path)
+        if rgb is None:
+            continue
+        height, width, _ = rgb.shape
+        plane_region = rgb[int(0.08 * height):int(0.78 * height), int(0.10 * width):int(0.98 * width)]
+        scores.append(float(_low_speed_velocity_mask(plane_region).mean()))
+    if len(scores) < 3:
+        return None
+    return float(sum(scores) / len(scores))
+
+
+def _rear_separation_score(run: int) -> float | None:
+    centerline = _centerline_wake_area_score(run)
+    xnormal = _xnormal_wake_area_score(run)
+    if centerline is None or xnormal is None:
+        return None
+    return 0.6 * centerline + 0.4 * xnormal
+
+
+def _load_cached_image_regime_scores() -> tuple[dict[str, dict[int, float]], dict[str, set[int]], str]:
+    """Load packaged image scores when source PNGs are not locally available."""
+    path = DATA_DIR / "image_metrics.csv"
+    if not path.exists():
+        return {}, {name: set() for name in IMAGE_SPLIT_NAMES}, "no_cached_image_metrics_csv"
+
+    with path.open(encoding="utf-8", newline="") as f:
+        rows = list(csv.DictReader(f))
+    if not rows:
+        return {}, {name: set() for name in IMAGE_SPLIT_NAMES}, "empty_cached_image_metrics_csv"
+
+    scores: dict[str, dict[int, float]] = {}
+    observed_ids: dict[str, set[int]] = {name: set() for name in IMAGE_SPLIT_NAMES}
+    for name in IMAGE_SPLIT_NAMES:
+        score_field = f"{name}_score"
+        observed_field = f"{name}_observed"
+        if score_field not in rows[0] or observed_field not in rows[0]:
+            continue
+        values: dict[int, float] = {}
+        for row in rows:
+            rid = _run_id_from_csv_value(row["run"])
+            if rid not in PUBLIC_RUN_IDS:
+                continue
+            values[rid] = float(row[score_field])
+            if row[observed_field].strip().lower() == "true":
+                observed_ids[name].add(rid)
+        if set(values) == set(PUBLIC_RUN_IDS):
+            scores[name] = values
+
+    if not scores:
+        return {}, observed_ids, "cached_image_metrics_csv_missing_active_scores"
+    return scores, observed_ids, f"cached_image_metrics_csv({path})"
+
+
+def load_image_regime_scores(
+    records: dict[int, dict[str, float]], geo_records: dict[int, dict[str, float]]
+) -> tuple[dict[str, dict[int, float]], dict[str, set[int]], str]:
+    """Build image-inspired flow-regime scores, imputing missing PNG cases."""
+    observed: dict[str, dict[int, float]] = {name: {} for name in IMAGE_SPLIT_NAMES}
+
+    for rid in PUBLIC_RUN_IDS:
+        rear_score = _rear_separation_score(rid)
+        if rear_score is not None:
+            observed["rear_separation"][rid] = rear_score
+
+    scores: dict[str, dict[int, float]] = {}
+    observed_counts = {name: len(values) for name, values in observed.items()}
+    for name, values in observed.items():
+        imputed = _impute_scores(values, records, geo_records)
+        if imputed:
+            scores[name] = imputed
+
+    if not scores:
+        cached_scores, cached_observed_ids, cached_source = _load_cached_image_regime_scores()
+        if cached_scores:
+            return cached_scores, cached_observed_ids, cached_source
+        return {}, {name: set(values) for name, values in observed.items()}, "no_sufficient_real_png_images"
+    count_summary = ",".join(f"{name}:{observed_counts[name]}" for name in IMAGE_SPLIT_NAMES)
+    observed_ids = {name: set(values) for name, values in observed.items()}
+    return scores, observed_ids, f"observed_png_scores_with_force_geometry_knn_imputation({count_summary})"
+
+
+def build_force_scores(
+    records: dict[int, dict[str, float]],
+) -> dict[str, dict[int, float]]:
+    """Return force-response scores used by split generation."""
+    cd = {rid: row["cd"] for rid, row in records.items()}
+    return {
+        "high_drag": cd,
+        "low_drag": {rid: -value for rid, value in cd.items()},
+    }
+
+
+def ranked_ood_split(scores: dict[int, float], *, salt: str) -> tuple[list[int], list[int], list[int]]:
+    """Hold out the top-scoring 20 percent as OOD test; split the rest train/val."""
+    ranked = sorted(scores, key=lambda rid: (scores[rid], rid))
+    n_test = round(len(ranked) * OOD_TEST_FRACTION)
+    test = sorted(ranked[-n_test:])
+    pool = sorted(ranked[:-n_test])
+    train, val = _split_pool(pool, salt=salt)
+    return train, val, test
+
+
+def diverse_training_order(records: dict[int, dict[str, float]], geo_records: dict[int, dict[str, float]]) -> list[int]:
+    """Greedy max-min order in force/geometry space for nested scarce subsets."""
+    train_pool = FULL_TRAIN_IDS.copy()
+    features = []
+    for key in ["cd", "cl", "cs"]:
+        vals = [records[rid][key] for rid in train_pool]
+        mean, std = _mean(vals), _std(vals) or 1.0
+        features.append({rid: (records[rid][key] - mean) / std for rid in train_pool})
+    for key in sorted(next(iter(geo_records.values())).keys()):
+        vals = [geo_records[rid][key] for rid in train_pool]
+        mean, std = _mean(vals), _std(vals) or 1.0
+        features.append({rid: (geo_records[rid][key] - mean) / std for rid in train_pool})
+
+    def distance(a: int, b: int) -> float:
+        return math.sqrt(sum((feature[a] - feature[b]) ** 2 for feature in features))
+
+    shape = geometry_extreme_scores({rid: geo_records[rid] for rid in train_pool})
+    shape_z = _zscore_map(shape)
+    cd_z = _zscore_map({rid: records[rid]["cd"] for rid in train_pool})
+    cl_z = _zscore_map({rid: abs(records[rid]["cl"]) for rid in train_pool})
+    cs_z = _zscore_map({rid: abs(records[rid]["cs"]) for rid in train_pool})
+
+    # Seed with force and geometry anchors, then continue by max-min spread.
+    anchor_priority = sorted(
+        train_pool,
+        key=lambda rid: (
+            -(abs(cd_z[rid]) + abs(cl_z[rid]) + abs(cs_z[rid]) + 0.5 * shape_z[rid]),
+            rid,
+        ),
+    )
+    selected = []
+    for rid in anchor_priority[:8]:
+        if rid not in selected:
+            selected.append(rid)
+
+    remaining = [rid for rid in train_pool if rid not in set(selected)]
+    while remaining:
+        next_rid = max(
+            remaining,
+            key=lambda rid: (
+                min(distance(rid, chosen) for chosen in selected),
+                _unit_hash(rid, "scarce_tie_break"),
+            ),
+        )
+        selected.append(next_rid)
+        remaining.remove(next_rid)
+    return selected
+
+
+### ---- Split generation --------------------------------------------------
+
+
+def write_image_metrics(
+    image_split_scores: dict[str, dict[int, float]],
+    image_observed_ids: dict[str, set[int]],
+) -> None:
+    """Write image-derived scores used by image-inspired splits."""
+    if not image_split_scores:
+        return
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    output = DATA_DIR / "image_metrics.csv"
+    with output.open("w", encoding="utf-8", newline="") as f:
+        fieldnames = ["run"]
+        for name in IMAGE_SPLIT_NAMES:
+            if name in image_split_scores:
+                fieldnames.extend([f"{name}_score", f"{name}_observed"])
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        for rid in PUBLIC_RUN_IDS:
+            row: dict[str, int | float] = {"run": rid}
+            for name in IMAGE_SPLIT_NAMES:
+                if name not in image_split_scores:
+                    continue
+                row[f"{name}_score"] = image_split_scores[name][rid]
+                row[f"{name}_observed"] = str(rid in image_observed_ids.get(name, set())).lower()
+            writer.writerow(row)
+
+
+def generate_splits() -> tuple[dict[str, list[str]], str, str, str, str]:
+    """Generate split manifest and return data-source descriptions."""
+    _complete_noether_split()
+    records, force_source = load_force_mom()
+    geo_records, geo_source = load_geo_parameters()
+    chamfer_scores, chamfer_source = load_chamfer_scores()
+    image_split_scores, image_observed_ids, image_split_source = load_image_regime_scores(records, geo_records)
+    scores = build_force_scores(records)
+    splits: dict[str, list[str]] = {}
+
+    # 1. Full public seed-42 random split.
+    splits["full_train"] = make_case_ids(FULL_TRAIN_IDS)
+    splits["full_val"] = make_case_ids(FULL_VAL_IDS)
+    splits["full_test"] = make_case_ids(FULL_TEST_IDS)
+
+    # 2-4. Data-efficiency splits. Same val/test as full; train is a nested
+    # force/geometry-diverse prefix of full_train.
+    order = diverse_training_order(records, geo_records)
+    n_medium = round(len(FULL_TRAIN_IDS) * MEDIUM_FRACTION)
+    n_scarce = round(len(FULL_TRAIN_IDS) * SCARCE_FRACTION)
+    n_super_scarce = round(len(FULL_TRAIN_IDS) * SUPER_SCARCE_FRACTION)
+    splits["medium_train"] = make_case_ids(sorted(order[:n_medium]))
+    splits["medium_val"] = splits["full_val"]
+    splits["medium_test"] = splits["full_test"]
+    splits["scarce_train"] = make_case_ids(sorted(order[:n_scarce]))
+    splits["scarce_val"] = splits["full_val"]
+    splits["scarce_test"] = splits["full_test"]
+    splits["super_scarce_train"] = make_case_ids(sorted(order[:n_super_scarce]))
+    splits["super_scarce_val"] = splits["full_val"]
+    splits["super_scarce_test"] = splits["full_test"]
+
+    # 5-6. Force-response OOD splits. Val is sampled from the
+    # training-side pool.
+    for name in ["high_drag", "low_drag"]:
+        salt = "drag_val_selection" if name == "high_drag" else f"{name}_val_selection"
+        train, val, test = ranked_ood_split(scores[name], salt=salt)
+        splits[f"{name}_train"] = make_case_ids(train)
+        splits[f"{name}_val"] = make_case_ids(val)
+        splits[f"{name}_test"] = make_case_ids(test)
+
+    # 7. STL-surface Chamfer OOD split. This uses direct surface-distance
+    # isolation scores from chamfer_metrics.csv.
+    if chamfer_scores:
+        train, val, test = ranked_ood_split(chamfer_scores, salt=f"{CHAMFER_SPLIT_NAME}_val_selection")
+        splits[f"{CHAMFER_SPLIT_NAME}_train"] = make_case_ids(train)
+        splits[f"{CHAMFER_SPLIT_NAME}_val"] = make_case_ids(val)
+        splits[f"{CHAMFER_SPLIT_NAME}_test"] = make_case_ids(test)
+
+    # 8. Image-inspired physics OOD split. Observed PNG-derived scores are
+    # used where available; missing runs are imputed from force/geometry
+    # neighbors so the split still covers all public cases.
+    for name in IMAGE_SPLIT_NAMES:
+        if name not in image_split_scores:
+            continue
+        train, val, test = ranked_ood_split(image_split_scores[name], salt=f"{name}_val_selection")
+        splits[f"{name}_train"] = make_case_ids(train)
+        splits[f"{name}_val"] = make_case_ids(val)
+        splits[f"{name}_test"] = make_case_ids(test)
+
+    write_image_metrics(image_split_scores, image_observed_ids)
+
+    return splits, force_source, geo_source, chamfer_source, image_split_source
+
+
+### ---- Validation --------------------------------------------------------
+
+
+def validate_splits(splits: dict[str, list[str]]) -> None:
+    """Verify structural correctness of all generated splits."""
+    split_names = sorted({k.rsplit("_", 1)[0] for k in splits})
+    public_cases = {case_id(i) for i in PUBLIC_RUN_IDS}
+    hidden_cases = {case_id(i) for i in HIDDEN_TEST_IDS}
+
+    for name in split_names:
+        train_set = set(splits[f"{name}_train"])
+        val_set = set(splits[f"{name}_val"])
+        test_set = set(splits[f"{name}_test"])
+
+        assert not (train_set & val_set), f"{name}: train/val overlap"
+        assert not (train_set & test_set), f"{name}: train/test overlap"
+        assert not (val_set & test_set), f"{name}: val/test overlap"
+        assert not ((train_set | val_set | test_set) & hidden_cases), f"{name}: hidden run included"
+        assert train_set | val_set | test_set <= public_cases, f"{name}: non-public run included"
+
+    assert (len(splits["full_train"]), len(splits["full_val"]), len(splits["full_test"])) == (400, 34, 50)
+
+    assert set(splits["super_scarce_train"]) < set(splits["scarce_train"]), (
+        "super_scarce_train must be a proper subset of scarce_train"
+    )
+    assert set(splits["scarce_train"]) < set(splits["medium_train"]), (
+        "scarce_train must be a proper subset of medium_train"
+    )
+    assert set(splits["medium_train"]) < set(splits["full_train"]), (
+        "medium_train must be a proper subset of full_train"
+    )
+    for prefix in ["medium", "scarce", "super_scarce"]:
+        assert splits[f"{prefix}_val"] == splits["full_val"], f"{prefix}_val must equal full_val"
+        assert splits[f"{prefix}_test"] == splits["full_test"], f"{prefix}_test must equal full_test"
+
+    partition_prefixes = [
+        "full",
+        *([CHAMFER_SPLIT_NAME] if f"{CHAMFER_SPLIT_NAME}_train" in splits else []),
+        "high_drag",
+        "low_drag",
+        *[name for name in IMAGE_SPLIT_NAMES if f"{name}_train" in splits],
+    ]
+    for prefix in partition_prefixes:
+        total = (
+            len(splits[f"{prefix}_train"])
+            + len(splits[f"{prefix}_val"])
+            + len(splits[f"{prefix}_test"])
+        )
+        assert total == N_PUBLIC, f"{prefix}: expected {N_PUBLIC} public cases, got {total}"
+
+    for prefix in [
+        *([CHAMFER_SPLIT_NAME] if f"{CHAMFER_SPLIT_NAME}_train" in splits else []),
+        "high_drag",
+        "low_drag",
+        *[name for name in IMAGE_SPLIT_NAMES if f"{name}_train" in splits],
+    ]:
+        assert (
+            len(splits[f"{prefix}_train"]),
+            len(splits[f"{prefix}_val"]),
+            len(splits[f"{prefix}_test"]),
+        ) == (339, 48, 97), f"{prefix}: unexpected OOD split sizes"
+
+
+### ---- Main --------------------------------------------------------------
+
+
+def main() -> None:
+    splits, force_source, geo_source, chamfer_source, image_source = generate_splits()
+    validate_splits(splits)
+
+    print("DrivAerML Splits")
+    print("=" * 60)
+    print(f"  Public runs: {N_PUBLIC}; hidden/unavailable runs: {len(HIDDEN_TEST_IDS)}")
+    print(f"  Seed: {SEED}")
+    print(f"  Force/moment source: {force_source}")
+    print(f"  Geometry-parameter source: {geo_source}")
+    print(f"  Chamfer source: {chamfer_source}")
+    print(f"  Flow-image source: {image_source}")
+    if force_source == "deterministic_proxy_missing_force_mom_all_csv":
+        print("  WARNING: force_mom_all.csv not found; force-regime splits used proxy scores.")
+    if geo_source == "deterministic_proxy_missing_geo_parameters_all_csv":
+        print("  WARNING: geo_parameters_all.csv not found; data-efficiency subsets used proxy parameters.")
+    if chamfer_source == "chamfer_metrics_csv_not_found":
+        print("  WARNING: chamfer_metrics.csv not found; geometry split was not generated.")
+    print()
+
+    split_names = sorted({k.rsplit("_", 1)[0] for k in splits})
+    print(f"  {'Split':<24s} {'Train':>6s} {'Val':>6s} {'Test':>6s} {'Total':>6s}")
+    print(f"  {'-' * 52}")
+    for name in split_names:
+        n_train = len(splits[f"{name}_train"])
+        n_val = len(splits[f"{name}_val"])
+        n_test = len(splits[f"{name}_test"])
+        print(f"  {name:<24s} {n_train:>6d} {n_val:>6d} {n_test:>6d} {n_train + n_val + n_test:>6d}")
+    print()
+
+    SPLITS_DIR.mkdir(parents=True, exist_ok=True)
+    output = SPLITS_DIR / "manifest.json"
+    output.write_text(json.dumps(splits, indent=4) + "\n", encoding="utf-8")
+    print(f"  Manifest: {output}")
+    print(f"  Keys: {len(splits)}")
+    print("All validations passed.")
+
+
+if __name__ == "__main__":
+    main()

splits/image_metrics.csv

@@ -0,0 +1,485 @@
+run,rear_separation_score,rear_separation_observed
+1,0.25272547842260684,true
+2,0.3164777364020835,true
+3,0.2929632797629087,true
+4,0.2068489048234909,true
+5,0.30840304831174864,true
+6,0.2910688710488444,true
+7,0.27885181609090004,true
+8,0.2719102569257368,true
+9,0.24240163153123787,true
+10,0.32959813206826877,true
+11,0.2360446719449199,true
+12,0.27281712326872964,true
+13,0.25442794730381324,true
+14,0.26748255411520716,true
+15,0.2891937554950017,true
+16,0.2833009745356684,true
+17,0.3083976791831533,true
+18,0.25741765330965494,true
+19,0.22635623368706076,true
+20,0.2658125648925125,true
+21,0.23843755040441056,true
+22,0.2753801481753036,true
+23,0.27976019833866417,true
+24,0.2728312376399111,true
+25,0.31244927130371875,true
+26,0.2512199320801266,true
+27,0.20987453422927613,true
+28,0.3015376344673631,true
+29,0.20158218507110626,true
+30,0.3063167949448006,true
+31,0.27296056829175497,true
+32,0.2824560274723106,true
+33,0.2785487790081147,true
+34,0.27790004950767366,true
+35,0.2967770190159291,true
+36,0.21882717372663352,true
+37,0.27637170573085124,true
+38,0.3325832368882041,true
+39,0.18598323613546475,true
+40,0.2529709113082462,true
+41,0.32255810490371495,true
+42,0.2382424914750675,true
+43,0.3146383119208039,true
+44,0.2711310431334678,true
+45,0.2954208776723287,true
+46,0.27728776653041776,true
+47,0.18216380708127405,true
+48,0.32583096635398084,true
+49,0.22369883178046443,true
+50,0.3250633288130904,true
+51,0.25490582318022204,true
+52,0.3302656622714021,true
+53,0.1876576097555991,true
+54,0.3162129787456505,true
+55,0.2621241826017942,true
+56,0.19197713644369066,true
+57,0.29827443666612363,true
+58,0.2331692344066614,true
+59,0.2839324497820098,true
+60,0.3277052973079895,true
+61,0.26567501253065257,true
+62,0.2758180934711547,true
+63,0.2872665435556304,true
+64,0.24561452613390372,true
+65,0.31811956742041825,true
+66,0.2989784147674965,true
+67,0.26721485329444405,true
+68,0.2851482876993081,true
+69,0.18776349500839296,true
+70,0.29114459668299447,true
+71,0.2736691819584977,true
+72,0.3168150541865845,true
+73,0.2819313221586729,true
+74,0.25252106312055295,true
+75,0.2738008547574874,true
+76,0.30070647672645173,true
+77,0.20895623819697637,true
+78,0.26534135791047614,true
+79,0.2783892683677861,true
+80,0.32904718053878995,true
+81,0.29640875109724574,true
+82,0.2008195567610277,true
+83,0.26786577526993316,true
+84,0.28101399442641767,true
+85,0.2919381937363184,true
+86,0.27144457945615164,true
+87,0.305206712365945,true
+88,0.24430161675059636,true
+89,0.3147487719912554,true
+90,0.20736603953513477,true
+91,0.2589118034015993,true
+92,0.2327747393158112,true
+93,0.2764297374457098,true
+94,0.28883183143387225,true
+95,0.2868886542525653,true
+96,0.25680151481171887,true
+97,0.22601744103669402,true
+98,0.29055438617257523,true
+99,0.2801335592151919,true
+100,0.15938819683717642,true
+101,0.2504536067407203,true
+102,0.34139525425239714,true
+103,0.30854924751408286,true
+104,0.23631797368472623,true
+105,0.32438814486833695,true
+106,0.2812988116609541,true
+107,0.2345332375803178,true
+108,0.2333461436522661,true
+109,0.21706224048060785,true
+110,0.31006896232067394,true
+111,0.25582745257097694,true
+112,0.24922607597042,true
+113,0.25361083790568184,true
+114,0.29245351941804354,true
+115,0.20012389710260164,true
+116,0.3229414921812881,true
+117,0.25858031050368363,true
+118,0.28608328240981307,true
+119,0.2477996900330362,true
+120,0.3159775686127464,true
+121,0.3363049305906449,true
+122,0.19120487675589717,true
+123,0.24672419654715788,true
+124,0.3113959509877877,true
+125,0.3463684175101195,true
+126,0.21954243224753262,true
+127,0.22328047267995724,true
+128,0.2872562977824299,true
+129,0.27967028282976536,true
+130,0.2667865297967339,true
+131,0.31803771251210605,true
+132,0.2348347257470907,true
+133,0.27521702787008906,true
+134,0.2581397625806312,true
+135,0.2342952135457102,true
+136,0.29314520841373687,true
+137,0.2448915389090615,true
+138,0.28847272530946,true
+139,0.31232960279516403,true
+140,0.2944654900921408,true
+141,0.29493870615365947,true
+142,0.21147906515253456,true
+143,0.22252903670196905,true
+144,0.3222474068532169,true
+145,0.21311602854517214,true
+146,0.2719803507370379,true
+147,0.28201232441028357,true
+148,0.3127756904797721,true
+149,0.24755655734799203,true
+150,0.28305459020603024,true
+151,0.28375907150127566,true
+152,0.20613566170717623,true
+153,0.2849727156307359,true
+154,0.29302556130917345,true
+155,0.20721408997293664,true
+156,0.2194870060122477,true
+157,0.24730543631459134,true
+158,0.3208941196696299,true
+159,0.2978190119468518,true
+160,0.26780646611420506,true
+161,0.3012387676591294,true
+162,0.2835473423614305,true
+163,0.21591937260898325,true
+164,0.2522821598795625,true
+165,0.24053263762113658,true
+166,0.3302768820403058,true
+168,0.258826060841288,true
+169,0.28262328713680207,true
+170,0.2643590256489756,true
+171,0.23039841447701623,true
+172,0.2772188103547245,true
+173,0.19362303747947662,true
+174,0.2842727019530414,true
+175,0.2204105134117139,true
+176,0.2971872704832712,true
+177,0.23135830368610982,true
+178,0.330385991464191,true
+179,0.26995178138287385,true
+180,0.3089506029684601,true
+181,0.22593668657944838,true
+182,0.25524333114211795,true
+183,0.29835961036608605,true
+184,0.2973428934116367,true
+185,0.3192274078073603,true
+186,0.16530684330311868,true
+187,0.3194990723562152,true
+188,0.25372726613122776,true
+189,0.3283730059240263,true
+190,0.18626311707944362,true
+191,0.2836886842649148,true
+192,0.2845131495381784,true
+193,0.26556372199229344,true
+194,0.31728949888002295,true
+195,0.2329617732950442,true
+196,0.21179765363631364,true
+197,0.26015926452859905,true
+198,0.29649520859219414,true
+199,0.29066116718679635,true
+200,0.2624773102385272,true
+201,0.2872509846599207,true
+202,0.2783382877316281,true
+203,0.2763546176046176,true
+204,0.23904432302391485,true
+205,0.2684076761627782,true
+206,0.2337897483946913,true
+207,0.25662294788045087,true
+208,0.29912638909526024,true
+209,0.2763634871487578,true
+210,0.25893077359413424,true
+212,0.3224908274296029,true
+213,0.33276578201144286,true
+214,0.26924920603942387,true
+215,0.2583692424508751,true
+216,0.23791141470954547,true
+217,0.31916859867337305,true
+219,0.27828892527014254,true
+220,0.3149133159757409,true
+222,0.26774921232476534,true
+223,0.24933975719882162,true
+224,0.2943874561195283,true
+225,0.283086601554082,true
+226,0.2591159151407598,true
+227,0.28823153966106474,true
+228,0.23694271479869214,true
+229,0.28747652716047334,true
+230,0.25296391057436335,true
+231,0.3250661715621619,true
+232,0.2416102265081857,true
+233,0.29213391373535236,true
+234,0.24632366552641205,true
+235,0.28087214106421793,true
+236,0.23615256408255525,true
+237,0.3063317570523546,true
+238,0.28147158687975016,true
+239,0.16355641170054436,true
+240,0.32666325762718607,true
+241,0.18628768959188674,true
+242,0.3223949099019311,true
+243,0.24446357834112936,true
+244,0.34077638844927094,true
+245,0.21330209039979417,true
+246,0.31141945974599033,true
+247,0.23881826648408283,true
+249,0.26476321802852415,true
+250,0.24531710062118453,true
+251,0.2699072339362751,true
+252,0.29006800396166665,true
+253,0.3129969461638235,true
+254,0.2776493409230724,true
+255,0.24700515310642382,true
+256,0.2650833429621393,true
+257,0.24792772554607184,true
+258,0.258663875542834,true
+259,0.3048720400031016,true
+260,0.23261911456900344,true
+261,0.295841237176314,true
+262,0.2616714010591562,true
+263,0.28627686089420784,true
+264,0.25695600318049294,true
+265,0.2644875622050703,true
+266,0.2595505803399527,true
+267,0.30403186850397457,true
+268,0.24841446968397746,true
+269,0.25334369403015045,true
+270,0.2666028413303144,true
+271,0.2669131288879188,true
+272,0.29494792095073585,true
+273,0.23785451225137916,true
+274,0.292967159909786,true
+275,0.24210148128515477,true
+276,0.3438440895838855,true
+277,0.20441117455487132,true
+278,0.3234341636038949,true
+279,0.3103214422723878,true
+280,0.2866653203953876,true
+281,0.3218705918683451,true
+283,0.25781936099336744,true
+284,0.2933239919344361,true
+285,0.2555851916055998,true
+286,0.2693634060008273,true
+287,0.25645683786319484,true
+288,0.3392371512423922,true
+289,0.32594825625163,true
+290,0.27270679717108287,true
+292,0.22852835283528353,true
+293,0.3209217102074245,true
+294,0.28973410434692143,true
+296,0.2770357204335744,true
+297,0.3038510113724271,true
+298,0.28471448166208885,true
+299,0.21258780318393639,true
+300,0.2721871618648745,true
+301,0.2613788861572609,true
+302,0.32259049351678637,true
+303,0.2182762390670554,true
+304,0.3037630468350125,true
+305,0.21443390197443218,true
+306,0.28718893351546415,true
+307,0.24138144793920868,true
+308,0.2894846642406043,true
+309,0.27770783749308536,true
+310,0.2674251258945136,true
+311,0.3050396399161168,true
+312,0.2266235984903452,true
+313,0.2637132505538359,true
+314,0.25172845690164547,true
+315,0.2997067784511547,true
+317,0.2809173485704098,true
+318,0.2310581596133761,true
+319,0.2769990560075274,true
+320,0.2453970132611934,true
+321,0.2957208523909528,true
+322,0.26947136596896504,true
+323,0.2915229475433557,true
+324,0.27811426641396303,true
+326,0.26743596726910646,true
+327,0.2401933511499838,true
+328,0.245842971784887,true
+330,0.3020189078180125,true
+331,0.2829871688935314,true
+332,0.31295440595923946,true
+333,0.18194350552133115,true
+334,0.2936814165675802,true
+335,0.24555373775242853,true
+336,0.3127523856501467,true
+337,0.2588629679636534,true
+338,0.27935965172561106,true
+339,0.28258142718543394,true
+340,0.3057080193527842,true
+341,0.2938710439584825,true
+342,0.31735994011504215,true
+343,0.2347897194675328,true
+344,0.24321159632684242,true
+345,0.3436190783484484,true
+346,0.22367442163815765,true
+347,0.2710488694429748,true
+348,0.31175003313013516,true
+349,0.3237770359141711,true
+350,0.24352481861794323,true
+351,0.20230648047744698,true
+352,0.29126819276553084,true
+353,0.28980128714822595,true
+354,0.30743008062289257,true
+355,0.2814300929607052,true
+356,0.1973157188463311,true
+357,0.24157100389840294,true
+358,0.2687523873284967,true
+359,0.31376806866602786,true
+360,0.23908802733887013,true
+361,0.3346844430611515,true
+362,0.27148958373448173,true
+363,0.27608404279298804,true
+365,0.28986335794892243,true
+366,0.25592481585424554,true
+367,0.2789413813110445,true
+368,0.29875410303981736,true
+369,0.29797413502056824,true
+371,0.22834646029426597,true
+372,0.276064247390778,true
+373,0.26276797720160383,true
+374,0.27486602894586654,true
+375,0.23874380037035453,true
+377,0.24518864484742803,true
+378,0.2066664369145178,true
+379,0.2806135342870037,true
+380,0.2813594960008371,true
+381,0.23897827403175695,true
+382,0.3078574410283594,true
+383,0.2591183161167759,true
+384,0.2768514566407917,true
+385,0.28334845610747084,true
+386,0.2833029526185754,true
+387,0.2527567729519815,true
+388,0.25677114358666187,true
+389,0.30394153025994053,true
+390,0.2473759586582074,true
+391,0.24801754643591378,true
+392,0.29142248031791473,true
+393,0.31860242317350584,true
+394,0.2683951316192328,true
+395,0.2216697396662014,true
+396,0.31519436345966956,true
+397,0.18266561126649494,true
+398,0.2626783881668955,true
+399,0.25341310550194107,true
+400,0.32356690940453303,true
+401,0.2611320504678225,true
+402,0.31631754099362963,true
+404,0.33420666694565726,true
+405,0.26262004167837316,true
+406,0.3479030236173093,true
+407,0.3126205936920222,true
+408,0.17716229451791005,true
+409,0.3198399396613682,true
+410,0.2615071796408817,true
+411,0.23213097824046322,true
+412,0.24152024219093765,true
+413,0.3139413041453858,true
+414,0.21837116234410486,true
+415,0.2754582845329824,true
+416,0.27728662942756127,true
+417,0.2627933017992661,true
+418,0.290861893208832,true
+419,0.25880333951762524,true
+420,0.2321312497823808,true
+421,0.23447338463959547,true
+422,0.3314758104451417,true
+423,0.3045578173549362,true
+424,0.2861661540461504,true
+425,0.29038785996253097,true
+426,0.3035218835712089,true
+427,0.2562884309567983,true
+428,0.2855165262575053,true
+429,0.20378410132324737,true
+430,0.3075874702498079,true
+431,0.246038958162409,true
+432,0.26067129725495797,true
+433,0.2815551529198499,true
+434,0.26411633769712783,true
+435,0.2986675477491804,true
+436,0.2847040290317602,true
+437,0.290408789230171,true
+438,0.23888666645199164,true
+439,0.2340263286811897,true
+440,0.3039345858223409,true
+441,0.28135241546551865,true
+442,0.23513425630627738,true
+443,0.3151483570451158,true
+444,0.30472272518029764,true
+445,0.2876206673145449,true
+446,0.23191425921017755,true
+447,0.1675047841622322,true
+448,0.27342449642194544,true
+449,0.3176367658838936,true
+450,0.2832253147943186,true
+451,0.31729715801144376,true
+452,0.20762801824026314,true
+453,0.30314379815038145,true
+454,0.1855732497311746,true
+455,0.3108186684421915,true
+456,0.23887679694313013,true
+457,0.27857897974185997,true
+458,0.21685669947066094,true
+459,0.27981065511100167,true
+460,0.2710025026541352,true
+461,0.21222425200205097,true
+462,0.30674485795298273,true
+463,0.29772729037706724,true
+464,0.293869417897029,true
+465,0.22267126003211093,true
+466,0.30049297128234365,true
+467,0.207484909108532,true
+468,0.32380120081979047,true
+469,0.21554899674678424,true
+470,0.29121323854217007,true
+471,0.29747234697524905,true
+472,0.2543257806023763,true
+474,0.2498217599329021,true
+475,0.28046908970678475,true
+476,0.3265925859407331,true
+477,0.23047756992977186,true
+478,0.2857257359753147,true
+479,0.21157005401617263,true
+480,0.32564144951919344,true
+481,0.27296148296602996,true
+482,0.26020031160385415,true
+483,0.2957815300480485,true
+484,0.27905688950051977,true
+485,0.2526443148688047,true
+486,0.30575381087738324,true
+487,0.2665856974657995,true
+488,0.2631131368769647,true
+489,0.3444804713777305,true
+490,0.23117391572760637,true
+491,0.17720433969896915,true
+492,0.2862750727996827,true
+493,0.3278433367688154,true
+494,0.22778925367127462,true
+495,0.24133720139665127,true
+496,0.3143652172336712,true
+497,0.23586910374777814,true
+498,0.28974669897363503,true
+499,0.23330238755814492,true
+500,0.24310930559101523,true

splits/manifest.json

@@ -0,0 +1,2933 @@
+{
+    "full_train": [
+        "run_1",
+        "run_2",
+        "run_3",
+        "run_5",
+        "run_6",
+        "run_7",
+        "run_8",
+        "run_9",
+        "run_10",
+        "run_13",
+        "run_14",
+        "run_15",
+        "run_16",
+        "run_17",
+        "run_18",
+        "run_21",
+        "run_23",
+        "run_25",
+        "run_27",
+        "run_28",
+        "run_30",
+        "run_31",
+        "run_32",
+        "run_33",
+        "run_34",
+        "run_35",
+        "run_36",
+        "run_37",
+        "run_38",
+        "run_39",
+        "run_40",
+        "run_42",
+        "run_43",
+        "run_44",
+        "run_45",
+        "run_46",
+        "run_47",
+        "run_48",
+        "run_49",
+        "run_50",
+        "run_51",
+        "run_52",
+        "run_53",
+        "run_54",
+        "run_57",
+        "run_58",
+        "run_60",
+        "run_61",
+        "run_62",
+        "run_63",
+        "run_64",
+        "run_65",
+        "run_66",
+        "run_67",
+        "run_68",
+        "run_69",
+        "run_70",
+        "run_71",
+        "run_72",
+        "run_73",
+        "run_74",
+        "run_75",
+        "run_76",
+        "run_77",
+        "run_78",
+        "run_79",
+        "run_80",
+        "run_81",
+        "run_82",
+        "run_83",
+        "run_84",
+        "run_85",
+        "run_86",
+        "run_87",
+        "run_88",
+        "run_89",
+        "run_90",
+        "run_91",
+        "run_92",
+        "run_93",
+        "run_94",
+        "run_95",
+        "run_96",
+        "run_97",
+        "run_98",
+        "run_99",
+        "run_100",
+        "run_101",
+        "run_102",
+        "run_103",
+        "run_104",
+        "run_105",
+        "run_106",
+        "run_107",
+        "run_110",
+        "run_111",
+        "run_112",
+        "run_113",
+        "run_114",
+        "run_115",
+        "run_116",
+        "run_117",
+        "run_118",
+        "run_119",
+        "run_120",
+        "run_121",
+        "run_122",
+        "run_123",
+        "run_125",
+        "run_126",
+        "run_128",
+        "run_129",
+        "run_130",
+        "run_131",
+        "run_132",
+        "run_134",
+        "run_135",
+        "run_136",
+        "run_137",
+        "run_138",
+        "run_139",
+        "run_140",
+        "run_141",
+        "run_143",
+        "run_144",
+        "run_145",
+        "run_146",
+        "run_147",
+        "run_148",
+        "run_149",
+        "run_151",
+        "run_152",
+        "run_153",
+        "run_154",
+        "run_155",
+        "run_156",
+        "run_157",
+        "run_159",
+        "run_160",
+        "run_161",
+        "run_162",
+        "run_163",
+        "run_164",
+        "run_166",
+        "run_168",
+        "run_169",
+        "run_170",
+        "run_171",
+        "run_172",
+        "run_174",
+        "run_175",
+        "run_176",
+        "run_178",
+        "run_179",
+        "run_181",
+        "run_182",
+        "run_183",
+        "run_184",
+        "run_185",
+        "run_186",
+        "run_189",
+        "run_190",
+        "run_192",
+        "run_193",
+        "run_194",
+        "run_195",
+        "run_196",
+        "run_198",
+        "run_200",
+        "run_201",
+        "run_202",
+        "run_204",
+        "run_206",
+        "run_209",
+        "run_212",
+        "run_213",
+        "run_214",
+        "run_216",
+        "run_217",
+        "run_219",
+        "run_220",
+        "run_223",
+        "run_224",
+        "run_225",
+        "run_227",
+        "run_229",
+        "run_230",
+        "run_231",
+        "run_232",
+        "run_233",
+        "run_235",
+        "run_236",
+        "run_237",
+        "run_238",
+        "run_239",
+        "run_240",
+        "run_242",
+        "run_243",
+        "run_244",
+        "run_245",
+        "run_246",
+        "run_249",
+        "run_250",
+        "run_251",
+        "run_254",
+        "run_255",
+        "run_256",
+        "run_257",
+        "run_259",
+        "run_261",
+        "run_262",
+        "run_264",
+        "run_265",
+        "run_266",
+        "run_267",
+        "run_268",
+        "run_269",
+        "run_270",
+        "run_272",
+        "run_273",
+        "run_274",
+        "run_276",
+        "run_277",
+        "run_278",
+        "run_279",
+        "run_281",
+        "run_283",
+        "run_285",
+        "run_286",
+        "run_287",
+        "run_288",
+        "run_289",
+        "run_292",
+        "run_293",
+        "run_294",
+        "run_296",
+        "run_297",
+        "run_299",
+        "run_300",
+        "run_301",
+        "run_302",
+        "run_304",
+        "run_305",
+        "run_306",
+        "run_307",
+        "run_308",
+        "run_309",
+        "run_310",
+        "run_312",
+        "run_313",
+        "run_314",
+        "run_315",
+        "run_317",
+        "run_318",
+        "run_319",
+        "run_320",
+        "run_323",
+        "run_326",
+        "run_327",
+        "run_330",
+        "run_331",
+        "run_332",
+        "run_333",
+        "run_334",
+        "run_335",
+        "run_336",
+        "run_338",
+        "run_339",
+        "run_340",
+        "run_342",
+        "run_343",
+        "run_344",
+        "run_345",
+        "run_346",
+        "run_347",
+        "run_348",
+        "run_349",
+        "run_351",
+        "run_353",
+        "run_355",
+        "run_356",
+        "run_357",
+        "run_358",
+        "run_359",
+        "run_360",
+        "run_361",
+        "run_362",
+        "run_365",
+        "run_367",
+        "run_368",
+        "run_369",
+        "run_371",
+        "run_373",
+        "run_374",
+        "run_375",
+        "run_377",
+        "run_378",
+        "run_379",
+        "run_381",
+        "run_383",
+        "run_384",
+        "run_385",
+        "run_386",
+        "run_388",
+        "run_389",
+        "run_391",
+        "run_392",
+        "run_393",
+        "run_394",
+        "run_395",
+        "run_396",
+        "run_397",
+        "run_398",
+        "run_399",
+        "run_400",
+        "run_402",
+        "run_404",
+        "run_406",
+        "run_407",
+        "run_408",
+        "run_409",
+        "run_411",
+        "run_412",
+        "run_413",
+        "run_414",
+        "run_415",
+        "run_416",
+        "run_417",
+        "run_418",
+        "run_419",
+        "run_420",
+        "run_421",
+        "run_422",
+        "run_425",
+        "run_426",
+        "run_427",
+        "run_430",
+        "run_431",
+        "run_432",
+        "run_433",
+        "run_434",
+        "run_435",
+        "run_437",
+        "run_438",
+        "run_439",
+        "run_440",
+        "run_442",
+        "run_443",
+        "run_444",
+        "run_445",
+        "run_446",
+        "run_448",
+        "run_449",
+        "run_450",
+        "run_451",
+        "run_452",
+        "run_453",
+        "run_455",
+        "run_456",
+        "run_457",
+        "run_458",
+        "run_459",
+        "run_460",
+        "run_461",
+        "run_462",
+        "run_463",
+        "run_464",
+        "run_465",
+        "run_466",
+        "run_467",
+        "run_468",
+        "run_469",
+        "run_470",
+        "run_471",
+        "run_474",
+        "run_475",
+        "run_476",
+        "run_477",
+        "run_478",
+        "run_479",
+        "run_480",
+        "run_481",
+        "run_482",
+        "run_483",
+        "run_484",
+        "run_485",
+        "run_486",
+        "run_488",
+        "run_489",
+        "run_490",
+        "run_491",
+        "run_492",
+        "run_493",
+        "run_494",
+        "run_495",
+        "run_496",
+        "run_497",
+        "run_498",
+        "run_499",
+        "run_500"
+    ],
+    "full_val": [
+        "run_4",
+        "run_22",
+        "run_56",
+        "run_109",
+        "run_150",
+        "run_165",
+        "run_177",
+        "run_191",
+        "run_228",
+        "run_234",
+        "run_241",
+        "run_247",
+        "run_252",
+        "run_253",
+        "run_260",
+        "run_271",
+        "run_275",
+        "run_298",
+        "run_303",
+        "run_311",
+        "run_321",
+        "run_324",
+        "run_328",
+        "run_341",
+        "run_352",
+        "run_366",
+        "run_380",
+        "run_390",
+        "run_401",
+        "run_423",
+        "run_441",
+        "run_447",
+        "run_454",
+        "run_487"
+    ],
+    "full_test": [
+        "run_11",
+        "run_12",
+        "run_19",
+        "run_20",
+        "run_24",
+        "run_26",
+        "run_29",
+        "run_41",
+        "run_55",
+        "run_59",
+        "run_108",
+        "run_124",
+        "run_127",
+        "run_133",
+        "run_142",
+        "run_158",
+        "run_173",
+        "run_180",
+        "run_187",
+        "run_188",
+        "run_197",
+        "run_199",
+        "run_203",
+        "run_205",
+        "run_207",
+        "run_208",
+        "run_210",
+        "run_215",
+        "run_222",
+        "run_226",
+        "run_258",
+        "run_263",
+        "run_280",
+        "run_284",
+        "run_290",
+        "run_322",
+        "run_337",
+        "run_350",
+        "run_354",
+        "run_363",
+        "run_372",
+        "run_382",
+        "run_387",
+        "run_405",
+        "run_410",
+        "run_424",
+        "run_428",
+        "run_429",
+        "run_436",
+        "run_472"
+    ],
+    "medium_train": [
+        "run_3",
+        "run_5",
+        "run_6",
+        "run_10",
+        "run_14",
+        "run_16",
+        "run_28",
+        "run_36",
+        "run_38",
+        "run_39",
+        "run_42",
+        "run_43",
+        "run_45",
+        "run_49",
+        "run_53",
+        "run_58",
+        "run_62",
+        "run_73",
+        "run_75",
+        "run_80",
+        "run_84",
+        "run_85",
+        "run_88",
+        "run_94",
+        "run_95",
+        "run_97",
+        "run_98",
+        "run_100",
+        "run_102",
+        "run_112",
+        "run_115",
+        "run_120",
+        "run_138",
+        "run_146",
+        "run_149",
+        "run_152",
+        "run_160",
+        "run_161",
+        "run_162",
+        "run_163",
+        "run_166",
+        "run_169",
+        "run_171",
+        "run_172",
+        "run_175",
+        "run_178",
+        "run_183",
+        "run_184",
+        "run_186",
+        "run_189",
+        "run_195",
+        "run_198",
+        "run_209",
+        "run_213",
+        "run_217",
+        "run_220",
+        "run_230",
+        "run_231",
+        "run_233",
+        "run_237",
+        "run_239",
+        "run_243",
+        "run_246",
+        "run_250",
+        "run_251",
+        "run_255",
+        "run_256",
+        "run_262",
+        "run_265",
+        "run_269",
+        "run_272",
+        "run_276",
+        "run_277",
+        "run_281",
+        "run_285",
+        "run_287",
+        "run_293",
+        "run_296",
+        "run_301",
+        "run_304",
+        "run_306",
+        "run_307",
+        "run_317",
+        "run_331",
+        "run_336",
+        "run_340",
+        "run_343",
+        "run_347",
+        "run_349",
+        "run_356",
+        "run_357",
+        "run_362",
+        "run_368",
+        "run_369",
+        "run_386",
+        "run_391",
+        "run_397",
+        "run_399",
+        "run_408",
+        "run_412",
+        "run_415",
+        "run_420",
+        "run_421",
+        "run_425",
+        "run_427",
+        "run_430",
+        "run_432",
+        "run_433",
+        "run_439",
+        "run_440",
+        "run_445",
+        "run_446",
+        "run_450",
+        "run_451",
+        "run_452",
+        "run_453",
+        "run_455",
+        "run_456",
+        "run_457",
+        "run_461",
+        "run_465",
+        "run_469",
+        "run_470",
+        "run_476",
+        "run_477",
+        "run_479",
+        "run_481",
+        "run_484",
+        "run_485",
+        "run_486",
+        "run_492",
+        "run_496",
+        "run_497"
+    ],
+    "medium_val": [
+        "run_4",
+        "run_22",
+        "run_56",
+        "run_109",
+        "run_150",
+        "run_165",
+        "run_177",
+        "run_191",
+        "run_228",
+        "run_234",
+        "run_241",
+        "run_247",
+        "run_252",
+        "run_253",
+        "run_260",
+        "run_271",
+        "run_275",
+        "run_298",
+        "run_303",
+        "run_311",
+        "run_321",
+        "run_324",
+        "run_328",
+        "run_341",
+        "run_352",
+        "run_366",
+        "run_380",
+        "run_390",
+        "run_401",
+        "run_423",
+        "run_441",
+        "run_447",
+        "run_454",
+        "run_487"
+    ],
+    "medium_test": [
+        "run_11",
+        "run_12",
+        "run_19",
+        "run_20",
+        "run_24",
+        "run_26",
+        "run_29",
+        "run_41",
+        "run_55",
+        "run_59",
+        "run_108",
+        "run_124",
+        "run_127",
+        "run_133",
+        "run_142",
+        "run_158",
+        "run_173",
+        "run_180",
+        "run_187",
+        "run_188",
+        "run_197",
+        "run_199",
+        "run_203",
+        "run_205",
+        "run_207",
+        "run_208",
+        "run_210",
+        "run_215",
+        "run_222",
+        "run_226",
+        "run_258",
+        "run_263",
+        "run_280",
+        "run_284",
+        "run_290",
+        "run_322",
+        "run_337",
+        "run_350",
+        "run_354",
+        "run_363",
+        "run_372",
+        "run_382",
+        "run_387",
+        "run_405",
+        "run_410",
+        "run_424",
+        "run_428",
+        "run_429",
+        "run_436",
+        "run_472"
+    ],
+    "scarce_train": [
+        "run_3",
+        "run_10",
+        "run_16",
+        "run_38",
+        "run_39",
+        "run_43",
+        "run_45",
+        "run_49",
+        "run_53",
+        "run_62",
+        "run_73",
+        "run_75",
+        "run_80",
+        "run_85",
+        "run_94",
+        "run_98",
+        "run_102",
+        "run_112",
+        "run_115",
+        "run_161",
+        "run_169",
+        "run_172",
+        "run_186",
+        "run_209",
+        "run_213",
+        "run_220",
+        "run_230",
+        "run_231",
+        "run_233",
+        "run_237",
+        "run_256",
+        "run_262",
+        "run_269",
+        "run_272",
+        "run_276",
+        "run_277",
+        "run_301",
+        "run_306",
+        "run_307",
+        "run_317",
+        "run_343",
+        "run_347",
+        "run_356",
+        "run_357",
+        "run_362",
+        "run_369",
+        "run_391",
+        "run_397",
+        "run_399",
+        "run_412",
+        "run_425",
+        "run_427",
+        "run_432",
+        "run_439",
+        "run_445",
+        "run_452",
+        "run_455",
+        "run_457",
+        "run_461",
+        "run_465",
+        "run_469",
+        "run_476",
+        "run_477",
+        "run_484",
+        "run_486",
+        "run_492",
+        "run_497"
+    ],
+    "scarce_val": [
+        "run_4",
+        "run_22",
+        "run_56",
+        "run_109",
+        "run_150",
+        "run_165",
+        "run_177",
+        "run_191",
+        "run_228",
+        "run_234",
+        "run_241",
+        "run_247",
+        "run_252",
+        "run_253",
+        "run_260",
+        "run_271",
+        "run_275",
+        "run_298",
+        "run_303",
+        "run_311",
+        "run_321",
+        "run_324",
+        "run_328",
+        "run_341",
+        "run_352",
+        "run_366",
+        "run_380",
+        "run_390",
+        "run_401",
+        "run_423",
+        "run_441",
+        "run_447",
+        "run_454",
+        "run_487"
+    ],
+    "scarce_test": [
+        "run_11",
+        "run_12",
+        "run_19",
+        "run_20",
+        "run_24",
+        "run_26",
+        "run_29",
+        "run_41",
+        "run_55",
+        "run_59",
+        "run_108",
+        "run_124",
+        "run_127",
+        "run_133",
+        "run_142",
+        "run_158",
+        "run_173",
+        "run_180",
+        "run_187",
+        "run_188",
+        "run_197",
+        "run_199",
+        "run_203",
+        "run_205",
+        "run_207",
+        "run_208",
+        "run_210",
+        "run_215",
+        "run_222",
+        "run_226",
+        "run_258",
+        "run_263",
+        "run_280",
+        "run_284",
+        "run_290",
+        "run_322",
+        "run_337",
+        "run_350",
+        "run_354",
+        "run_363",
+        "run_372",
+        "run_382",
+        "run_387",
+        "run_405",
+        "run_410",
+        "run_424",
+        "run_428",
+        "run_429",
+        "run_436",
+        "run_472"
+    ],
+    "super_scarce_train": [
+        "run_39",
+        "run_49",
+        "run_85",
+        "run_115",
+        "run_186",
+        "run_220",
+        "run_277",
+        "run_357",
+        "run_412",
+        "run_455",
+        "run_477"
+    ],
+    "super_scarce_val": [
+        "run_4",
+        "run_22",
+        "run_56",
+        "run_109",
+        "run_150",
+        "run_165",
+        "run_177",
+        "run_191",
+        "run_228",
+        "run_234",
+        "run_241",
+        "run_247",
+        "run_252",
+        "run_253",
+        "run_260",
+        "run_271",
+        "run_275",
+        "run_298",
+        "run_303",
+        "run_311",
+        "run_321",
+        "run_324",
+        "run_328",
+        "run_341",
+        "run_352",
+        "run_366",
+        "run_380",
+        "run_390",
+        "run_401",
+        "run_423",
+        "run_441",
+        "run_447",
+        "run_454",
+        "run_487"
+    ],
+    "super_scarce_test": [
+        "run_11",
+        "run_12",
+        "run_19",
+        "run_20",
+        "run_24",
+        "run_26",
+        "run_29",
+        "run_41",
+        "run_55",
+        "run_59",
+        "run_108",
+        "run_124",
+        "run_127",
+        "run_133",
+        "run_142",
+        "run_158",
+        "run_173",
+        "run_180",
+        "run_187",
+        "run_188",
+        "run_197",
+        "run_199",
+        "run_203",
+        "run_205",
+        "run_207",
+        "run_208",
+        "run_210",
+        "run_215",
+        "run_222",
+        "run_226",
+        "run_258",
+        "run_263",
+        "run_280",
+        "run_284",
+        "run_290",
+        "run_322",
+        "run_337",
+        "run_350",
+        "run_354",
+        "run_363",
+        "run_372",
+        "run_382",
+        "run_387",
+        "run_405",
+        "run_410",
+        "run_424",
+        "run_428",
+        "run_429",
+        "run_436",
+        "run_472"
+    ],
+    "high_drag_train": [
+        "run_2",
+        "run_3",
+        "run_4",
+        "run_5",
+        "run_6",
+        "run_7",
+        "run_9",
+        "run_10",
+        "run_12",
+        "run_13",
+        "run_16",
+        "run_17",
+        "run_20",
+        "run_21",
+        "run_24",
+        "run_25",
+        "run_26",
+        "run_27",
+        "run_28",
+        "run_30",
+        "run_31",
+        "run_32",
+        "run_33",
+        "run_35",
+        "run_36",
+        "run_38",
+        "run_40",
+        "run_41",
+        "run_42",
+        "run_43",
+        "run_45",
+        "run_46",
+        "run_48",
+        "run_50",
+        "run_51",
+        "run_54",
+        "run_55",
+        "run_57",
+        "run_58",
+        "run_59",
+        "run_60",
+        "run_61",
+        "run_62",
+        "run_63",
+        "run_64",
+        "run_66",
+        "run_67",
+        "run_68",
+        "run_70",
+        "run_71",
+        "run_72",
+        "run_74",
+        "run_75",
+        "run_76",
+        "run_80",
+        "run_81",
+        "run_83",
+        "run_84",
+        "run_85",
+        "run_86",
+        "run_89",
+        "run_90",
+        "run_91",
+        "run_92",
+        "run_93",
+        "run_94",
+        "run_95",
+        "run_97",
+        "run_98",
+        "run_99",
+        "run_100",
+        "run_101",
+        "run_102",
+        "run_103",
+        "run_104",
+        "run_105",
+        "run_106",
+        "run_107",
+        "run_111",
+        "run_113",
+        "run_114",
+        "run_117",
+        "run_118",
+        "run_119",
+        "run_120",
+        "run_121",
+        "run_124",
+        "run_125",
+        "run_127",
+        "run_128",
+        "run_130",
+        "run_131",
+        "run_133",
+        "run_134",
+        "run_136",
+        "run_137",
+        "run_139",
+        "run_140",
+        "run_141",
+        "run_142",
+        "run_144",
+        "run_145",
+        "run_147",
+        "run_149",
+        "run_150",
+        "run_152",
+        "run_153",
+        "run_156",
+        "run_157",
+        "run_159",
+        "run_160",
+        "run_161",
+        "run_162",
+        "run_164",
+        "run_166",
+        "run_168",
+        "run_169",
+        "run_170",
+        "run_171",
+        "run_172",
+        "run_175",
+        "run_176",
+        "run_177",
+        "run_178",
+        "run_179",
+        "run_180",
+        "run_182",
+        "run_183",
+        "run_185",
+        "run_187",
+        "run_189",
+        "run_191",
+        "run_192",
+        "run_193",
+        "run_194",
+        "run_195",
+        "run_197",
+        "run_198",
+        "run_200",
+        "run_201",
+        "run_202",
+        "run_203",
+        "run_205",
+        "run_207",
+        "run_208",
+        "run_209",
+        "run_212",
+        "run_213",
+        "run_214",
+        "run_215",
+        "run_217",
+        "run_220",
+        "run_222",
+        "run_224",
+        "run_225",
+        "run_227",
+        "run_228",
+        "run_231",
+        "run_232",
+        "run_233",
+        "run_236",
+        "run_237",
+        "run_240",
+        "run_241",
+        "run_242",
+        "run_244",
+        "run_246",
+        "run_249",
+        "run_251",
+        "run_252",
+        "run_253",
+        "run_254",
+        "run_256",
+        "run_257",
+        "run_259",
+        "run_260",
+        "run_261",
+        "run_262",
+        "run_263",
+        "run_264",
+        "run_265",
+        "run_266",
+        "run_267",
+        "run_268",
+        "run_270",
+        "run_271",
+        "run_272",
+        "run_273",
+        "run_274",
+        "run_276",
+        "run_278",
+        "run_279",
+        "run_280",
+        "run_281",
+        "run_283",
+        "run_284",
+        "run_285",
+        "run_286",
+        "run_287",
+        "run_288",
+        "run_290",
+        "run_294",
+        "run_296",
+        "run_297",
+        "run_298",
+        "run_300",
+        "run_301",
+        "run_302",
+        "run_304",
+        "run_305",
+        "run_306",
+        "run_308",
+        "run_310",
+        "run_311",
+        "run_313",
+        "run_314",
+        "run_315",
+        "run_317",
+        "run_321",
+        "run_322",
+        "run_323",
+        "run_326",
+        "run_327",
+        "run_328",
+        "run_330",
+        "run_332",
+        "run_334",
+        "run_336",
+        "run_337",
+        "run_338",
+        "run_339",
+        "run_341",
+        "run_344",
+        "run_345",
+        "run_346",
+        "run_347",
+        "run_348",
+        "run_349",
+        "run_351",
+        "run_353",
+        "run_354",
+        "run_355",
+        "run_356",
+        "run_358",
+        "run_359",
+        "run_361",
+        "run_362",
+        "run_365",
+        "run_366",
+        "run_368",
+        "run_373",
+        "run_374",
+        "run_375",
+        "run_378",
+        "run_380",
+        "run_382",
+        "run_383",
+        "run_384",
+        "run_385",
+        "run_386",
+        "run_388",
+        "run_392",
+        "run_393",
+        "run_394",
+        "run_395",
+        "run_396",
+        "run_398",
+        "run_399",
+        "run_400",
+        "run_401",
+        "run_402",
+        "run_404",
+        "run_405",
+        "run_406",
+        "run_407",
+        "run_409",
+        "run_410",
+        "run_411",
+        "run_415",
+        "run_416",
+        "run_418",
+        "run_419",
+        "run_421",
+        "run_422",
+        "run_423",
+        "run_424",
+        "run_425",
+        "run_426",
+        "run_427",
+        "run_428",
+        "run_430",
+        "run_432",
+        "run_433",
+        "run_434",
+        "run_435",
+        "run_437",
+        "run_438",
+        "run_440",
+        "run_441",
+        "run_442",
+        "run_443",
+        "run_444",
+        "run_446",
+        "run_447",
+        "run_448",
+        "run_449",
+        "run_450",
+        "run_451",
+        "run_453",
+        "run_455",
+        "run_456",
+        "run_457",
+        "run_458",
+        "run_459",
+        "run_460",
+        "run_462",
+        "run_463",
+        "run_464",
+        "run_468",
+        "run_470",
+        "run_471",
+        "run_475",
+        "run_476",
+        "run_478",
+        "run_479",
+        "run_480",
+        "run_481",
+        "run_482",
+        "run_483",
+        "run_485",
+        "run_486",
+        "run_487",
+        "run_488",
+        "run_489",
+        "run_492",
+        "run_493",
+        "run_496",
+        "run_497",
+        "run_499"
+    ],
+    "high_drag_val": [
+        "run_15",
+        "run_23",
+        "run_34",
+        "run_37",
+        "run_52",
+        "run_65",
+        "run_73",
+        "run_87",
+        "run_96",
+        "run_109",
+        "run_110",
+        "run_116",
+        "run_146",
+        "run_151",
+        "run_154",
+        "run_158",
+        "run_174",
+        "run_188",
+        "run_199",
+        "run_223",
+        "run_229",
+        "run_230",
+        "run_235",
+        "run_238",
+        "run_255",
+        "run_269",
+        "run_289",
+        "run_293",
+        "run_309",
+        "run_312",
+        "run_319",
+        "run_331",
+        "run_335",
+        "run_340",
+        "run_342",
+        "run_363",
+        "run_369",
+        "run_372",
+        "run_389",
+        "run_397",
+        "run_413",
+        "run_466",
+        "run_467",
+        "run_472",
+        "run_474",
+        "run_484",
+        "run_494",
+        "run_498"
+    ],
+    "high_drag_test": [
+        "run_1",
+        "run_8",
+        "run_11",
+        "run_14",
+        "run_18",
+        "run_19",
+        "run_22",
+        "run_29",
+        "run_39",
+        "run_44",
+        "run_47",
+        "run_49",
+        "run_53",
+        "run_56",
+        "run_69",
+        "run_77",
+        "run_78",
+        "run_79",
+        "run_82",
+        "run_88",
+        "run_108",
+        "run_112",
+        "run_115",
+        "run_122",
+        "run_123",
+        "run_126",
+        "run_129",
+        "run_132",
+        "run_135",
+        "run_138",
+        "run_143",
+        "run_148",
+        "run_155",
+        "run_163",
+        "run_165",
+        "run_173",
+        "run_181",
+        "run_184",
+        "run_186",
+        "run_190",
+        "run_196",
+        "run_204",
+        "run_206",
+        "run_210",
+        "run_216",
+        "run_219",
+        "run_226",
+        "run_234",
+        "run_239",
+        "run_243",
+        "run_245",
+        "run_247",
+        "run_250",
+        "run_258",
+        "run_275",
+        "run_277",
+        "run_292",
+        "run_299",
+        "run_303",
+        "run_307",
+        "run_318",
+        "run_320",
+        "run_324",
+        "run_333",
+        "run_343",
+        "run_350",
+        "run_352",
+        "run_357",
+        "run_360",
+        "run_367",
+        "run_371",
+        "run_377",
+        "run_379",
+        "run_381",
+        "run_387",
+        "run_390",
+        "run_391",
+        "run_408",
+        "run_412",
+        "run_414",
+        "run_417",
+        "run_420",
+        "run_429",
+        "run_431",
+        "run_436",
+        "run_439",
+        "run_445",
+        "run_452",
+        "run_454",
+        "run_461",
+        "run_465",
+        "run_469",
+        "run_477",
+        "run_490",
+        "run_491",
+        "run_495",
+        "run_500"
+    ],
+    "low_drag_train": [
+        "run_1",
+        "run_4",
+        "run_6",
+        "run_7",
+        "run_9",
+        "run_11",
+        "run_12",
+        "run_13",
+        "run_14",
+        "run_16",
+        "run_18",
+        "run_19",
+        "run_20",
+        "run_21",
+        "run_22",
+        "run_23",
+        "run_24",
+        "run_25",
+        "run_26",
+        "run_28",
+        "run_29",
+        "run_30",
+        "run_32",
+        "run_33",
+        "run_34",
+        "run_36",
+        "run_39",
+        "run_40",
+        "run_41",
+        "run_42",
+        "run_44",
+        "run_46",
+        "run_47",
+        "run_49",
+        "run_51",
+        "run_52",
+        "run_55",
+        "run_56",
+        "run_57",
+        "run_58",
+        "run_61",
+        "run_63",
+        "run_64",
+        "run_65",
+        "run_66",
+        "run_68",
+        "run_69",
+        "run_72",
+        "run_73",
+        "run_74",
+        "run_75",
+        "run_77",
+        "run_78",
+        "run_79",
+        "run_82",
+        "run_83",
+        "run_84",
+        "run_86",
+        "run_87",
+        "run_88",
+        "run_89",
+        "run_90",
+        "run_91",
+        "run_92",
+        "run_93",
+        "run_95",
+        "run_96",
+        "run_97",
+        "run_98",
+        "run_100",
+        "run_101",
+        "run_105",
+        "run_108",
+        "run_110",
+        "run_111",
+        "run_112",
+        "run_113",
+        "run_115",
+        "run_117",
+        "run_118",
+        "run_119",
+        "run_120",
+        "run_122",
+        "run_123",
+        "run_125",
+        "run_127",
+        "run_129",
+        "run_130",
+        "run_132",
+        "run_133",
+        "run_134",
+        "run_135",
+        "run_136",
+        "run_137",
+        "run_138",
+        "run_139",
+        "run_140",
+        "run_141",
+        "run_142",
+        "run_143",
+        "run_145",
+        "run_146",
+        "run_147",
+        "run_150",
+        "run_152",
+        "run_153",
+        "run_154",
+        "run_155",
+        "run_156",
+        "run_160",
+        "run_163",
+        "run_164",
+        "run_165",
+        "run_169",
+        "run_170",
+        "run_171",
+        "run_173",
+        "run_174",
+        "run_175",
+        "run_176",
+        "run_177",
+        "run_180",
+        "run_181",
+        "run_182",
+        "run_185",
+        "run_186",
+        "run_187",
+        "run_189",
+        "run_190",
+        "run_191",
+        "run_192",
+        "run_193",
+        "run_195",
+        "run_196",
+        "run_197",
+        "run_199",
+        "run_200",
+        "run_202",
+        "run_204",
+        "run_205",
+        "run_206",
+        "run_208",
+        "run_209",
+        "run_210",
+        "run_212",
+        "run_214",
+        "run_215",
+        "run_216",
+        "run_219",
+        "run_223",
+        "run_224",
+        "run_226",
+        "run_227",
+        "run_229",
+        "run_230",
+        "run_231",
+        "run_232",
+        "run_234",
+        "run_236",
+        "run_238",
+        "run_239",
+        "run_240",
+        "run_241",
+        "run_243",
+        "run_245",
+        "run_247",
+        "run_249",
+        "run_250",
+        "run_251",
+        "run_252",
+        "run_254",
+        "run_255",
+        "run_257",
+        "run_258",
+        "run_259",
+        "run_261",
+        "run_265",
+        "run_268",
+        "run_270",
+        "run_271",
+        "run_272",
+        "run_273",
+        "run_274",
+        "run_275",
+        "run_276",
+        "run_277",
+        "run_278",
+        "run_280",
+        "run_283",
+        "run_285",
+        "run_286",
+        "run_287",
+        "run_292",
+        "run_294",
+        "run_296",
+        "run_297",
+        "run_299",
+        "run_300",
+        "run_301",
+        "run_303",
+        "run_304",
+        "run_305",
+        "run_306",
+        "run_307",
+        "run_310",
+        "run_311",
+        "run_312",
+        "run_313",
+        "run_315",
+        "run_317",
+        "run_318",
+        "run_320",
+        "run_322",
+        "run_323",
+        "run_324",
+        "run_326",
+        "run_327",
+        "run_328",
+        "run_332",
+        "run_333",
+        "run_334",
+        "run_335",
+        "run_336",
+        "run_337",
+        "run_338",
+        "run_339",
+        "run_341",
+        "run_342",
+        "run_343",
+        "run_346",
+        "run_347",
+        "run_348",
+        "run_350",
+        "run_351",
+        "run_352",
+        "run_353",
+        "run_354",
+        "run_356",
+        "run_357",
+        "run_358",
+        "run_360",
+        "run_361",
+        "run_362",
+        "run_365",
+        "run_367",
+        "run_368",
+        "run_371",
+        "run_374",
+        "run_375",
+        "run_377",
+        "run_378",
+        "run_379",
+        "run_380",
+        "run_381",
+        "run_384",
+        "run_385",
+        "run_386",
+        "run_387",
+        "run_390",
+        "run_391",
+        "run_394",
+        "run_395",
+        "run_396",
+        "run_397",
+        "run_398",
+        "run_399",
+        "run_400",
+        "run_401",
+        "run_402",
+        "run_404",
+        "run_405",
+        "run_406",
+        "run_408",
+        "run_410",
+        "run_411",
+        "run_412",
+        "run_413",
+        "run_414",
+        "run_417",
+        "run_418",
+        "run_420",
+        "run_421",
+        "run_422",
+        "run_423",
+        "run_424",
+        "run_427",
+        "run_429",
+        "run_431",
+        "run_432",
+        "run_433",
+        "run_434",
+        "run_435",
+        "run_438",
+        "run_439",
+        "run_441",
+        "run_442",
+        "run_443",
+        "run_444",
+        "run_445",
+        "run_446",
+        "run_447",
+        "run_448",
+        "run_450",
+        "run_451",
+        "run_452",
+        "run_453",
+        "run_454",
+        "run_455",
+        "run_458",
+        "run_459",
+        "run_460",
+        "run_461",
+        "run_463",
+        "run_464",
+        "run_465",
+        "run_466",
+        "run_469",
+        "run_471",
+        "run_474",
+        "run_475",
+        "run_476",
+        "run_477",
+        "run_478",
+        "run_479",
+        "run_480",
+        "run_481",
+        "run_482",
+        "run_484",
+        "run_485",
+        "run_486",
+        "run_487",
+        "run_488",
+        "run_490",
+        "run_491",
+        "run_493",
+        "run_494",
+        "run_495",
+        "run_497",
+        "run_499"
+    ],
+    "low_drag_val": [
+        "run_2",
+        "run_8",
+        "run_15",
+        "run_35",
+        "run_37",
+        "run_53",
+        "run_54",
+        "run_59",
+        "run_71",
+        "run_99",
+        "run_103",
+        "run_104",
+        "run_121",
+        "run_126",
+        "run_148",
+        "run_149",
+        "run_151",
+        "run_157",
+        "run_161",
+        "run_168",
+        "run_172",
+        "run_184",
+        "run_201",
+        "run_203",
+        "run_207",
+        "run_217",
+        "run_233",
+        "run_256",
+        "run_260",
+        "run_263",
+        "run_264",
+        "run_266",
+        "run_290",
+        "run_293",
+        "run_314",
+        "run_344",
+        "run_363",
+        "run_372",
+        "run_382",
+        "run_393",
+        "run_407",
+        "run_425",
+        "run_428",
+        "run_436",
+        "run_457",
+        "run_467",
+        "run_498",
+        "run_500"
+    ],
+    "low_drag_test": [
+        "run_3",
+        "run_5",
+        "run_10",
+        "run_17",
+        "run_27",
+        "run_31",
+        "run_38",
+        "run_43",
+        "run_45",
+        "run_48",
+        "run_50",
+        "run_60",
+        "run_62",
+        "run_67",
+        "run_70",
+        "run_76",
+        "run_80",
+        "run_81",
+        "run_85",
+        "run_94",
+        "run_102",
+        "run_106",
+        "run_107",
+        "run_109",
+        "run_114",
+        "run_116",
+        "run_124",
+        "run_128",
+        "run_131",
+        "run_144",
+        "run_158",
+        "run_159",
+        "run_162",
+        "run_166",
+        "run_178",
+        "run_179",
+        "run_183",
+        "run_188",
+        "run_194",
+        "run_198",
+        "run_213",
+        "run_220",
+        "run_222",
+        "run_225",
+        "run_228",
+        "run_235",
+        "run_237",
+        "run_242",
+        "run_244",
+        "run_246",
+        "run_253",
+        "run_262",
+        "run_267",
+        "run_269",
+        "run_279",
+        "run_281",
+        "run_284",
+        "run_288",
+        "run_289",
+        "run_298",
+        "run_302",
+        "run_308",
+        "run_309",
+        "run_319",
+        "run_321",
+        "run_330",
+        "run_331",
+        "run_340",
+        "run_345",
+        "run_349",
+        "run_355",
+        "run_359",
+        "run_366",
+        "run_369",
+        "run_373",
+        "run_383",
+        "run_388",
+        "run_389",
+        "run_392",
+        "run_409",
+        "run_415",
+        "run_416",
+        "run_419",
+        "run_426",
+        "run_430",
+        "run_437",
+        "run_440",
+        "run_449",
+        "run_456",
+        "run_462",
+        "run_468",
+        "run_470",
+        "run_472",
+        "run_483",
+        "run_489",
+        "run_492",
+        "run_496"
+    ],
+    "geometry_train": [
+        "run_1",
+        "run_2",
+        "run_3",
+        "run_4",
+        "run_6",
+        "run_7",
+        "run_9",
+        "run_10",
+        "run_13",
+        "run_14",
+        "run_15",
+        "run_16",
+        "run_17",
+        "run_18",
+        "run_19",
+        "run_20",
+        "run_21",
+        "run_22",
+        "run_23",
+        "run_24",
+        "run_26",
+        "run_27",
+        "run_30",
+        "run_31",
+        "run_33",
+        "run_34",
+        "run_35",
+        "run_37",
+        "run_38",
+        "run_40",
+        "run_41",
+        "run_42",
+        "run_44",
+        "run_46",
+        "run_47",
+        "run_48",
+        "run_50",
+        "run_51",
+        "run_55",
+        "run_56",
+        "run_57",
+        "run_58",
+        "run_59",
+        "run_60",
+        "run_61",
+        "run_62",
+        "run_64",
+        "run_66",
+        "run_67",
+        "run_68",
+        "run_69",
+        "run_70",
+        "run_71",
+        "run_73",
+        "run_74",
+        "run_76",
+        "run_77",
+        "run_79",
+        "run_80",
+        "run_81",
+        "run_82",
+        "run_83",
+        "run_84",
+        "run_85",
+        "run_86",
+        "run_87",
+        "run_90",
+        "run_91",
+        "run_92",
+        "run_94",
+        "run_95",
+        "run_99",
+        "run_100",
+        "run_101",
+        "run_103",
+        "run_104",
+        "run_106",
+        "run_107",
+        "run_108",
+        "run_109",
+        "run_110",
+        "run_111",
+        "run_113",
+        "run_114",
+        "run_116",
+        "run_118",
+        "run_122",
+        "run_123",
+        "run_124",
+        "run_126",
+        "run_127",
+        "run_130",
+        "run_131",
+        "run_132",
+        "run_133",
+        "run_134",
+        "run_135",
+        "run_136",
+        "run_137",
+        "run_139",
+        "run_140",
+        "run_141",
+        "run_143",
+        "run_144",
+        "run_145",
+        "run_146",
+        "run_147",
+        "run_148",
+        "run_149",
+        "run_150",
+        "run_151",
+        "run_153",
+        "run_155",
+        "run_156",
+        "run_157",
+        "run_158",
+        "run_160",
+        "run_162",
+        "run_163",
+        "run_164",
+        "run_165",
+        "run_166",
+        "run_168",
+        "run_169",
+        "run_170",
+        "run_171",
+        "run_172",
+        "run_174",
+        "run_175",
+        "run_177",
+        "run_178",
+        "run_180",
+        "run_181",
+        "run_182",
+        "run_183",
+        "run_184",
+        "run_185",
+        "run_187",
+        "run_188",
+        "run_190",
+        "run_192",
+        "run_194",
+        "run_195",
+        "run_196",
+        "run_197",
+        "run_198",
+        "run_199",
+        "run_200",
+        "run_202",
+        "run_203",
+        "run_204",
+        "run_205",
+        "run_206",
+        "run_207",
+        "run_208",
+        "run_210",
+        "run_212",
+        "run_215",
+        "run_216",
+        "run_219",
+        "run_222",
+        "run_223",
+        "run_225",
+        "run_227",
+        "run_230",
+        "run_232",
+        "run_233",
+        "run_234",
+        "run_235",
+        "run_238",
+        "run_239",
+        "run_240",
+        "run_241",
+        "run_242",
+        "run_243",
+        "run_245",
+        "run_247",
+        "run_249",
+        "run_251",
+        "run_252",
+        "run_253",
+        "run_254",
+        "run_255",
+        "run_257",
+        "run_259",
+        "run_261",
+        "run_262",
+        "run_263",
+        "run_264",
+        "run_266",
+        "run_267",
+        "run_268",
+        "run_269",
+        "run_270",
+        "run_272",
+        "run_273",
+        "run_274",
+        "run_275",
+        "run_278",
+        "run_279",
+        "run_283",
+        "run_284",
+        "run_285",
+        "run_286",
+        "run_287",
+        "run_289",
+        "run_290",
+        "run_294",
+        "run_296",
+        "run_298",
+        "run_300",
+        "run_301",
+        "run_302",
+        "run_303",
+        "run_304",
+        "run_305",
+        "run_307",
+        "run_308",
+        "run_309",
+        "run_310",
+        "run_312",
+        "run_313",
+        "run_314",
+        "run_315",
+        "run_317",
+        "run_318",
+        "run_319",
+        "run_320",
+        "run_321",
+        "run_323",
+        "run_326",
+        "run_327",
+        "run_328",
+        "run_330",
+        "run_331",
+        "run_332",
+        "run_334",
+        "run_335",
+        "run_336",
+        "run_339",
+        "run_340",
+        "run_342",
+        "run_344",
+        "run_346",
+        "run_348",
+        "run_349",
+        "run_350",
+        "run_351",
+        "run_352",
+        "run_353",
+        "run_354",
+        "run_355",
+        "run_356",
+        "run_358",
+        "run_359",
+        "run_360",
+        "run_361",
+        "run_363",
+        "run_365",
+        "run_368",
+        "run_371",
+        "run_372",
+        "run_374",
+        "run_375",
+        "run_377",
+        "run_378",
+        "run_380",
+        "run_381",
+        "run_383",
+        "run_384",
+        "run_385",
+        "run_386",
+        "run_387",
+        "run_388",
+        "run_391",
+        "run_392",
+        "run_394",
+        "run_399",
+        "run_400",
+        "run_401",
+        "run_405",
+        "run_407",
+        "run_408",
+        "run_410",
+        "run_411",
+        "run_414",
+        "run_415",
+        "run_416",
+        "run_417",
+        "run_418",
+        "run_421",
+        "run_422",
+        "run_424",
+        "run_426",
+        "run_427",
+        "run_428",
+        "run_432",
+        "run_434",
+        "run_435",
+        "run_436",
+        "run_437",
+        "run_438",
+        "run_440",
+        "run_441",
+        "run_444",
+        "run_446",
+        "run_448",
+        "run_450",
+        "run_452",
+        "run_453",
+        "run_454",
+        "run_456",
+        "run_457",
+        "run_458",
+        "run_459",
+        "run_461",
+        "run_462",
+        "run_464",
+        "run_465",
+        "run_467",
+        "run_471",
+        "run_472",
+        "run_474",
+        "run_478",
+        "run_479",
+        "run_481",
+        "run_482",
+        "run_483",
+        "run_484",
+        "run_487",
+        "run_488",
+        "run_490",
+        "run_491",
+        "run_492",
+        "run_493",
+        "run_496",
+        "run_498",
+        "run_499",
+        "run_500"
+    ],
+    "geometry_val": [
+        "run_8",
+        "run_12",
+        "run_32",
+        "run_36",
+        "run_52",
+        "run_54",
+        "run_63",
+        "run_89",
+        "run_93",
+        "run_96",
+        "run_97",
+        "run_117",
+        "run_119",
+        "run_128",
+        "run_159",
+        "run_179",
+        "run_201",
+        "run_214",
+        "run_217",
+        "run_220",
+        "run_224",
+        "run_229",
+        "run_236",
+        "run_271",
+        "run_322",
+        "run_333",
+        "run_337",
+        "run_338",
+        "run_343",
+        "run_390",
+        "run_396",
+        "run_398",
+        "run_402",
+        "run_404",
+        "run_413",
+        "run_419",
+        "run_423",
+        "run_429",
+        "run_442",
+        "run_443",
+        "run_449",
+        "run_451",
+        "run_460",
+        "run_468",
+        "run_475",
+        "run_476",
+        "run_486",
+        "run_494"
+    ],
+    "geometry_test": [
+        "run_5",
+        "run_11",
+        "run_25",
+        "run_28",
+        "run_29",
+        "run_39",
+        "run_43",
+        "run_45",
+        "run_49",
+        "run_53",
+        "run_65",
+        "run_72",
+        "run_75",
+        "run_78",
+        "run_88",
+        "run_98",
+        "run_102",
+        "run_105",
+        "run_112",
+        "run_115",
+        "run_120",
+        "run_121",
+        "run_125",
+        "run_129",
+        "run_138",
+        "run_142",
+        "run_152",
+        "run_154",
+        "run_161",
+        "run_173",
+        "run_176",
+        "run_186",
+        "run_189",
+        "run_191",
+        "run_193",
+        "run_209",
+        "run_213",
+        "run_226",
+        "run_228",
+        "run_231",
+        "run_237",
+        "run_244",
+        "run_246",
+        "run_250",
+        "run_256",
+        "run_258",
+        "run_260",
+        "run_265",
+        "run_276",
+        "run_277",
+        "run_280",
+        "run_281",
+        "run_288",
+        "run_292",
+        "run_293",
+        "run_297",
+        "run_299",
+        "run_306",
+        "run_311",
+        "run_324",
+        "run_341",
+        "run_345",
+        "run_347",
+        "run_357",
+        "run_362",
+        "run_366",
+        "run_367",
+        "run_369",
+        "run_373",
+        "run_379",
+        "run_382",
+        "run_389",
+        "run_393",
+        "run_395",
+        "run_397",
+        "run_406",
+        "run_409",
+        "run_412",
+        "run_420",
+        "run_425",
+        "run_430",
+        "run_431",
+        "run_433",
+        "run_439",
+        "run_445",
+        "run_447",
+        "run_455",
+        "run_463",
+        "run_466",
+        "run_469",
+        "run_470",
+        "run_477",
+        "run_480",
+        "run_485",
+        "run_489",
+        "run_495",
+        "run_497"
+    ],
+    "rear_separation_train": [
+        "run_1",
+        "run_3",
+        "run_4",
+        "run_6",
+        "run_8",
+        "run_9",
+        "run_11",
+        "run_12",
+        "run_13",
+        "run_14",
+        "run_16",
+        "run_19",
+        "run_20",
+        "run_21",
+        "run_22",
+        "run_23",
+        "run_24",
+        "run_26",
+        "run_27",
+        "run_28",
+        "run_29",
+        "run_31",
+        "run_32",
+        "run_33",
+        "run_34",
+        "run_35",
+        "run_36",
+        "run_37",
+        "run_39",
+        "run_40",
+        "run_42",
+        "run_44",
+        "run_45",
+        "run_47",
+        "run_49",
+        "run_53",
+        "run_55",
+        "run_56",
+        "run_57",
+        "run_58",
+        "run_61",
+        "run_62",
+        "run_63",
+        "run_64",
+        "run_66",
+        "run_67",
+        "run_68",
+        "run_69",
+        "run_70",
+        "run_71",
+        "run_73",
+        "run_74",
+        "run_75",
+        "run_76",
+        "run_77",
+        "run_78",
+        "run_81",
+        "run_82",
+        "run_83",
+        "run_85",
+        "run_86",
+        "run_88",
+        "run_90",
+        "run_91",
+        "run_92",
+        "run_93",
+        "run_94",
+        "run_95",
+        "run_96",
+        "run_97",
+        "run_98",
+        "run_99",
+        "run_100",
+        "run_104",
+        "run_106",
+        "run_107",
+        "run_108",
+        "run_109",
+        "run_111",
+        "run_112",
+        "run_113",
+        "run_114",
+        "run_115",
+        "run_117",
+        "run_118",
+        "run_119",
+        "run_122",
+        "run_123",
+        "run_126",
+        "run_127",
+        "run_128",
+        "run_129",
+        "run_130",
+        "run_132",
+        "run_133",
+        "run_135",
+        "run_136",
+        "run_140",
+        "run_141",
+        "run_142",
+        "run_143",
+        "run_145",
+        "run_146",
+        "run_147",
+        "run_149",
+        "run_150",
+        "run_151",
+        "run_152",
+        "run_153",
+        "run_154",
+        "run_155",
+        "run_156",
+        "run_157",
+        "run_159",
+        "run_161",
+        "run_162",
+        "run_164",
+        "run_165",
+        "run_168",
+        "run_170",
+        "run_171",
+        "run_172",
+        "run_174",
+        "run_175",
+        "run_176",
+        "run_177",
+        "run_179",
+        "run_181",
+        "run_182",
+        "run_183",
+        "run_186",
+        "run_188",
+        "run_190",
+        "run_191",
+        "run_192",
+        "run_195",
+        "run_196",
+        "run_198",
+        "run_199",
+        "run_200",
+        "run_201",
+        "run_202",
+        "run_203",
+        "run_204",
+        "run_205",
+        "run_206",
+        "run_207",
+        "run_209",
+        "run_210",
+        "run_214",
+        "run_215",
+        "run_216",
+        "run_219",
+        "run_222",
+        "run_223",
+        "run_224",
+        "run_225",
+        "run_227",
+        "run_228",
+        "run_229",
+        "run_230",
+        "run_232",
+        "run_233",
+        "run_234",
+        "run_235",
+        "run_236",
+        "run_238",
+        "run_239",
+        "run_241",
+        "run_243",
+        "run_245",
+        "run_247",
+        "run_249",
+        "run_250",
+        "run_251",
+        "run_252",
+        "run_254",
+        "run_255",
+        "run_256",
+        "run_257",
+        "run_258",
+        "run_260",
+        "run_261",
+        "run_263",
+        "run_264",
+        "run_265",
+        "run_267",
+        "run_268",
+        "run_269",
+        "run_271",
+        "run_272",
+        "run_273",
+        "run_274",
+        "run_275",
+        "run_280",
+        "run_283",
+        "run_284",
+        "run_285",
+        "run_286",
+        "run_287",
+        "run_290",
+        "run_292",
+        "run_294",
+        "run_296",
+        "run_298",
+        "run_299",
+        "run_300",
+        "run_301",
+        "run_303",
+        "run_304",
+        "run_306",
+        "run_307",
+        "run_308",
+        "run_309",
+        "run_310",
+        "run_312",
+        "run_314",
+        "run_315",
+        "run_317",
+        "run_319",
+        "run_320",
+        "run_321",
+        "run_322",
+        "run_323",
+        "run_324",
+        "run_326",
+        "run_328",
+        "run_330",
+        "run_333",
+        "run_334",
+        "run_335",
+        "run_337",
+        "run_338",
+        "run_339",
+        "run_341",
+        "run_343",
+        "run_346",
+        "run_347",
+        "run_350",
+        "run_351",
+        "run_353",
+        "run_355",
+        "run_356",
+        "run_357",
+        "run_358",
+        "run_360",
+        "run_362",
+        "run_363",
+        "run_365",
+        "run_367",
+        "run_368",
+        "run_369",
+        "run_372",
+        "run_373",
+        "run_374",
+        "run_375",
+        "run_377",
+        "run_378",
+        "run_379",
+        "run_380",
+        "run_381",
+        "run_383",
+        "run_384",
+        "run_385",
+        "run_386",
+        "run_388",
+        "run_389",
+        "run_390",
+        "run_391",
+        "run_394",
+        "run_395",
+        "run_397",
+        "run_398",
+        "run_399",
+        "run_401",
+        "run_405",
+        "run_408",
+        "run_410",
+        "run_411",
+        "run_412",
+        "run_414",
+        "run_415",
+        "run_416",
+        "run_417",
+        "run_418",
+        "run_419",
+        "run_420",
+        "run_421",
+        "run_425",
+        "run_426",
+        "run_428",
+        "run_429",
+        "run_431",
+        "run_432",
+        "run_433",
+        "run_434",
+        "run_435",
+        "run_436",
+        "run_437",
+        "run_438",
+        "run_439",
+        "run_440",
+        "run_441",
+        "run_442",
+        "run_445",
+        "run_446",
+        "run_448",
+        "run_450",
+        "run_452",
+        "run_453",
+        "run_456",
+        "run_457",
+        "run_458",
+        "run_459",
+        "run_460",
+        "run_464",
+        "run_465",
+        "run_466",
+        "run_467",
+        "run_469",
+        "run_470",
+        "run_471",
+        "run_472",
+        "run_474",
+        "run_475",
+        "run_477",
+        "run_478",
+        "run_479",
+        "run_481",
+        "run_482",
+        "run_483",
+        "run_484",
+        "run_488",
+        "run_491",
+        "run_495",
+        "run_497",
+        "run_498",
+        "run_499",
+        "run_500"
+    ],
+    "rear_separation_val": [
+        "run_7",
+        "run_15",
+        "run_18",
+        "run_46",
+        "run_51",
+        "run_59",
+        "run_79",
+        "run_84",
+        "run_101",
+        "run_134",
+        "run_137",
+        "run_138",
+        "run_160",
+        "run_163",
+        "run_169",
+        "run_173",
+        "run_184",
+        "run_193",
+        "run_197",
+        "run_208",
+        "run_226",
+        "run_262",
+        "run_266",
+        "run_270",
+        "run_277",
+        "run_297",
+        "run_305",
+        "run_313",
+        "run_318",
+        "run_327",
+        "run_331",
+        "run_344",
+        "run_352",
+        "run_366",
+        "run_371",
+        "run_387",
+        "run_392",
+        "run_424",
+        "run_427",
+        "run_447",
+        "run_454",
+        "run_461",
+        "run_463",
+        "run_485",
+        "run_487",
+        "run_490",
+        "run_492",
+        "run_494"
+    ],
+    "rear_separation_test": [
+        "run_2",
+        "run_5",
+        "run_10",
+        "run_17",
+        "run_25",
+        "run_30",
+        "run_38",
+        "run_41",
+        "run_43",
+        "run_48",
+        "run_50",
+        "run_52",
+        "run_54",
+        "run_60",
+        "run_65",
+        "run_72",
+        "run_80",
+        "run_87",
+        "run_89",
+        "run_102",
+        "run_103",
+        "run_105",
+        "run_110",
+        "run_116",
+        "run_120",
+        "run_121",
+        "run_124",
+        "run_125",
+        "run_131",
+        "run_139",
+        "run_144",
+        "run_148",
+        "run_158",
+        "run_166",
+        "run_178",
+        "run_180",
+        "run_185",
+        "run_187",
+        "run_189",
+        "run_194",
+        "run_212",
+        "run_213",
+        "run_217",
+        "run_220",
+        "run_231",
+        "run_237",
+        "run_240",
+        "run_242",
+        "run_244",
+        "run_246",
+        "run_253",
+        "run_259",
+        "run_276",
+        "run_278",
+        "run_279",
+        "run_281",
+        "run_288",
+        "run_289",
+        "run_293",
+        "run_302",
+        "run_311",
+        "run_332",
+        "run_336",
+        "run_340",
+        "run_342",
+        "run_345",
+        "run_348",
+        "run_349",
+        "run_354",
+        "run_359",
+        "run_361",
+        "run_382",
+        "run_393",
+        "run_396",
+        "run_400",
+        "run_402",
+        "run_404",
+        "run_406",
+        "run_407",
+        "run_409",
+        "run_413",
+        "run_422",
+        "run_423",
+        "run_430",
+        "run_443",
+        "run_444",
+        "run_449",
+        "run_451",
+        "run_455",
+        "run_462",
+        "run_468",
+        "run_476",
+        "run_480",
+        "run_486",
+        "run_489",
+        "run_493",
+        "run_496"
+    ]
+}

splits/visualize_flow_regimes.py

@@ -0,0 +1,155 @@
+"""Visualize the DrivAerML force- and geometry-regime split logic.
+
+Creates force_regimes.png. The script reads force_mom_all.csv and
+geo_parameters_all.csv when available. It also reads chamfer_metrics.csv when
+available to show the STL-surface geometry split.
+
+Usage:
+    python3 splits/visualize_flow_regimes.py
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+from matplotlib.lines import Line2D
+import numpy as np
+
+from generate_splits import (
+    load_chamfer_scores,
+    load_force_mom,
+    run_id,
+)
+
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+PACKAGE_ROOT = SCRIPT_DIR
+DATA_DIR = PACKAGE_ROOT
+DOCS_DIR = PACKAGE_ROOT
+SPLITS_DIR = PACKAGE_ROOT
+OUT = DOCS_DIR / "force_regimes.png"
+MANIFEST = SPLITS_DIR / "manifest.json"
+
+
+def _ids(manifest: dict[str, list[str]], key: str) -> set[int]:
+    return {run_id(cid) for cid in manifest[key]}
+
+
+def _array(records: dict[int, dict[str, float]], field: str) -> tuple[np.ndarray, np.ndarray]:
+    runs = np.asarray(sorted(records))
+    values = np.asarray([records[int(r)][field] for r in runs], dtype=float)
+    return runs, values
+
+
+def _plot_partitioned(
+    ax,
+    runs: np.ndarray,
+    values: np.ndarray,
+    train_ids: set[int],
+    val_ids: set[int],
+    test_ids: set[int],
+    *,
+    title: str,
+    ylabel: str,
+    colors: dict[str, str],
+) -> None:
+    train_mask = np.asarray([int(r) in train_ids for r in runs])
+    val_mask = np.asarray([int(r) in val_ids for r in runs])
+    test_mask = np.asarray([int(r) in test_ids for r in runs])
+    ax.scatter(runs[train_mask], values[train_mask], s=30, color=colors["train"], linewidth=0, alpha=0.58)
+    ax.scatter(runs[val_mask], values[val_mask], s=46, color=colors["val"], linewidth=0, alpha=0.95)
+    ax.scatter(runs[test_mask], values[test_mask], s=46, color=colors["test"], linewidth=0, alpha=0.95)
+    ax.set_title(title)
+    ax.set_xlabel("run")
+    ax.set_ylabel(ylabel)
+    ax.grid(True, color="#e1e6eb", lw=0.7)
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+
+
+def main() -> None:
+    records, force_source = load_force_mom()
+    if force_source == "deterministic_proxy_missing_force_mom_all_csv":
+        raise SystemExit(
+            "force_mom_all.csv is required for force_regimes.png. "
+            "Run after `python3 splits/download_hf_inputs.py --output-dir data`, "
+            "or set DRIVAERML_DATA_ROOT to a directory containing it."
+        )
+    chamfer_scores, _ = load_chamfer_scores()
+    manifest = json.loads(MANIFEST.read_text(encoding="utf-8"))
+
+    runs, cd = _array(records, "cd")
+    chamfer = np.asarray([chamfer_scores[int(r)] for r in runs]) if chamfer_scores else None
+
+    full_train = _ids(manifest, "full_train")
+    full_val = _ids(manifest, "full_val")
+    full_test = _ids(manifest, "full_test")
+    high_drag_train = _ids(manifest, "high_drag_train")
+    high_drag_val = _ids(manifest, "high_drag_val")
+    high_drag_test = _ids(manifest, "high_drag_test")
+    low_drag_train = _ids(manifest, "low_drag_train")
+    low_drag_val = _ids(manifest, "low_drag_val")
+    low_drag_test = _ids(manifest, "low_drag_test")
+    geometry_train = _ids(manifest, "geometry_train") if "geometry_train" in manifest else set()
+    geometry_val = _ids(manifest, "geometry_val") if "geometry_val" in manifest else set()
+    geometry_test = _ids(manifest, "geometry_test") if "geometry_test" in manifest else set()
+
+    colors = {
+        "train": "#cfd5dc",
+        "val": "#c28f22",
+        "test": "#2f8f61",
+    }
+
+    axes = plt.figure(figsize=(11.0, 11.0), constrained_layout=True).subplot_mosaic(
+        [
+            ["full", "high"],
+            ["low", "geometry_cd"],
+            ["geometry_chamfer", "geometry_chamfer"],
+        ]
+    )
+    fig = axes["full"].figure
+
+    _plot_partitioned(
+        axes["full"], runs, cd, full_train, full_val, full_test,
+        title="Full random baseline", ylabel="Cd", colors=colors,
+    )
+    _plot_partitioned(
+        axes["high"], runs, cd, high_drag_train, high_drag_val, high_drag_test,
+        title="High-drag holdout", ylabel="Cd", colors=colors,
+    )
+    _plot_partitioned(
+        axes["low"], runs, cd, low_drag_train, low_drag_val, low_drag_test,
+        title="Low-drag holdout", ylabel="Cd", colors=colors,
+    )
+    _plot_partitioned(
+        axes["geometry_cd"], runs, cd, geometry_train, geometry_val, geometry_test,
+        title="Geometry holdout on Cd", ylabel="Cd", colors=colors,
+    )
+
+    ax = axes["geometry_chamfer"]
+    if chamfer is not None:
+        _plot_partitioned(
+            ax, runs, chamfer, geometry_train, geometry_val, geometry_test,
+            title="Geometry holdout", ylabel="mean 10-NN Chamfer", colors=colors,
+        )
+    else:
+        ax.text(0.5, 0.5, "splits/chamfer_metrics.csv not found", ha="center", va="center")
+        ax.set_axis_off()
+
+    legend_handles = [
+        Line2D([0], [0], marker="o", color="none", markerfacecolor=colors["train"], markeredgewidth=0, markersize=8, label="train"),
+        Line2D([0], [0], marker="o", color="none", markerfacecolor=colors["val"], markeredgewidth=0, markersize=8, label="val"),
+        Line2D([0], [0], marker="o", color="none", markerfacecolor=colors["test"], markeredgewidth=0, markersize=8, label="test"),
+    ]
+    fig.legend(handles=legend_handles, frameon=False, loc="upper center", ncol=3, bbox_to_anchor=(0.5, 0.975))
+
+    fig.suptitle("DrivAerML force and geometry split diagnostics", fontsize=12)
+    DOCS_DIR.mkdir(parents=True, exist_ok=True)
+    fig.savefig(OUT, dpi=180)
+    print(f"Wrote {OUT}")
+
+
+if __name__ == "__main__":
+    main()

splits/visualize_geometry_examples.py

@@ -0,0 +1,230 @@
+"""Build low/high geometry examples for the split report.
+
+Creates geometry_split_examples.png. The script selects the lowest Chamfer
+geometry score from geometry_train and the highest score from geometry_test,
+then renders same-scale complete-car side-view PNGs plus a transparent overlay
+when source images are available.
+"""
+
+from __future__ import annotations
+
+import csv
+import json
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+from PIL import Image
+
+from generate_splits import _run_image_dir, run_id
+
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+PACKAGE_ROOT = SCRIPT_DIR
+DATA_DIR = PACKAGE_ROOT
+DOCS_DIR = PACKAGE_ROOT
+SPLITS_DIR = PACKAGE_ROOT
+CHAMFER = DATA_DIR / "chamfer_metrics.csv"
+MANIFEST = SPLITS_DIR / "manifest.json"
+OUT = DOCS_DIR / "geometry_split_examples.png"
+LOW_COLOR = np.array([47, 111, 176], dtype=np.float32) / 255.0
+HIGH_COLOR = np.array([200, 92, 46], dtype=np.float32) / 255.0
+BACKGROUND = np.array([1.0, 1.0, 1.0], dtype=np.float32)
+
+
+def _load_scores() -> dict[int, float]:
+    rows = csv.DictReader(CHAMFER.open(encoding="utf-8"))
+    return {int(row["run"]): float(row["ood_score"]) for row in rows}
+
+
+def _ids(manifest: dict[str, list[str]], key: str) -> set[int]:
+    return {run_id(cid) for cid in manifest[key]}
+
+
+def _example_runs() -> tuple[tuple[int, float], tuple[int, float]]:
+    scores = _load_scores()
+    manifest = json.loads(MANIFEST.read_text(encoding="utf-8"))
+    train_ids = _ids(manifest, "geometry_train")
+    test_ids = _ids(manifest, "geometry_test")
+    low_run = min(train_ids, key=lambda rid: scores[rid])
+    high_run = max(test_ids, key=lambda rid: scores[rid])
+    return (low_run, scores[low_run]), (high_run, scores[high_run])
+
+
+def _surface_side_path(run: int) -> Path | None:
+    image_dir = _run_image_dir(run)
+    if image_dir is None:
+        return None
+    path = image_dir / f"fig_run{run}_SRS_surf-ySide_grid.png"
+    return path if path.exists() else None
+
+
+def _read_png_rgb(path: Path) -> np.ndarray | None:
+    if path.name.startswith("._"):
+        return None
+    try:
+        with path.open("rb") as f:
+            if f.read(8) != b"\x89PNG\r\n\x1a\n":
+                return None
+        with Image.open(path) as img:
+            img = img.convert("RGB")
+            arr = np.asarray(img, dtype=np.uint8)
+    except Exception:
+        return None
+
+    return arr
+
+
+def _foreground_mask(arr: np.ndarray) -> np.ndarray:
+    return np.any(arr < 245, axis=2)
+
+
+def _shared_crop_bbox(arrays: list[np.ndarray]) -> tuple[int, int, int, int]:
+    masks = [_foreground_mask(arr) for arr in arrays]
+    combined = np.logical_or.reduce(masks)
+    h, w = combined.shape
+
+    # Use dense rows/columns so tiny annotations do not define the crop, then
+    # fall back to all foreground pixels if an unusual source image is sparse.
+    min_col_pixels = max(8, int(0.02 * h))
+    min_row_pixels = max(16, int(0.035 * w))
+    xs = np.where(combined.sum(axis=0) >= min_col_pixels)[0]
+    ys = np.where(combined.sum(axis=1) >= min_row_pixels)[0]
+    if len(xs) == 0 or len(ys) == 0:
+        ys, xs = np.where(combined)
+    if len(xs) == 0 or len(ys) == 0:
+        return (0, h, 0, w)
+
+    pad_x = int(0.03 * w)
+    pad_y = int(0.06 * h)
+    left = max(0, xs.min() - pad_x)
+    right = min(w, xs.max() + pad_x + 1)
+    top = max(0, ys.min() - pad_y)
+    bottom = min(h, ys.max() + pad_y + 1)
+    return (top, bottom, left, right)
+
+
+def _crop(arr: np.ndarray, bbox: tuple[int, int, int, int]) -> np.ndarray:
+    top, bottom, left, right = bbox
+    return arr[top:bottom, left:right].astype(np.float32) / 255.0
+
+
+def _example_image(run: int) -> tuple[np.ndarray | None, str]:
+    path = _surface_side_path(run)
+    if path is None:
+        return None, "source complete-car PNG not found"
+    arr = _read_png_rgb(path)
+    if arr is None:
+        return None, "source complete-car PNG could not be read"
+    return arr, path.name
+
+
+def _transparent_overlay(low_arr: np.ndarray, high_arr: np.ndarray) -> np.ndarray:
+    low_mask = _foreground_mask((low_arr * 255.0).astype(np.uint8))
+    high_mask = _foreground_mask((high_arr * 255.0).astype(np.uint8))
+    canvas = np.ones(low_arr.shape, dtype=np.float32) * BACKGROUND
+
+    alpha = 0.62
+    canvas[low_mask] = (1.0 - alpha) * canvas[low_mask] + alpha * LOW_COLOR
+    canvas[high_mask] = (1.0 - alpha) * canvas[high_mask] + alpha * HIGH_COLOR
+    return np.clip(canvas, 0.0, 1.0)
+
+
+def _plot_placeholder(ax: plt.Axes, title: str, run: int, score: float, filename: str) -> None:
+    ax.set_facecolor("#f5f7fa")
+    ax.text(
+        0.5,
+        0.5,
+        f"run_{run}\nChamfer score={score:.6f}\n{filename}",
+        ha="center",
+        va="center",
+        fontsize=10,
+        color="#1f2933",
+        transform=ax.transAxes,
+    )
+    ax.set_title(title, fontsize=10)
+
+
+def _finish_axis(ax: plt.Axes, xlabel: str = "") -> None:
+    ax.set_xlabel(xlabel, fontsize=7)
+    ax.set_xticks([])
+    ax.set_yticks([])
+    for spine in ax.spines.values():
+        spine.set_visible(False)
+
+
+def main() -> None:
+    low_example, high_example = _example_runs()
+    examples = [
+        ("Training-side low geometry score", *low_example),
+        ("Transparent overlay", None, None),
+        ("Geometry-test high geometry score", *high_example),
+    ]
+
+    low_arr, low_filename = _example_image(low_example[0])
+    high_arr, high_filename = _example_image(high_example[0])
+    fig = plt.figure(figsize=(11.5, 6.6), constrained_layout=True)
+    grid = fig.add_gridspec(2, 2, height_ratios=[1.0, 1.18])
+    low_ax = fig.add_subplot(grid[0, 0])
+    high_ax = fig.add_subplot(grid[0, 1])
+    overlay_ax = fig.add_subplot(grid[1, :])
+
+    if low_arr is not None and high_arr is not None:
+        bbox = _shared_crop_bbox([low_arr, high_arr])
+        low_crop = _crop(low_arr, bbox)
+        high_crop = _crop(high_arr, bbox)
+        overlay = _transparent_overlay(low_crop, high_crop)
+
+        low_ax.imshow(low_crop)
+        low_ax.set_title(
+            f"{examples[0][0]}\nrun_{low_example[0]}, Chamfer score={low_example[1]:.6f}",
+            fontsize=10,
+        )
+        _finish_axis(low_ax, low_filename)
+
+        high_ax.imshow(high_crop)
+        high_ax.set_title(
+            f"{examples[2][0]}\nrun_{high_example[0]}, Chamfer score={high_example[1]:.6f}",
+            fontsize=10,
+        )
+        _finish_axis(high_ax, high_filename)
+
+        overlay_ax.imshow(overlay)
+        overlay_ax.set_title(
+            "Transparent overlay\nblue=train-side low, orange=geometry-test high",
+            fontsize=10,
+        )
+        _finish_axis(overlay_ax, "same crop and camera")
+    else:
+        for ax, (title, run, score), arr, filename in [
+            (low_ax, examples[0], low_arr, low_filename),
+            (high_ax, examples[2], high_arr, high_filename),
+        ]:
+            if arr is None:
+                _plot_placeholder(ax, title, run, score, filename)
+            else:
+                ax.imshow(arr.astype(np.float32) / 255.0)
+                ax.set_title(f"{title}\nrun_{run}, Chamfer score={score:.6f}", fontsize=10)
+            _finish_axis(ax, filename)
+        overlay_ax.set_facecolor("#f5f7fa")
+        overlay_ax.text(
+            0.5,
+            0.5,
+            "Overlay unavailable\nboth source PNGs are required",
+            ha="center",
+            va="center",
+            fontsize=10,
+            color="#1f2933",
+            transform=overlay_ax.transAxes,
+        )
+        overlay_ax.set_title(examples[1][0], fontsize=10)
+        _finish_axis(overlay_ax, "")
+
+    fig.suptitle("Geometry split examples: complete-car surface views and overlay", fontsize=13)
+    DOCS_DIR.mkdir(parents=True, exist_ok=True)
+    fig.savefig(OUT, dpi=180)
+    print(f"Wrote {OUT}")
+
+
+if __name__ == "__main__":
+    main()

splits/visualize_image_regimes.py

@@ -0,0 +1,143 @@
+"""Visualize image-inspired DrivAerML flow-regime splits.
+
+Creates image_regimes.png from splits/image_metrics.csv,
+splits/manifest.json, and
+force_mom_all.csv.
+"""
+
+from __future__ import annotations
+
+import csv
+import json
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from generate_splits import load_force_mom, run_id
+
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+PACKAGE_ROOT = SCRIPT_DIR
+DATA_DIR = PACKAGE_ROOT
+DOCS_DIR = PACKAGE_ROOT
+SPLITS_DIR = PACKAGE_ROOT
+MANIFEST = SPLITS_DIR / "manifest.json"
+METRICS = DATA_DIR / "image_metrics.csv"
+OUT = DOCS_DIR / "image_regimes.png"
+
+
+def _ids(manifest: dict[str, list[str]], key: str) -> set[int]:
+    return {run_id(cid) for cid in manifest[key]}
+
+
+def _load_metrics() -> dict[str, dict[int, float | bool]]:
+    rows = list(csv.DictReader(METRICS.open(encoding="utf-8")))
+    result: dict[str, dict[int, float | bool]] = {}
+    for row in rows:
+        rid = int(row["run"])
+        result.setdefault("run", {})[rid] = rid
+        for key, value in row.items():
+            if key == "run":
+                continue
+            if key.endswith("_observed"):
+                result.setdefault(key, {})[rid] = value == "true"
+            else:
+                result.setdefault(key, {})[rid] = float(value)
+    return result
+
+
+def _arrays(values: dict[int, float | bool]) -> tuple[np.ndarray, np.ndarray]:
+    runs = np.asarray(sorted(values))
+    arr = np.asarray([values[int(r)] for r in runs])
+    return runs, arr
+
+
+def _plot_partitioned(
+    ax,
+    runs: np.ndarray,
+    x: np.ndarray,
+    y: np.ndarray,
+    train_ids: set[int],
+    val_ids: set[int],
+    test_ids: set[int],
+    *,
+    title: str,
+    xlabel: str,
+    ylabel: str,
+) -> None:
+    train = np.asarray([int(r) in train_ids for r in runs])
+    val = np.asarray([int(r) in val_ids for r in runs])
+    test = np.asarray([int(r) in test_ids for r in runs])
+    ax.scatter(x[train], y[train], s=22, color="#aeb7c2", linewidth=0, alpha=0.62, label="train")
+    ax.scatter(x[val], y[val], s=30, color="#c28f22", linewidth=0, alpha=0.95, label="val")
+    ax.scatter(x[test], y[test], s=30, color="#2f8f61", linewidth=0, alpha=0.95, label="test")
+    ax.set_title(title)
+    ax.set_xlabel(xlabel)
+    ax.set_ylabel(ylabel)
+    ax.grid(True, color="#e1e6eb", lw=0.7)
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+
+
+def main() -> None:
+    manifest = json.loads(MANIFEST.read_text(encoding="utf-8"))
+    metrics = _load_metrics()
+    records, force_source = load_force_mom()
+    if force_source == "deterministic_proxy_missing_force_mom_all_csv":
+        raise SystemExit(
+            "force_mom_all.csv is required for image_regimes.png. "
+            "Run after `python3 splits/download_hf_inputs.py --output-dir data`, "
+            "or set DRIVAERML_DATA_ROOT to a directory containing it."
+        )
+    runs, _ = _arrays(metrics["run"])
+    cd = np.asarray([records[int(r)]["cd"] for r in runs], dtype=float)
+
+    def score(name: str) -> tuple[np.ndarray, np.ndarray]:
+        _, y = _arrays(metrics[f"{name}_score"])
+        _, observed = _arrays(metrics[f"{name}_observed"])
+        return y.astype(float), observed.astype(bool)
+
+    fig, axes = plt.subplots(1, 2, figsize=(10.8, 3.9), constrained_layout=True)
+
+    y, _obs = score("rear_separation")
+    train_ids = _ids(manifest, "rear_separation_train")
+    val_ids = _ids(manifest, "rear_separation_val")
+    test_ids = _ids(manifest, "rear_separation_test")
+    _plot_partitioned(
+        axes[0],
+        runs,
+        runs,
+        y,
+        train_ids,
+        val_ids,
+        test_ids,
+        title="Rear-separation split score",
+        xlabel="run",
+        ylabel="rear_separation score",
+    )
+    _plot_partitioned(
+        axes[1],
+        runs,
+        runs,
+        cd,
+        train_ids,
+        val_ids,
+        test_ids,
+        title="Rear-separation split on Cd",
+        xlabel="run",
+        ylabel="Cd",
+    )
+    legend = axes[0].legend(frameon=True, loc="lower left")
+    legend.get_frame().set_facecolor("white")
+    legend.get_frame().set_edgecolor("none")
+    legend.get_frame().set_alpha(0.78)
+
+    fig.suptitle("DrivAerML image-derived flow-regime split diagnostics", fontsize=12)
+    DOCS_DIR.mkdir(parents=True, exist_ok=True)
+    fig.savefig(OUT, dpi=180)
+    print(f"Wrote {OUT}")
+
+
+if __name__ == "__main__":
+    main()

splits/visualize_split_examples.py

@@ -0,0 +1,115 @@
+"""Build illustrative high/low image examples for the split report."""
+
+from __future__ import annotations
+
+import csv
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+from PIL import Image
+
+from generate_splits import _run_image_dir
+
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+PACKAGE_ROOT = SCRIPT_DIR
+DATA_DIR = PACKAGE_ROOT
+DOCS_DIR = PACKAGE_ROOT
+METRICS = DATA_DIR / "image_metrics.csv"
+OUT = DOCS_DIR / "image_split_examples.png"
+
+EXAMPLES = [
+    ("rear_separation", "centreline", "Rear separation"),
+]
+
+
+def _observed_rows(metric: str) -> list[dict[str, str]]:
+    rows = list(csv.DictReader(METRICS.open(encoding="utf-8")))
+    return [row for row in rows if row[f"{metric}_observed"] == "true"]
+
+
+def _example_run(metric: str, high: bool) -> tuple[int, float]:
+    rows = _observed_rows(metric)
+    key = lambda row: float(row[f"{metric}_score"])
+    row = max(rows, key=key) if high else min(rows, key=key)
+    return int(row["run"]), float(row[f"{metric}_score"])
+
+
+def _centreline_paths(run: int) -> list[Path]:
+    image_dir = _run_image_dir(run)
+    if image_dir is None:
+        return []
+    prefix = f"fig_run{run}_SRS"
+    return [
+        image_dir / f"{prefix}_magUMeanNormTrim_yNormal-2_yNormal_p00000.png",
+        image_dir / f"{prefix}_CptMeanTrim_yNormal-2_yNormal_p00000.png",
+        image_dir / f"{prefix}_CpMeanTrim_yNormal-2_yNormal_p00000.png",
+    ]
+
+
+def _display_png_array(path: Path) -> np.ndarray | None:
+    if not path.exists() or path.name.startswith("._"):
+        return None
+    try:
+        with path.open("rb") as f:
+            if f.read(8) != b"\x89PNG\r\n\x1a\n":
+                return None
+        with Image.open(path) as img:
+            img = img.convert("RGB")
+            width, height = img.size
+            # Keep the full centreline field and colorbar, trimming only the
+            # mostly empty lower margin from the exported ParaView image.
+            img = img.crop((0, 0, width, int(height * 0.91)))
+            return np.asarray(img, dtype=np.float32) / 255.0
+    except Exception:
+        return None
+
+
+def _first_image(run: int, kind: str):
+    paths = _centreline_paths(run) if kind == "centreline" else []
+    for path in paths:
+        arr = _display_png_array(path)
+        if arr is not None:
+            return arr, path.name
+    return None, "source PNG not found"
+
+
+def main() -> None:
+    fig, axes = plt.subplots(len(EXAMPLES), 2, figsize=(11.5, 4.2), constrained_layout=True, squeeze=False)
+
+    for row_idx, (metric, kind, title) in enumerate(EXAMPLES):
+        for col_idx, high in enumerate([False, True]):
+            run, score = _example_run(metric, high)
+            arr, filename = _first_image(run, kind)
+            ax = axes[row_idx, col_idx]
+            if arr is None:
+                ax.set_facecolor("#f5f7fa")
+                ax.text(
+                    0.5,
+                    0.5,
+                    f"run_{run}\nscore={score:.3f}\n{filename}",
+                    ha="center",
+                    va="center",
+                    fontsize=11,
+                    color="#1f2933",
+                    transform=ax.transAxes,
+                )
+            else:
+                ax.imshow(arr)
+            ax.set_xticks([])
+            ax.set_yticks([])
+            label = "high" if high else "low"
+            ax.set_title(f"{title}: {label} score\ncentreline y=0, run_{run}, score={score:.3f}", fontsize=10)
+            ax.set_xlabel(filename, fontsize=7)
+            for spine in ax.spines.values():
+                spine.set_visible(False)
+
+    fig.suptitle("Image-derived split examples: centreline low vs. high observed-score cases", fontsize=13)
+    DOCS_DIR.mkdir(parents=True, exist_ok=True)
+    fig.savefig(OUT, dpi=180)
+    print(f"Wrote {OUT}")
+
+
+if __name__ == "__main__":
+    main()