Add deterministic benchmark splits

.gitattributes

@@ -1116,3 +1116,4 @@ run_20/boundary_20.vtu filter=lfs diff=lfs merge=lfs -text
 run_82/boundary_82.vtu filter=lfs diff=lfs merge=lfs -text
 run_82/volume_82.vtu filter=lfs diff=lfs merge=lfs -text
 run_82/windsor_82.stl filter=lfs diff=lfs merge=lfs -text
+splits/README.pdf filter=lfs diff=lfs merge=lfs -text

README.md

@@ -48,6 +48,49 @@ Each folder (e.g run_1,run_2…run_“i” etc) corresponds to a different geome
 * force_mom_all.csv: contains force/moments for all runs in a single file
 * force_mom_varref_all.csv: contains force/moments for all runs in a single file using a reference frontal area that is unique to each geometry
 * geo_parameters_all.csv: contains all the geometry parameters for all the runs in a single file
+* [`splits/`](splits/): deterministic benchmark manifests, methods documentation, derived metrics, diagnostic figures, and generation code
+
+## Recommended dataset splits
+
+WindsorML provides eight deterministic train/validation/test split families in
+[`splits/manifest.json`](splits/manifest.json). Identifiers follow the
+`run_N` convention used by the dataset.
+
+| Split | Type | Train | Validation | Test | Intended evaluation |
+|---|---:|---:|---:|---:|---|
+| `full` | In-distribution | 284 | 35 | 36 | Seed-42 random baseline, approximately 80/10/10 |
+| `medium` | In-distribution | 95 | 35 | 36 | Intermediate data efficiency |
+| `scarce` | In-distribution | 47 | 35 | 36 | Low-data evaluation |
+| `super_scarce` | In-distribution | 8 | 35 | 36 | Extreme low-data evaluation |
+| `geometry` | OOD | 248 | 36 | 71 | STL-surface geometry extrapolation |
+| `high_drag` | OOD | 248 | 36 | 71 | High-drag extrapolation |
+| `low_drag` | OOD | 248 | 36 | 71 | Low-drag extrapolation |
+| `image_wake` | OOD | 248 | 36 | 71 | Image-derived wake extrapolation |
+
+The `full` family is a reproducible seed-42 benchmark. It is not a
+reconstruction of the paper's preliminary 60/20/20 evaluation partition,
+whose case membership was not published. The reduced-data training sets are
+strictly nested and share the same validation and test cases. For the OOD
+families, validation is selected from the training-side population.
+
+The aggregate tables and manifest cover `run_0` through `run_354`. At the
+source revision used for this package, per-run STL and image files for
+`run_350` through `run_354` were unavailable. Their geometry and image-wake
+scores are estimated from nearby observed cases and are explicitly identified
+in the distributed metric CSVs.
+
+Download only the split package with:
+
+```bash
+hf download neashton/windsorml \
+  --type dataset \
+  --include "splits/**" \
+  --local-dir ./windsorml
+```
+
+Complete definitions, construction methods, missing-data treatment,
+diagnostic figures, and reproducibility instructions are provided in
+[`splits/README.md`](splits/README.md).
 
 Downloads: 
 -----------
@@ -58,12 +101,15 @@ Example 1: Download all files (~8TB)
 -------
 Please note you’ll need to have git lfs installed first, then you can run the following command:
 
+```
 git clone git@hf.co:datasets/neashton/windsorml
+```
 
 Example 2: only download select files (STL,images & force and moments):
 -------
 Create the following bash script that could be adapted to loop through only select runs or to change to download different files e.g boundary/volume.
 
+```bash
 #!/bin/bash
 
 # Set the path and prefix
@@ -76,8 +122,8 @@ LOCAL_DIR="./windsor_data"
 # Create the local directory if it doesn't exist
 mkdir -p "$LOCAL_DIR"
 
-# Loop through the run folders from 1 to 354
-for i in $(seq 1 354); do
+# The currently available per-run folders span 0 to 349.
+for i in $(seq 0 349); do
     RUN_DIR="run_$i"
     RUN_LOCAL_DIR="$LOCAL_DIR/$RUN_DIR"
 
@@ -91,6 +137,7 @@ for i in $(seq 1 354); do
     wget "https://huggingface.co/datasets/${HF_OWNER}/${HF_PREFIX}/resolve/main/$RUN_DIR/force_mom_$i.csv" -O "$RUN_LOCAL_DIR/force_mom_$i.csv"
 
 done
+```
 
 Acknowledgements
 -----------
@@ -104,4 +151,6 @@ License
 ----
 This dataset is provided under the CC BY SA 4.0 license, please see LICENSE.txt for full license text.
 
-
+version history:
+---------------
+* 17/08/2026 - Added deterministic benchmark train/validation/test splits, including nested data-efficiency and out-of-distribution evaluation protocols; documented current per-run asset coverage.

splits/README.md

@@ -0,0 +1,238 @@
+# WindsorML dataset splits
+
+This directory provides deterministic train/validation/test assignments for the
+[WindsorML](https://huggingface.co/datasets/neashton/windsorml) dataset. The
+authoritative assignments are stored in [`manifest.json`](manifest.json) as a
+flat JSON object. Keys follow the pattern `{split_name}_{train,val,test}`, and
+each value is a numerically sorted list of identifiers matching the top-level
+`run_N` convention.
+
+The aggregate WindsorML tables describe 355 Windsor-body variants, indexed from
+`run_0` through `run_354`. At the source revision used to construct this
+package, per-run STL and image assets were available for `run_0` through
+`run_349`; the treatment of the five remaining cases is documented below.
+
+## Splits at a glance
+
+| Split | Type | Train | Validation | Test | Intended evaluation |
+|---|---:|---:|---:|---:|---|
+| `full` | In-distribution | 284 | 35 | 36 | Seed-42 random baseline, approximately 80/10/10 |
+| `medium` | In-distribution | 95 | 35 | 36 | Intermediate data efficiency |
+| `scarce` | In-distribution | 47 | 35 | 36 | Low-data evaluation |
+| `super_scarce` | In-distribution | 8 | 35 | 36 | Extreme low-data evaluation |
+| `geometry` | OOD | 248 | 36 | 71 | STL-surface geometry extrapolation |
+| `high_drag` | OOD | 248 | 36 | 71 | High-drag extrapolation |
+| `low_drag` | OOD | 248 | 36 | 71 | Low-drag extrapolation |
+| `image_wake` | OOD | 248 | 36 | 71 | Image-derived wake 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 assignments. For every
+out-of-distribution (OOD) family, validation is sampled from the training-side
+population; the held-out extreme is reserved for final testing.
+
+## Relation to the paper split
+
+The WindsorML paper reports a 60/20/20 partition for its preliminary machine-
+learning evaluation but does not publish the case-membership lists. The `full`
+family here is therefore a separate, reproducible seed-42 benchmark with an
+approximately 80/10/10 ratio. It should not be described as a reconstruction of
+the paper's preliminary partition.
+
+## Using the committed manifest
+
+Normal benchmark use requires only the committed manifest. Regenerating the
+splits 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 `image_wake` to select another
+family.
+
+Download only the split package with:
+
+```bash
+hf download neashton/windsorml \
+  --type dataset \
+  --include "splits/**" \
+  --local-dir ./windsorml
+```
+
+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 repeated visual inspection during development.
+
+## Construction principles
+
+1. **Reproducible baseline.** The `full` family is a committed seed-42 random
+   assignment over all 355 identifiers.
+2. **In-distribution validation.** OOD validation cases are selected from the
+   training-side population rather than the extreme test region.
+3. **Nested data-efficiency subsets.** Smaller training sets are strict
+   subsets of larger sets, with validation and test held fixed.
+4. **Direct geometry comparison.** The geometry OOD score is computed from STL
+   surfaces rather than inferred only from geometry parameters.
+5. **Dataset-defined physical quantities.** Drag families use the published
+   constant-reference-area force table.
+6. **Flow-structure information.** The image-wake family uses fixed velocity
+   views rather than an integrated coefficient.
+7. **Explicit missing-data treatment.** Observed and estimated metric values
+   are identified in the distributed CSVs.
+8. **Auditability.** The manifest is distributed with the derived metrics,
+   scripts, figures, LaTeX source, and PDF methods report used to document it.
+
+## Split definitions
+
+### `full`
+
+The baseline constructs `torch.randperm(355)` with seed 42, assigns the first
+284 entries to training, the next 35 to validation, and the final 36 to testing,
+then sorts each stored list numerically. The identifiers are committed directly
+in the generator, so PyTorch is not a runtime dependency.
+
+### `medium`, `scarce`, and `super_scarce`
+
+These families retain `full_val` and `full_test` while reducing the training
+population to 95, 47, and 8 cases. A greedy max-min procedure constructs one
+nested ordering in standardized force/geometry feature space using `cd`, `cl`,
+and the columns present in the aggregate geometry table.
+
+The paper defines seven CAD variables. The current root-level
+`geo_parameters_all.csv` contains six of those variables plus `frontal_area`;
+`ratio_length_front_rear` is present in per-run geometry CSVs but absent from
+the aggregate table. The nested selection uses the aggregate columns actually
+available. The STL-based geometry OOD family is independent of this omission.
+
+### `geometry`
+
+The geometry family uses [`chamfer_metrics.csv`](chamfer_metrics.csv). Each
+available `run_N/windsor_N.stl` surface is sampled with 4,096 deterministic
+area-weighted points. Point clouds remain in the shared dataset coordinate
+frame and are scaled by the global median STL bounding-box diagonal. Pairwise
+surface difference is measured with symmetric Chamfer RMS distance.
+
+For each run, the OOD score is the mean distance to its ten nearest neighbouring
+geometries. The 71 highest-scoring cases form `geometry_test`; 36 validation
+cases are deterministically selected from the complementary population, leaving
+248 training cases.
+
+### `high_drag` and `low_drag`
+
+These families rank all cases by `cd` from the root-level `force_mom_all.csv`,
+whose constant reference area makes the coefficients directly comparable.
+`high_drag` holds out the largest 71 values, while `low_drag` holds out the
+smallest 71. Validation is sampled from the complementary population in both
+cases.
+
+### `image_wake`
+
+The image-wake score uses two near-centreline constant-z velocity images and
+three near-base constant-x images for each observed run. A fixed wake crop and
+colour/intensity measure estimate the low-speed area in each view. The 71
+largest scores form `image_wake_test`.
+
+![Split diagnostics](split_diagnostics.png)
+
+![Geometry-score examples](geometry_score_examples.png)
+
+![Image-wake-score examples](wake_score_examples.png)
+
+## Current per-run asset coverage
+
+At WindsorML revision `bb721834e681a9a8329c42288c1514d6ce617547`, the
+aggregate force and geometry tables contain all 355 identifiers, but the
+per-run STL and targeted PNG files for `run_350` through `run_354` are absent.
+Their geometry and image-wake scores are estimated from the five nearest
+observed runs in standardized force/aggregate-geometry space.
+
+[`chamfer_metrics.csv`](chamfer_metrics.csv) and
+[`image_metrics.csv`](image_metrics.csv) record an observed flag and the
+neighbour identifiers used for every estimate. They contain 350 direct
+observations and five estimated rows each. The committed manifest is the
+versioned benchmark assignment; future metric revisions should be released
+explicitly rather than silently changing this manifest.
+
+## Reproducibility
+
+The committed [`manifest.json`](manifest.json) is the source of truth. The
+commands below are provided to audit or rebuild the artifacts. They were
+prepared against the WindsorML revision given above.
+
+Install the lightweight generation and plotting dependencies:
+
+```bash
+python3 -m pip install numpy matplotlib pillow
+```
+
+From the dataset repository root, download the aggregate source tables and
+regenerate the manifest and diagnostic plot:
+
+```bash
+python3 splits/download_hf_inputs.py --output-dir data
+python3 splits/generate_splits.py
+python3 splits/visualize_splits.py
+```
+
+The commands above use the committed Chamfer and image metrics. To recompute
+those metrics and recreate the example figures, keep large STL and PNG inputs
+outside the repository:
+
+```bash
+ASSET_ROOT=../windsorml_hf_assets
+
+python3 splits/download_hf_inputs.py --output-dir "$ASSET_ROOT" \
+  --include-stls --include-wake-images --include-geometry-images \
+  --workers 6 --allow-missing
+
+python3 splits/compute_chamfer_splits.py --data-root "$ASSET_ROOT" \
+  --output-dir /tmp/windsorml_chamfer_4096 --samples 4096 \
+  --workers 16 --sample-workers 2 --runs all --allow-missing
+
+cp /tmp/windsorml_chamfer_4096/chamfer_metrics.csv \
+  splits/chamfer_metrics.csv
+
+python3 splits/compute_image_metrics.py --asset-root "$ASSET_ROOT" \
+  --data-root "$ASSET_ROOT" --output splits/image_metrics.csv
+
+WINDSORML_DATA_ROOT="$ASSET_ROOT" python3 splits/generate_splits.py
+WINDSORML_DATA_ROOT="$ASSET_ROOT" python3 splits/visualize_splits.py
+python3 splits/create_example_figures.py --asset-root "$ASSET_ROOT" \
+  --force-root "$ASSET_ROOT"
+```
+
+Full Chamfer recomputation additionally requires SciPy and trimesh:
+
+```bash
+python3 -m pip install scipy trimesh
+```
+
+Rebuild the PDF methods report with:
+
+```bash
+latexmk -pdf -cd splits/README.tex
+```
+
+The generated manifest remains a flat mapping such as:
+
+```json
+{
+  "full_train": ["run_0", "run_1"],
+  "full_val": ["run_8"],
+  "full_test": ["run_7"]
+}
+```
+
+The shortened lists above illustrate the format only; use the committed
+manifest for the complete assignments.

splits/README.pdf

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

splits/README.tex

@@ -0,0 +1,302 @@
+\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{WindsorML Dataset Splits}}
+\author{}
+\date{}
+
+\begin{document}
+\maketitle
+\vspace{-2.0em}
+
+Deterministic train/validation/test splits for the
+\href{https://huggingface.co/datasets/neashton/windsorml}{WindsorML dataset}
+\cite{windsorml_dataset}. WindsorML contains 355 Halton-sampled variants of the
+Windsor body, indexed from \code{run\_0} through \code{run\_354}. The associated
+paper reports a 60/20/20 partition for its preliminary ML evaluation but does
+not publish an exact case-membership list \cite{windsorml_paper}. For consistency
+with the AhmedML and DrivAerML split packages, this package instead defines an
+approximately 80/10/10 seed-42 baseline and companion data-efficiency and
+out-of-distribution (OOD) splits.
+
+The source of truth is \code{splits/manifest.json}, a flat JSON object with keys
+such as \code{full\_train}, \code{full\_val}, and \code{geometry\_test}. This
+split directory stores the manifest, derived metrics, scripts, figures, and
+this report. The aggregate source tables remain at the dataset root. Large STL
+and PNG reconstruction inputs belong in a sibling asset directory.
+
+\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 & 284 & 35 & 36 & Seed-42 random baseline, approximately 80/10/10 \\
+\splitkey{medium} & In-dist & 95 & 35 & 36 & Data efficiency, 1/3 of \splitkey{full} training data \\
+\splitkey{scarce} & In-dist & 47 & 35 & 36 & Data efficiency, 1/6 of \splitkey{full} training data \\
+\splitkey{super\_scarce} & In-dist & 8 & 35 & 36 & Extreme data efficiency, 1/36 of \splitkey{full} training data \\
+\splitkey{geometry} & OOD & 248 & 36 & 71 & STL-shape extrapolation using the top 20\% local Chamfer-isolation score \\
+\splitkey{high\_drag} & OOD & 248 & 36 & 71 & High-drag extrapolation using the top 20\% fixed-reference \code{cd} \\
+\splitkey{low\_drag} & OOD & 248 & 36 & 71 & Low-drag extrapolation using the bottom 20\% fixed-reference \code{cd} \\
+\splitkey{image\_wake} & OOD & 248 & 36 & 71 & Low-speed wake extrapolation from near-centreline and near-base velocity PNGs \\
+\bottomrule
+\end{tabularx}
+
+\section*{Which split should I use?}
+
+\begin{itemize}
+  \item \textbf{Standard baseline}: \splitkey{full}
+  \item \textbf{Data efficiency}: compare \splitkey{super\_scarce}, \splitkey{scarce}, \splitkey{medium}, and \splitkey{full}
+  \item \textbf{Shape extrapolation}: \splitkey{geometry}
+  \item \textbf{Aerodynamic-coefficient extrapolation}: \splitkey{high\_drag} or \splitkey{low\_drag}
+  \item \textbf{Wake-regime extrapolation}: \splitkey{image\_wake}
+\end{itemize}
+
+\section*{Using the committed splits}
+
+For the standard use case, read \code{splits/manifest.json}; no STL, PNG, or
+regeneration step is required. Each value is a sorted list of dataset directory
+names.
+
+\begin{verbatim}
+import json
+from pathlib import Path
+
+manifest = json.loads(Path("splits/manifest.json").read_text())
+
+train_ids = manifest["full_train"]
+val_ids = manifest["full_val"]
+test_ids = manifest["full_test"]
+\end{verbatim}
+
+Change the \code{full} prefix to \code{medium}, \code{scarce},
+\code{super\_scarce}, \code{geometry}, \code{high\_drag}, \code{low\_drag}, or
+\code{image\_wake} to select another split.
+
+\section*{Design principles}
+
+\begin{itemize}
+  \item \textbf{Validation remains in-distribution with training.} For each OOD split, the test set is the held-out extreme 20\%; validation is the companion-package 10\% sample drawn only from the complementary population.
+  \item \textbf{Companion-package ratios.} \splitkey{full} is approximately 80/10/10. OOD families are approximately 70/10/20 so the extreme test regime remains large enough to evaluate separately.
+  \item \textbf{Nested data-efficiency subsets.} The 8-case, 47-case, and 95-case training sets are strict nested subsets of \splitkey{full\_train}; all share \splitkey{full\_val} and \splitkey{full\_test}.
+  \item \textbf{Use the appropriate source quantity.} Drag splits use the constant-reference-area coefficients in \code{force\_mom\_all.csv}; geometry uses STL-surface Chamfer distance; image wake uses published streamwise-velocity PNGs.
+  \item \textbf{Test-set integrity.} Test cases should not be used for normalization fitting, hyperparameter tuning, model selection, or repeated visual inspection during development.
+\end{itemize}
+
+Figure~\ref{fig:diagnostics} shows the exact train, validation, and test
+membership against each split-defining quantity. The first panel confirms that
+\splitkey{full} is random with respect to drag; the high- and low-drag panels
+show the expected coefficient tails; the lower panels show the geometry and
+image-wake OOD regions.
+
+\begin{figure}[H]
+  \centering
+  \includegraphics[width=0.99\textwidth]{split_diagnostics.png}
+  \caption{WindsorML split diagnostics. Points are colored by train, validation, and test membership. The panels show the full seed-42 baseline on \code{Cd}; high- and low-drag holdouts on \code{Cd}; the STL-Chamfer geometry holdout; the image-wake holdout on its low-speed score; and the image-wake membership on \code{Cd}.}
+  \label{fig:diagnostics}
+\end{figure}
+
+\section*{Split details}
+
+\subsection*{\splitkey{full}}
+
+To match the AhmedML and DrivAerML split convention, \splitkey{full} uses an
+approximately 80/10/10 partition: 284 train, 35 validation, and 36 test cases.
+To make the unpublished membership reproducible, this repository constructs
+\code{torch.randperm(355)} with \code{torch.Generator().manual\_seed(42)}, assigns
+the first 284 entries to train, the next 35 to validation, and the final 36 to
+test, then sorts each stored ID list. The resulting IDs are committed directly
+in the generator, so PyTorch is not a runtime dependency.
+
+\subsection*{\splitkey{medium}, \splitkey{scarce}, and \splitkey{super\_scarce}}
+
+These families keep \splitkey{full\_val} and \splitkey{full\_test} fixed. Their
+training sets are nested, greedy max-min subsets of \splitkey{full\_train} in
+standardized \code{cd}, \code{cl}, and published aggregate geometry-feature
+space. The procedure selects a force/geometry-extreme case first, then repeatedly
+adds the candidate whose nearest selected neighbor is farthest away.
+
+The WindsorML paper defines seven CAD variables: front-to-rear length ratio,
+back-fast length ratio, nose-to-windshield height ratio, fast-back height ratio,
+side taper, clearance, and bottom taper angle \cite{windsorml_paper}. The current
+public \code{geo\_parameters\_all.csv} contains six of those variables plus
+\code{frontal\_area}; \code{ratio\_length\_front\_rear} appears in per-run geometry
+CSVs but is absent from the aggregate table. The nested selection uses the
+columns actually present in the aggregate file. The \splitkey{geometry} OOD
+split does not depend on that table omission because it is computed from STLs.
+
+\subsection*{\splitkey{geometry}}
+
+Each available \code{run\_N/windsor\_N.stl} is sampled with 4096 deterministic,
+area-weighted surface points. Point clouds remain in the common dataset
+coordinate frame and are scaled by the global median STL bounding-box diagonal.
+The symmetric Chamfer RMS distance is calculated for every pair, and each run's
+OOD score is its mean distance to the 10 nearest neighboring STLs. The 71
+highest scores form \splitkey{geometry\_test}; 36 validation cases are sampled
+from the remaining population, leaving 248 training cases.
+
+The current highest observed geometry scores include \splitkey{run\_252},
+\splitkey{run\_161}, \splitkey{run\_349}, \splitkey{run\_72}, and
+\splitkey{run\_57}. Figure~\ref{fig:geometry_examples} compares the lowest and
+highest observed score examples and overlays the complete side-view geometry.
+
+\begin{figure}[H]
+  \centering
+  \includegraphics[width=0.98\textwidth]{geometry_score_examples.png}
+  \caption{Geometry examples for \splitkey{geometry}. The low-score case is \splitkey{run\_304} with Chamfer score 0.01147, \code{Cd}=0.2823, and \code{Cl}=-0.2293. The high-score case is \splitkey{run\_252} with score 0.02076, \code{Cd}=0.3408, and \code{Cl}=0.8068. The lower panel superimposes both complete-car side views with transparent silhouettes.}
+  \label{fig:geometry_examples}
+\end{figure}
+
+\subsection*{\splitkey{high\_drag} and \splitkey{low\_drag}}
+
+WindsorML publishes both constant-reference-area and case-dependent-reference-area
+force tables. These splits use \code{force\_mom\_all.csv}, whose constant reference
+area makes \code{cd} directly comparable across geometry variants.
+\splitkey{high\_drag} holds out the 71 largest values; \splitkey{low\_drag} holds
+out the 71 smallest. Figure~\ref{fig:diagnostics} shows both tails.
+
+The highest-drag runs include \splitkey{run\_303}, \splitkey{run\_192},
+\splitkey{run\_346}, \splitkey{run\_10}, and \splitkey{run\_221}. The lowest-drag
+runs include \splitkey{run\_238}, \splitkey{run\_125}, \splitkey{run\_306},
+\splitkey{run\_133}, and \splitkey{run\_134}.
+
+\subsection*{\splitkey{image\_wake}}
+
+The paper states that the published images span 10 constant-\(z\) planes from
+\(z=-0.4\) to \(0.4\) m and 80 constant-\(x\) planes from \(x=-0.5\) to
+\(1.0\) m \cite{windsorml_paper}. The image-wake score uses
+\code{view1\_constz} indices 4 and 5, which bracket the centreline, and
+\code{view2\_constx} indices 53, 55, and 57, immediately downstream of the
+Windsor base at \(x=0.48\) m. In fixed wake crops, blue/purple pixels indicate
+lower streamwise velocity than the orange freestream. The score averages the
+low-speed area and color intensity across the centreline and near-base views.
+The 71 largest scores form \splitkey{image\_wake\_test}.
+
+The highest observed image-wake scores include \splitkey{run\_8},
+\splitkey{run\_315}, \splitkey{run\_57}, \splitkey{run\_332}, and
+\splitkey{run\_329}. Figure~\ref{fig:wake_examples} shows why the score separates
+the selected examples: the high-score case has a substantially larger low-speed
+region in both views.
+
+\begin{figure}[H]
+  \centering
+  \includegraphics[width=0.99\textwidth]{wake_score_examples.png}
+  \caption{Image-wake examples for \splitkey{image\_wake}. The low-score case is \splitkey{run\_161} with score 0.0076, \code{Cd}=0.3226, and \code{Cl}=0.8371. The high-score case is \splitkey{run\_8} with score 0.1519, \code{Cd}=0.3059, and \code{Cl}=-0.2052. The top row shows a near-centreline constant-\(z\) view; the bottom row shows the near-base \code{X-53} plane.}
+  \label{fig:wake_examples}
+\end{figure}
+
+\section*{Current Hub asset coverage}
+
+The aggregate CSVs contain all 355 runs. At Hub revision
+\code{bb721834e681a9a8329c42288c1514d6ce617547}, per-run STLs and targeted
+PNGs were available for \code{run\_0} through
+\code{run\_349}; the same assets for \code{run\_350} through \code{run\_354}
+returned HTTP 404. Their five geometry and image scores are estimated from the
+five nearest observed runs in standardized force/aggregate-geometry space.
+Both \code{splits/chamfer\_metrics.csv} and
+\code{splits/image\_metrics.csv} include
+an observed flag and the neighbor IDs for every estimate. Re-running the metric
+scripts after those Hub files become available can produce a revised metric
+set, which should be released as an explicit benchmark revision rather than
+silently changing the committed manifest.
+
+\section*{Repeatability and transparency}
+
+The committed manifest is intended for normal benchmark use. The commands below
+are only for auditing or rebuilding the split definitions. Keep large files in
+a sibling directory:
+
+\begin{verbatim}
+ASSET_ROOT=../windsorml_hf_assets
+
+python3 splits/download_hf_inputs.py --output-dir "$ASSET_ROOT" \
+  --include-stls --include-wake-images --include-geometry-images \
+  --workers 6 --allow-missing
+
+python3 splits/compute_chamfer_splits.py --data-root "$ASSET_ROOT" \
+  --output-dir /tmp/windsorml_chamfer_4096 --samples 4096 \
+  --workers 16 --sample-workers 2 --runs all --allow-missing
+cp /tmp/windsorml_chamfer_4096/chamfer_metrics.csv \
+  splits/chamfer_metrics.csv
+
+python3 splits/compute_image_metrics.py --asset-root "$ASSET_ROOT" \
+  --data-root "$ASSET_ROOT" --output splits/image_metrics.csv
+WINDSORML_DATA_ROOT="$ASSET_ROOT" python3 splits/generate_splits.py
+WINDSORML_DATA_ROOT="$ASSET_ROOT" python3 splits/visualize_splits.py
+python3 splits/create_example_figures.py --asset-root "$ASSET_ROOT" \
+  --force-root "$ASSET_ROOT"
+latexmk -pdf -cd splits/README.tex
+\end{verbatim}
+
+The Chamfer script requires \code{numpy}, \code{scipy}, and \code{trimesh}; the
+image and figure scripts require \code{numpy}, \code{Pillow}, and
+\code{matplotlib}. Large reconstruction inputs should remain outside the
+repository; the split directory contains only lightweight derived artifacts.
+
+The committed source artifacts are:
+
+\begin{verbatim}
+force_mom_all.csv
+geo_parameters_all.csv
+splits/chamfer_metrics.csv
+splits/image_metrics.csv
+<asset-root>/run_*/windsor_*.stl
+<asset-root>/run_*/images/windsor_*.png
+<asset-root>/run_*/images/velocityxavg/*.png
+splits/split_diagnostics.png
+splits/geometry_score_examples.png
+splits/wake_score_examples.png
+splits/manifest.json
+\end{verbatim}
+
+\section*{Manifest format}
+
+\begin{verbatim}
+{
+    "full_train": ["run_0", "run_1", "..."],
+    "full_val": ["run_8", "..."],
+    "full_test": ["run_7", "..."],
+    "geometry_train": ["run_0", "..."]
+}
+\end{verbatim}
+
+Case IDs match the on-disk dataset directory names and are sorted numerically.
+
+{\small
+\begin{thebibliography}{9}
+\bibitem{windsorml_dataset}
+WindsorML dataset. \url{https://huggingface.co/datasets/neashton/windsorml}.
+
+\bibitem{windsorml_paper}
+Ashton, N. et al. ``WindsorML: High-Fidelity Computational Fluid Dynamics Dataset for Automotive Aerodynamics.'' \url{https://arxiv.org/abs/2407.19320}.
+\end{thebibliography}
+}
+
+\end{document}

splits/chamfer_metrics.csv

@@ -0,0 +1,356 @@
+run,geometry_observed,nearest_neighbor_chamfer,mean_10_nn_chamfer,mean_all_chamfer,medoid_chamfer,medoid_run,ood_score,imputation_neighbors
+0,True,0.011387518607079983,0.013262450695037842,0.04128580167889595,0.03824697807431221,115,0.013262450695037842,
+1,True,0.011009939946234226,0.013251036405563354,0.05647054687142372,0.052962712943553925,115,0.013251036405563354,
+2,True,0.010547779500484467,0.013195875100791454,0.03964688628911972,0.029308414086699486,115,0.013195875100791454,
+3,True,0.011509324423968792,0.012370792217552662,0.03359327092766762,0.012307984754443169,115,0.012370792217552662,
+4,True,0.010701311752200127,0.013436922803521156,0.05352438986301422,0.05592511221766472,115,0.013436922803521156,
+5,True,0.01154999528080225,0.014133569784462452,0.04039603844285011,0.029157301411032677,115,0.014133569784462452,
+6,True,0.011555272154510021,0.01279392559081316,0.034877147525548935,0.015376703813672066,115,0.01279392559081316,
+7,True,0.011886964552104473,0.012538546696305275,0.043491609394550323,0.04243140295147896,115,0.012538546696305275,
+8,True,0.011150975711643696,0.013016683049499989,0.05060537904500961,0.05194465070962906,115,0.013016683049499989,
+9,True,0.01245274767279625,0.013386750593781471,0.04151185229420662,0.034206323325634,115,0.013386750593781471,
+10,True,0.010149999521672726,0.014017825946211815,0.04578939452767372,0.04009588807821274,115,0.014017825946211815,
+11,True,0.011157217435538769,0.013929265551269054,0.03790871426463127,0.02502146176993847,115,0.013929265551269054,
+12,True,0.011213844642043114,0.013062526471912861,0.05271097272634506,0.05017121136188507,115,0.013062526471912861,
+13,True,0.011921362020075321,0.013676638714969158,0.047521770000457764,0.03983796015381813,115,0.013676638714969158,
+14,True,0.012008284218609333,0.014828095212578773,0.03725012391805649,0.020932842046022415,115,0.014828095212578773,
+15,True,0.010373864322900772,0.012675918638706207,0.04253527149558067,0.03911801055073738,115,0.012675918638706207,
+16,True,0.010241445153951645,0.011512642726302147,0.038406386971473694,0.025528769940137863,115,0.011512642726302147,
+17,True,0.011789039708673954,0.01429742295295,0.049125123769044876,0.04818498715758324,115,0.01429742295295,
+18,True,0.010927367024123669,0.013093682937324047,0.03432627394795418,0.016404666006565094,115,0.013093682937324047,
+19,True,0.009818362072110176,0.011920268647372723,0.04855955392122269,0.04919042810797691,115,0.011920268647372723,
+20,True,0.012867278419435024,0.01521618478000164,0.03927508369088173,0.03147498518228531,115,0.01521618478000164,
+21,True,0.010895133018493652,0.012846298515796661,0.03587749972939491,0.01692228578031063,115,0.012846298515796661,
+22,True,0.011820620857179165,0.013819458894431591,0.05902153626084328,0.05692881718277931,115,0.013819458894431591,
+23,True,0.010261948220431805,0.012863698415458202,0.044761836528778076,0.037452731281518936,115,0.012863698415458202,
+24,True,0.010513492859899998,0.012658089399337769,0.03572552651166916,0.017877204343676567,115,0.012658089399337769,
+25,True,0.011507011950016022,0.013040557503700256,0.04703732579946518,0.046251993626356125,115,0.013040557503700256,
+26,True,0.010600236244499683,0.012397149577736855,0.04111762344837189,0.030570050701498985,115,0.012397149577736855,
+27,True,0.009490364231169224,0.011511269956827164,0.03818701207637787,0.030990643426775932,115,0.011511269956827164,
+28,True,0.010860958136618137,0.012726997956633568,0.03402654081583023,0.01745646819472313,115,0.012726997956633568,
+29,True,0.010579857043921947,0.013094527646899223,0.05072718858718872,0.053202178329229355,115,0.013094527646899223,
+30,True,0.00891837291419506,0.011897267773747444,0.0365508496761322,0.02734348177909851,115,0.011897267773747444,
+31,True,0.00891837291419506,0.011953024193644524,0.03663557767868042,0.02737654559314251,115,0.011953024193644524,
+32,True,0.01178054977208376,0.01331239938735962,0.044792160391807556,0.038074690848588943,115,0.01331239938735962,
+33,True,0.01087418757379055,0.011944858357310295,0.03442177176475525,0.012708167545497417,115,0.011944858357310295,
+34,True,0.01089719869196415,0.012335582636296749,0.04284502938389778,0.039931099861860275,115,0.012335582636296749,
+35,True,0.010727709159255028,0.013044538907706738,0.03844863176345825,0.02510569803416729,115,0.013044538907706738,
+36,True,0.010102402418851852,0.012338834814727306,0.039571456611156464,0.02707541175186634,115,0.012338834814727306,
+37,True,0.010749096982181072,0.013162517920136452,0.04447801038622856,0.042671091854572296,115,0.013162517920136452,
+38,True,0.011114558205008507,0.012699991464614868,0.03349260985851288,0.015496421605348587,115,0.012699991464614868,
+39,True,0.010612605139613152,0.012481985613703728,0.035326529294252396,0.022583890706300735,115,0.012481985613703728,
+40,True,0.013442505151033401,0.015488195233047009,0.0499306283891201,0.04255947098135948,115,0.015488195233047009,
+41,True,0.012020748108625412,0.013740424998104572,0.03715561702847481,0.029136115685105324,115,0.013740424998104572,
+42,True,0.009787488728761673,0.012273909524083138,0.03556263446807861,0.015094316564500332,115,0.012273909524083138,
+43,True,0.010189495049417019,0.012838209979236126,0.0342094711959362,0.013711540028452873,115,0.012838209979236126,
+44,True,0.010083073750138283,0.012880918569862843,0.04320306330919266,0.034211959689855576,115,0.012880918569862843,
+45,True,0.009806604124605656,0.013147053308784962,0.0362202450633049,0.020818931981921196,115,0.013147053308784962,
+46,True,0.011238104663789272,0.012345580384135246,0.04009832814335823,0.03549583628773689,115,0.012345580384135246,
+47,True,0.010543610900640488,0.013990441337227821,0.03949408978223801,0.02766445279121399,115,0.013990441337227821,
+48,True,0.009635820984840393,0.012854931876063347,0.049627549946308136,0.05091949179768562,115,0.012854931876063347,
+49,True,0.010492951609194279,0.012494039721786976,0.035110633820295334,0.023867812007665634,115,0.012494039721786976,
+50,True,0.013094361871480942,0.014725496992468834,0.04429764300584793,0.039075013250112534,115,0.014725496992468834,
+51,True,0.010708970949053764,0.013613102026283741,0.03766370564699173,0.02459827996790409,115,0.013613102026283741,
+52,True,0.010185126215219498,0.012646054849028587,0.044401030987501144,0.03792896866798401,115,0.012646054849028587,
+53,True,0.009615394286811352,0.012369819916784763,0.033640820533037186,0.012952952645719051,115,0.012369819916784763,
+54,True,0.01212071068584919,0.013602484948933125,0.03866367042064667,0.024225788190960884,115,0.013602484948933125,
+55,True,0.010020468384027481,0.012629804201424122,0.036491185426712036,0.018698325380682945,115,0.012629804201424122,
+56,True,0.010957827791571617,0.012206071056425571,0.03373796120285988,0.01495303027331829,115,0.012206071056425571,
+57,True,0.01283231656998396,0.016860544681549072,0.05935328081250191,0.06256767362356186,115,0.016860544681549072,
+58,True,0.011157868430018425,0.012793394736945629,0.03559685871005058,0.022277958691120148,115,0.012793394736945629,
+59,True,0.01318379770964384,0.015344934538006783,0.0455981083214283,0.03712679445743561,115,0.015344934538006783,
+60,True,0.013826809823513031,0.015726733952760696,0.04090641438961029,0.03518194705247879,115,0.015726733952760696,
+61,True,0.010233980603516102,0.01232092548161745,0.0355406254529953,0.016220910474658012,115,0.01232092548161745,
+62,True,0.011826787143945694,0.013856202363967896,0.05425432324409485,0.05200326070189476,115,0.013856202363967896,
+63,True,0.010531350038945675,0.01350613497197628,0.03480927273631096,0.016802148893475533,115,0.01350613497197628,
+64,True,0.01077455747872591,0.011790520511567593,0.045263614505529404,0.04441678151488304,115,0.011790520511567593,
+65,True,0.012252600863575935,0.013737152330577374,0.04236595332622528,0.03396288678050041,115,0.013737152330577374,
+66,True,0.01249685324728489,0.014912483282387257,0.03741711378097534,0.026593979448080063,115,0.014912483282387257,
+67,True,0.009911531582474709,0.011584421619772911,0.048246826976537704,0.04886375740170479,115,0.011584421619772911,
+68,True,0.011088039726018906,0.012897312641143799,0.05116324499249458,0.04743942245841026,115,0.012897312641143799,
+69,True,0.009596668183803558,0.012562038376927376,0.03443862125277519,0.015863623470067978,115,0.012562038376927376,
+70,True,0.010501796379685402,0.013671675696969032,0.05483553931117058,0.05149687081575394,115,0.013671675696969032,
+71,True,0.010561534203588963,0.011958612129092216,0.03407052159309387,0.011373537592589855,115,0.011958612129092216,
+72,True,0.012064927257597446,0.01746426895260811,0.0536867156624794,0.055677641183137894,115,0.01746426895260811,
+73,True,0.01219950057566166,0.013178017921745777,0.03901924565434456,0.027651270851492882,115,0.013178017921745777,
+74,True,0.011096742004156113,0.012258653528988361,0.04066529497504234,0.03689809516072273,115,0.012258653528988361,
+75,True,0.011933083645999432,0.012702187523245811,0.034044984728097916,0.012212133966386318,115,0.012702187523245811,
+76,True,0.011845076456665993,0.012540718540549278,0.03514784574508667,0.020117679610848427,115,0.012540718540549278,
+77,True,0.009935575537383556,0.011647654697299004,0.03725145757198334,0.029301010072231293,115,0.011647654697299004,
+78,True,0.011292885057628155,0.012916048988699913,0.05399074777960777,0.05127245932817459,115,0.012916048988699913,
+79,True,0.012450383976101875,0.014197349548339844,0.04292396828532219,0.03206207603216171,115,0.014197349548339844,
+80,True,0.0100817596539855,0.012955896556377411,0.03556123003363609,0.021370509639382362,115,0.012955896556377411,
+81,True,0.012341976165771484,0.014487706124782562,0.04217182844877243,0.03359149768948555,115,0.014487706124782562,
+82,True,0.010895133018493652,0.012638302519917488,0.036285754293203354,0.017733542248606682,115,0.012638302519917488,
+83,True,0.011798141524195671,0.012458031997084618,0.04144105687737465,0.038182228803634644,115,0.012458031997084618,
+84,True,0.010541833937168121,0.013724635355174541,0.048521652817726135,0.048178184777498245,115,0.013724635355174541,
+85,True,0.01056189276278019,0.011936021968722343,0.03667242452502251,0.02660462073981762,115,0.011936021968722343,
+86,True,0.011124493554234505,0.012513640336692333,0.04937281832098961,0.044036876410245895,115,0.012513640336692333,
+87,True,0.00975774135440588,0.013487035408616066,0.04493710398674011,0.04266781732439995,115,0.013487035408616066,
+88,True,0.011564011685550213,0.012671425938606262,0.05236012488603592,0.049248307943344116,115,0.012671425938606262,
+89,True,0.012682211585342884,0.013258358463644981,0.0408281646668911,0.030973348766565323,115,0.013258358463644981,
+90,True,0.012353197671473026,0.013780256733298302,0.04926513135433197,0.05062468349933624,115,0.013780256733298302,
+91,True,0.011570622213184834,0.012393051758408546,0.03738311305642128,0.023241683840751648,115,0.012393051758408546,
+92,True,0.011966320686042309,0.013744816184043884,0.03661346435546875,0.02215883694589138,115,0.013744816184043884,
+93,True,0.011912383139133453,0.013699990697205067,0.04908175766468048,0.04860259220004082,115,0.013699990697205067,
+94,True,0.010244164615869522,0.014857937581837177,0.038308035582304,0.028338411822915077,115,0.014857937581837177,
+95,True,0.011466301046311855,0.01242103148251772,0.035481881350278854,0.021633205935359,115,0.01242103148251772,
+96,True,0.01010688953101635,0.011791740544140339,0.03680938109755516,0.027401022613048553,115,0.011791740544140339,
+97,True,0.012686400674283504,0.014529144391417503,0.03613593429327011,0.01922997646033764,115,0.014529144391417503,
+98,True,0.011088039726018906,0.012999529018998146,0.05207730084657669,0.04869169369339943,115,0.012999529018998146,
+99,True,0.011436245404183865,0.013331407681107521,0.04183586686849594,0.03174901753664017,115,0.013331407681107521,
+100,True,0.009818362072110176,0.012100779451429844,0.047362636774778366,0.04740758612751961,115,0.012100779451429844,
+101,True,0.011471334844827652,0.012772241607308388,0.034339938312768936,0.016530731692910194,115,0.012772241607308388,
+102,True,0.011596080847084522,0.013860282488167286,0.053731102496385574,0.05707959458231926,115,0.013860282488167286,
+103,True,0.01035719271749258,0.012929211370646954,0.05235666409134865,0.047744665294885635,115,0.012929211370646954,
+104,True,0.010796640999615192,0.012631116434931755,0.04068189486861229,0.03709409013390541,115,0.012631116434931755,
+105,True,0.0100531792268157,0.011926176026463509,0.03434721753001213,0.01334389392286539,115,0.011926176026463509,
+106,True,0.011132863350212574,0.012581197544932365,0.04408402368426323,0.03647174686193466,115,0.012581197544932365,
+107,True,0.010860958136618137,0.014010705053806305,0.035445064306259155,0.02054925262928009,115,0.014010705053806305,
+108,True,0.011005599051713943,0.012304537929594517,0.04542159661650658,0.04458223283290863,115,0.012304537929594517,
+109,True,0.011570622213184834,0.01351388543844223,0.03919278457760811,0.025375599041581154,115,0.01351388543844223,
+110,True,0.011305093765258789,0.013941806741058826,0.04612043872475624,0.043763935565948486,115,0.013941806741058826,
+111,True,0.012151926755905151,0.0140449870377779,0.036646053194999695,0.025562480092048645,115,0.0140449870377779,
+112,True,0.01062745600938797,0.012553276494145393,0.03512924537062645,0.021872323006391525,115,0.012553276494145393,
+113,True,0.01051503885537386,0.012661074288189411,0.04500167816877365,0.03771154209971428,115,0.012661074288189411,
+114,True,0.012120991945266724,0.01341661810874939,0.03733058273792267,0.028018714860081673,115,0.01341661810874939,
+115,True,0.011344105936586857,0.012205136939883232,0.03324690833687782,0.0,115,0.012205136939883232,
+116,True,0.01154999528080225,0.012807686813175678,0.040530506521463394,0.030588621273636818,115,0.012807686813175678,
+117,True,0.011316826567053795,0.013888314366340637,0.04133453592658043,0.03822266682982445,115,0.013888314366340637,
+118,True,0.010711164213716984,0.012846855446696281,0.036766134202480316,0.021720854565501213,115,0.012846855446696281,
+119,True,0.010786758735775948,0.01345351804047823,0.05020881071686745,0.05150604620575905,115,0.01345351804047823,
+120,True,0.010313023813068867,0.011776452884078026,0.03637032210826874,0.02507195807993412,115,0.011776452884078026,
+121,True,0.012049195356667042,0.014113077893853188,0.04673044756054878,0.04172993078827858,115,0.014113077893853188,
+122,True,0.010655068792402744,0.011746600270271301,0.03463897481560707,0.014070238918066025,115,0.011746600270271301,
+123,True,0.013049191795289516,0.016235236078500748,0.04737371951341629,0.04109608754515648,115,0.016235236078500748,
+124,True,0.010637951083481312,0.012449810281395912,0.04254832863807678,0.03268899396061897,115,0.012449810281395912,
+125,True,0.010728846304118633,0.013685730285942554,0.04924720153212547,0.05023272708058357,115,0.013685730285942554,
+126,True,0.011006438173353672,0.012406667694449425,0.03748086094856262,0.02209119312465191,115,0.012406667694449425,
+127,True,0.011202402412891388,0.01314001064747572,0.03522178903222084,0.016391508281230927,115,0.01314001064747572,
+128,True,0.011054269969463348,0.013230616226792336,0.03496325761079788,0.021032189950346947,115,0.013230616226792336,
+129,True,0.010368946008384228,0.013217074796557426,0.05466533452272415,0.05747315287590027,115,0.013217074796557426,
+130,True,0.011144586838781834,0.016579296439886093,0.04248950257897377,0.03769192844629288,115,0.016579296439886093,
+131,True,0.010257620364427567,0.012890520505607128,0.03450895845890045,0.016388066112995148,115,0.012890520505607128,
+132,True,0.011820620857179165,0.014143119566142559,0.05895627290010452,0.05683860927820206,115,0.014143119566142559,
+133,True,0.008977980352938175,0.01239490695297718,0.03419160842895508,0.014237464405596256,115,0.01239490695297718,
+134,True,0.008977980352938175,0.012424565851688385,0.03431066498160362,0.014466220512986183,115,0.012424565851688385,
+135,True,0.011512091383337975,0.01235582958906889,0.041123490780591965,0.03198293596506119,115,0.01235582958906889,
+136,True,0.009806604124605656,0.01313829980790615,0.03665979579091072,0.02207012288272381,115,0.01313829980790615,
+137,True,0.010009367018938065,0.011877383105456829,0.03822449594736099,0.030873961746692657,115,0.011877383105456829,
+138,True,0.012453647330403328,0.013798588886857033,0.03656229376792908,0.01947282999753952,115,0.013798588886857033,
+139,True,0.012064927257597446,0.01568509265780449,0.055819056928157806,0.05893253535032272,115,0.01568509265780449,
+140,True,0.012245526537299156,0.015722651034593582,0.0531228631734848,0.050245728343725204,115,0.015722651034593582,
+141,True,0.010986309498548508,0.012282474897801876,0.03902708739042282,0.03232970088720322,115,0.012282474897801876,
+142,True,0.009596668183803558,0.013266334310173988,0.03515924513339996,0.017106257379055023,115,0.013266334310173988,
+143,True,0.011254915967583656,0.014398915693163872,0.05278405919671059,0.04863034188747406,115,0.014398915693163872,
+144,True,0.01117666345089674,0.012004807591438293,0.04408888891339302,0.04191946983337402,115,0.012004807591438293,
+145,True,0.010241445153951645,0.011722841300070286,0.038930706679821014,0.026286469772458076,115,0.011722841300070286,
+146,True,0.011198735795915127,0.012161582708358765,0.04190019890666008,0.03823016211390495,115,0.012161582708358765,
+147,True,0.011114558205008507,0.013118120841681957,0.03401997685432434,0.017511438578367233,115,0.013118120841681957,
+148,True,0.010452451184391975,0.014239570125937462,0.05472499504685402,0.05575217679142952,115,0.014239570125937462,
+149,True,0.010244164615869522,0.014521496370434761,0.03801584243774414,0.028677064925432205,115,0.014521496370434761,
+150,True,0.010412571020424366,0.012611362151801586,0.04948479309678078,0.044354718178510666,115,0.012611362151801586,
+151,True,0.011106288060545921,0.012374402955174446,0.03611917048692703,0.025719447061419487,115,0.012374402955174446,
+152,True,0.012558629736304283,0.015218393877148628,0.056405872106552124,0.05400558188557625,115,0.015218393877148628,
+153,True,0.011324729770421982,0.01268951315432787,0.03472497686743736,0.013177075423300266,115,0.01268951315432787,
+154,True,0.012373057194054127,0.013892313465476036,0.04877462610602379,0.050152041018009186,115,0.013892313465476036,
+155,True,0.009405845776200294,0.013131680898368359,0.0363728329539299,0.02164560928940773,115,0.013131680898368359,
+156,True,0.012030777521431446,0.013563198037445545,0.042833585292100906,0.039977412670850754,115,0.013563198037445545,
+157,True,0.010786758735775948,0.012179022654891014,0.04952722415328026,0.05095836892724037,115,0.012179022654891014,
+158,True,0.011466301046311855,0.012827962636947632,0.03513617813587189,0.02099422551691532,115,0.012827962636947632,
+159,True,0.011146847158670425,0.012747588567435741,0.050024114549160004,0.04562506824731827,115,0.012747588567435741,
+160,True,0.01305298786610365,0.01514745969325304,0.046699684113264084,0.0424322709441185,115,0.01514745969325304,
+161,True,0.018420280888676643,0.02056705951690674,0.045143913477659225,0.037030551582574844,115,0.02056705951690674,
+162,True,0.011556282639503479,0.012481031008064747,0.0535031296312809,0.050655756145715714,115,0.012481031008064747,
+163,True,0.010687686502933502,0.012675154022872448,0.043521225452423096,0.03669895604252815,115,0.012675154022872448,
+164,True,0.011482239700853825,0.012933204881846905,0.043600138276815414,0.04083477333188057,115,0.012933204881846905,
+165,True,0.010727709159255028,0.012398188933730125,0.03909281641244888,0.025408009067177773,115,0.012398188933730125,
+166,True,0.010419626720249653,0.01218860037624836,0.037100959569215775,0.02212364412844181,115,0.01218860037624836,
+167,True,0.01283231656998396,0.016761206090450287,0.058479223400354385,0.06172690913081169,115,0.016761206090450287,
+168,True,0.010313023813068867,0.011503527872264385,0.03552965819835663,0.022787833586335182,115,0.011503527872264385,
+169,True,0.011144586838781834,0.015656711533665657,0.04249955713748932,0.03857419267296791,115,0.015656711533665657,
+170,True,0.012198257260024548,0.01366309355944395,0.05225250869989395,0.04892798885703087,115,0.01366309355944395,
+171,True,0.010531350038945675,0.013090958818793297,0.03484949469566345,0.01673760823905468,115,0.013090958818793297,
+172,True,0.01077455747872591,0.011996537446975708,0.04606221988797188,0.045876313000917435,115,0.011996537446975708,
+173,True,0.010824659839272499,0.012162536382675171,0.039930980652570724,0.027981828898191452,115,0.012162536382675171,
+174,True,0.010474460199475288,0.011733836494386196,0.04024439677596092,0.03554348275065422,115,0.011733836494386196,
+175,True,0.011718209832906723,0.013124123215675354,0.03573346510529518,0.02355922944843769,115,0.013124123215675354,
+176,True,0.011150975711643696,0.012073131278157234,0.04867120832204819,0.04922817274928093,115,0.012073131278157234,
+177,True,0.010725480504333973,0.01221168041229248,0.038389693945646286,0.02937665395438671,115,0.01221168041229248,
+178,True,0.010882734321057796,0.014331286773085594,0.049880314618349075,0.0454464890062809,115,0.014331286773085594,
+179,True,0.011066574603319168,0.013516383245587349,0.039088595658540726,0.029932457953691483,115,0.013516383245587349,
+180,True,0.010257620364427567,0.01270800270140171,0.034352853894233704,0.01651644892990589,115,0.01270800270140171,
+181,True,0.010185126215219498,0.013393069617450237,0.045568399131298065,0.039775196462869644,115,0.013393069617450237,
+182,True,0.012008284218609333,0.014705139212310314,0.03770122677087784,0.021265292540192604,115,0.014705139212310314,
+183,True,0.011036478914320469,0.013367380015552044,0.04739425703883171,0.04849841445684433,115,0.013367380015552044,
+184,True,0.011202785186469555,0.01378795225173235,0.04123876243829727,0.02947722189128399,115,0.01378795225173235,
+185,True,0.011240500025451183,0.013475057668983936,0.04389216750860214,0.04277810454368591,115,0.013475057668983936,
+186,True,0.012003510259091854,0.013280823826789856,0.03449511528015137,0.014400873333215714,115,0.013280823826789856,
+187,True,0.010612605139613152,0.013568488880991936,0.03614788129925728,0.023641621693968773,115,0.013568488880991936,
+188,True,0.010672987438738346,0.012702137231826782,0.04947040230035782,0.04503004252910614,115,0.012702137231826782,
+189,True,0.010230462066829205,0.012498101219534874,0.03648863732814789,0.02787650190293789,115,0.012498101219534874,
+190,True,0.013241295702755451,0.014919057488441467,0.03855970874428749,0.020917855203151703,115,0.014919057488441467,
+191,True,0.010635514743626118,0.012073850259184837,0.04554098844528198,0.038576751947402954,115,0.012073850259184837,
+192,True,0.0100817596539855,0.013272775337100029,0.036253493279218674,0.022750940173864365,115,0.013272775337100029,
+193,True,0.01211816631257534,0.013326202519237995,0.04144291579723358,0.032227516174316406,115,0.013326202519237995,
+194,True,0.011000615544617176,0.013441729359328747,0.03670767322182655,0.020291252061724663,115,0.013441729359328747,
+195,True,0.010661275126039982,0.011801479384303093,0.03853250667452812,0.031795937567949295,115,0.011801479384303093,
+196,True,0.011712548322975636,0.013665346428751945,0.034441106021404266,0.017575571313500404,115,0.013665346428751945,
+197,True,0.009635820984840393,0.012657602317631245,0.04843341186642647,0.04926977679133415,115,0.012657602317631245,
+198,True,0.011646391823887825,0.013224964961409569,0.03828059136867523,0.02720075286924839,115,0.013224964961409569,
+199,True,0.011276314966380596,0.012461191974580288,0.04938031733036041,0.044777557253837585,115,0.012461191974580288,
+200,True,0.011039580218493938,0.012896743603050709,0.03611478954553604,0.019840989261865616,115,0.012896743603050709,
+201,True,0.010412571020424366,0.01231597550213337,0.05202009901404381,0.04782242700457573,115,0.01231597550213337,
+202,True,0.01280540507286787,0.015459747985005379,0.04415055736899376,0.03639183193445206,115,0.015459747985005379,
+203,True,0.009740781970322132,0.012180924415588379,0.038558851927518845,0.0264649149030447,115,0.012180924415588379,
+204,True,0.011013309471309185,0.012449001893401146,0.03636184707283974,0.019064398482441902,115,0.012449001893401146,
+205,True,0.010979089885950089,0.012767809443175793,0.03401358053088188,0.01519929151982069,115,0.012767809443175793,
+206,True,0.010522228665649891,0.01222753431648016,0.034479472786188126,0.02045099437236786,115,0.01222753431648016,
+207,True,0.009490364231169224,0.011576822027564049,0.037580423057079315,0.02959495224058628,115,0.011576822027564049,
+208,True,0.010942158289253712,0.01269763894379139,0.03406064584851265,0.013745017349720001,115,0.01269763894379139,
+209,True,0.010205645114183426,0.012283327989280224,0.05150964483618736,0.04842327907681465,115,0.012283327989280224,
+210,True,0.0111441221088171,0.013149726204574108,0.03496525436639786,0.019649464637041092,115,0.013149726204574108,
+211,True,0.011271598748862743,0.014107773080468178,0.054515041410923004,0.05497254803776741,115,0.014107773080468178,
+212,True,0.010997823439538479,0.013203771784901619,0.03889762610197067,0.026685936376452446,115,0.013203771784901619,
+213,True,0.01110097300261259,0.012658951804041862,0.03571835905313492,0.016832424327731133,115,0.012658951804041862,
+214,True,0.010649324394762516,0.011970316991209984,0.03439358249306679,0.018259264528751373,115,0.011970316991209984,
+215,True,0.009976808913052082,0.012285393662750721,0.05011482536792755,0.04521547257900238,115,0.012285393662750721,
+216,True,0.011340286582708359,0.012645264156162739,0.03935270756483078,0.03383920341730118,115,0.012645264156162739,
+217,True,0.011070487089455128,0.012318954803049564,0.033772289752960205,0.012765946798026562,115,0.012318954803049564,
+218,True,0.011546914465725422,0.012736926786601543,0.04443148896098137,0.03738434985280037,115,0.012736926786601543,
+219,True,0.010561534203588963,0.011837254278361797,0.03442114591598511,0.012909213081002235,115,0.011837254278361797,
+220,True,0.010635731741786003,0.012454918585717678,0.045806530863046646,0.04608357697725296,115,0.012454918585717678,
+221,True,0.011233671568334103,0.014110866002738476,0.04061080142855644,0.030217427760362625,115,0.014110866002738476,
+222,True,0.011054269969463348,0.01239706389605999,0.03369778022170067,0.017263950780034065,115,0.01239706389605999,
+223,True,0.010176853276789188,0.013461530208587646,0.054060645401477814,0.05687972530722618,115,0.013461530208587646,
+224,True,0.011681165546178818,0.014684329740703106,0.045220471918582916,0.03817956894636154,115,0.014684329740703106,
+225,True,0.011928336694836617,0.012519342824816704,0.039323996752500534,0.03342495113611221,115,0.012519342824816704,
+226,True,0.01226238813251257,0.013434773311018944,0.05500947684049606,0.05209263041615486,115,0.013434773311018944,
+227,True,0.010456500574946404,0.012848381884396076,0.039728373289108276,0.02838985063135624,115,0.012848381884396076,
+228,True,0.010452451184391975,0.014583887532353401,0.056108295917510986,0.05671598017215729,115,0.014583887532353401,
+229,True,0.009813087992370129,0.015702825039625168,0.044126514345407486,0.03595707565546036,115,0.015702825039625168,
+230,True,0.00906071811914444,0.012099077925086021,0.035993386059999466,0.018316885456442833,115,0.012099077925086021,
+231,True,0.00906071811914444,0.012084267102181911,0.03605188429355621,0.018270432949066162,115,0.012084267102181911,
+232,True,0.011155190877616405,0.01303872186690569,0.051846228539943695,0.05419588088989258,115,0.01303872186690569,
+233,True,0.01056189276278019,0.011728049255907536,0.0369771309196949,0.028287455439567566,115,0.011728049255907536,
+234,True,0.009976808913052082,0.01243998296558857,0.049456458538770676,0.044221341609954834,115,0.01243998296558857,
+235,True,0.01094004325568676,0.01285687368363142,0.0360732264816761,0.01902812346816063,115,0.01285687368363142,
+236,True,0.014029739424586296,0.01643403433263302,0.05013445019721985,0.046524424105882645,115,0.01643403433263302,
+237,True,0.010635514743626118,0.011981664225459099,0.043528638780117035,0.035495150834321976,115,0.011981664225459099,
+238,True,0.011863150633871555,0.013959606178104877,0.049818553030490875,0.051034703850746155,115,0.013959606178104877,
+239,True,0.011522319167852402,0.013937093317508698,0.04053499549627304,0.026303449645638466,115,0.013937093317508698,
+240,True,0.012121381238102913,0.01411188580095768,0.03704553470015526,0.02357340417802334,115,0.01411188580095768,
+241,True,0.008687633089721203,0.012430744245648384,0.04445510730147362,0.0420556403696537,115,0.012430744245648384,
+242,True,0.008687633089721203,0.012520653195679188,0.044566646218299866,0.0422024205327034,115,0.012520653195679188,
+243,True,0.011008847504854202,0.012339677661657333,0.053139396011829376,0.05516323074698448,115,0.012339677661657333,
+244,True,0.012496504932641983,0.014537133276462555,0.037879884243011475,0.029946357011795044,115,0.014537133276462555,
+245,True,0.01010688953101635,0.012392330914735794,0.03788420185446739,0.028807079419493675,115,0.012392330914735794,
+246,True,0.011395073495805264,0.013997353613376617,0.03485090658068657,0.01850779540836811,115,0.013997353613376617,
+247,True,0.011009939946234226,0.012569794431328773,0.05475323647260666,0.05140521749854088,115,0.012569794431328773,
+248,True,0.010730068199336529,0.014027643017470837,0.04074784368276596,0.02872745878994465,115,0.014027643017470837,
+249,True,0.009740781970322132,0.011995026841759682,0.03809308260679245,0.025761662051081657,115,0.011995026841759682,
+250,True,0.013217703439295292,0.013814510777592659,0.04188578575849533,0.03925831988453865,115,0.013814510777592659,
+251,True,0.010711164213716984,0.012626878917217255,0.03766096010804176,0.024730894714593887,115,0.012626878917217255,
+252,True,0.016418002545833588,0.02076105773448944,0.06270488351583481,0.06630561500787735,115,0.02076105773448944,
+253,True,0.010882734321057796,0.013657523319125175,0.04896315187215805,0.044239237904548645,115,0.013657523319125175,
+254,True,0.011897294782102108,0.014278125949203968,0.04060998186469078,0.03495761379599571,115,0.014278125949203968,
+255,True,0.010020468384027481,0.013040557503700256,0.03634899854660034,0.01684168167412281,115,0.013040557503700256,
+256,True,0.011649984866380692,0.01296100951731205,0.04864790663123131,0.04313497617840767,115,0.01296100951731205,
+257,True,0.011798141524195671,0.012957748956978321,0.043602023273706436,0.04230928421020508,115,0.012957748956978321,
+258,True,0.0097475191578269,0.011975283734500408,0.03902320936322212,0.03145936131477356,115,0.011975283734500408,
+259,True,0.010251523926854134,0.012965837493538857,0.034284114837646484,0.018798062577843666,115,0.012965837493538857,
+260,True,0.01166519708931446,0.013790704309940338,0.03524676337838173,0.022790051996707916,115,0.013790704309940338,
+261,True,0.01045903842896223,0.012394639663398266,0.04938921704888344,0.044955264776945114,115,0.012394639663398266,
+262,True,0.01062745600938797,0.012275119312107563,0.03504301607608795,0.022800203412771225,115,0.012275119312107563,
+263,True,0.010809299536049366,0.013124307617545128,0.036081597208976746,0.017160814255475998,115,0.013124307617545128,
+264,True,0.012283185496926308,0.01487396378070116,0.06037301570177078,0.05840545892715454,115,0.01487396378070116,
+265,True,0.0100531792268157,0.011971680447459221,0.033522047102451324,0.011344105936586857,115,0.011971680447459221,
+266,True,0.010977273806929588,0.012782896868884563,0.044856954365968704,0.03696770220994949,115,0.012782896868884563,
+267,True,0.011178532615303993,0.012657621875405312,0.03832468017935753,0.02248370088636875,115,0.012657621875405312,
+268,True,0.011387518607079983,0.01425898540765047,0.0417192280292511,0.03857724368572235,115,0.01425898540765047,
+269,True,0.00925192330032587,0.012465608306229115,0.03533808887004852,0.016398821026086807,115,0.012465608306229115,
+270,True,0.008847367949783802,0.011549782939255238,0.034924887120723724,0.02052030712366104,115,0.011549782939255238,
+271,True,0.008847367949783802,0.01161869801580906,0.03496517613530159,0.02049800381064415,115,0.01161869801580906,
+272,True,0.010708970949053764,0.013310831971466541,0.03751038759946823,0.02409629337489605,115,0.013310831971466541,
+273,True,0.010501796379685402,0.013268527574837208,0.0551399402320385,0.05207718163728714,115,0.013268527574837208,
+274,True,0.010923683643341064,0.01208130456507206,0.04626765847206116,0.039218656718730927,115,0.01208130456507206,
+275,True,0.010373864322900772,0.012491529807448387,0.04235491156578064,0.03927897661924362,115,0.012491529807448387,
+276,True,0.010547779500484467,0.012995016761124134,0.039333123713731766,0.02857396751642227,115,0.012995016761124134,
+277,True,0.0115548986941576,0.01333839911967516,0.03702012822031975,0.02304554171860218,115,0.01333839911967516,
+278,True,0.01120274979621172,0.013039144687354565,0.05413883924484253,0.055428482592105865,115,0.013039144687354565,
+279,True,0.012085411697626114,0.013203551061451435,0.03607137128710747,0.015723925083875656,115,0.013203551061451435,
+280,True,0.011213844642043114,0.01289965957403183,0.05266663804650307,0.049437202513217926,115,0.01289965957403183,
+281,True,0.010513492859899998,0.012483803555369377,0.03507862240076065,0.015295181423425674,115,0.012483803555369377,
+282,True,0.010797296650707722,0.012911362573504448,0.050191380083560944,0.051360197365283966,115,0.012911362573504448,
+283,True,0.010600236244499683,0.01268988847732544,0.0404302142560482,0.02826869674026966,115,0.01268988847732544,
+284,True,0.009969743900001049,0.011618790216743946,0.03943400830030441,0.03375086560845375,115,0.011618790216743946,
+285,True,0.010251523926854134,0.012621292844414711,0.03416774794459343,0.018709402531385422,115,0.012621292844414711,
+286,True,0.01096393819898367,0.012457977049052715,0.04942759498953819,0.050696395337581635,115,0.012457977049052715,
+287,True,0.01245274767279625,0.016533926129341125,0.04514744132757187,0.03738575056195259,115,0.016533926129341125,
+288,True,0.013128777034580708,0.016062511131167412,0.05091457813978195,0.04679878056049347,115,0.016062511131167412,
+289,True,0.011066574603319168,0.012151261791586876,0.038694195449352264,0.03103378601372242,115,0.012151261791586876,
+290,True,0.010804703459143639,0.013417380861938,0.03763315826654434,0.024790428578853607,115,0.013417380861938,
+291,True,0.01045903842896223,0.012026458978652954,0.051004912704229355,0.04688442125916481,115,0.012026458978652954,
+292,True,0.010189495049417019,0.011801889166235924,0.03346363827586174,0.01180744543671608,115,0.011801889166235924,
+293,True,0.01089719869196415,0.012222721241414547,0.044584304094314575,0.042574238032102585,115,0.012222721241414547,
+294,True,0.010102402418851852,0.012273113243281841,0.03828580304980278,0.024594739079475403,115,0.012273113243281841,
+295,True,0.013040930032730103,0.015214851126074791,0.05039377883076668,0.05136299878358841,115,0.015214851126074791,
+296,True,0.011521357111632824,0.012697065249085426,0.03340018168091774,0.013147085905075073,115,0.012697065249085426,
+297,True,0.010176853276789188,0.01335055660456419,0.05460084229707718,0.057311080396175385,115,0.01335055660456419,
+298,True,0.012169672176241875,0.013953819870948792,0.038616131991147995,0.031737152487039566,115,0.013953819870948792,
+299,True,0.012781797908246517,0.015323931351304054,0.059158194810152054,0.057180408388376236,115,0.015323931351304054,
+300,True,0.010261948220431805,0.012234617955982685,0.044580042362213135,0.03728487715125084,115,0.012234617955982685,
+301,True,0.010703259147703648,0.013531466014683247,0.03593996912240982,0.021165892481803894,115,0.013531466014683247,
+302,True,0.010083073750138283,0.013041864149272442,0.044611670076847076,0.03630490228533745,115,0.013041864149272442,
+303,True,0.009405845776200294,0.013082899153232574,0.036452535539865494,0.022471297532320023,115,0.013082899153232574,
+304,True,0.008950324729084969,0.011465239338576794,0.03918894752860069,0.03263053670525551,115,0.011465239338576794,
+305,True,0.008950324729084969,0.011510076932609081,0.03916098549962044,0.03256355971097946,115,0.011510076932609081,
+306,True,0.010579857043921947,0.013348412699997425,0.05074436590075493,0.05280083417892456,115,0.013348412699997425,
+307,True,0.010205645114183426,0.011971231549978256,0.04945077747106552,0.045483339577913284,115,0.011971231549978256,
+308,True,0.011157217435538769,0.013653297908604145,0.03701554983854294,0.023330308496952057,115,0.013653297908604145,
+309,True,0.010917933657765388,0.013347593136131763,0.054036032408475876,0.05038435012102127,115,0.013347593136131763,
+310,True,0.010149999521672726,0.014423495158553123,0.04466211050748825,0.03794422000646591,115,0.014423495158553123,
+311,True,0.011316826567053795,0.014650714583694935,0.04422733187675476,0.04285261407494545,115,0.014650714583694935,
+312,True,0.010456500574946404,0.01253217738121748,0.03880474716424942,0.026873651891946793,115,0.01253217738121748,
+313,True,0.011094027198851109,0.012603993527591228,0.03928833082318306,0.025501983240246773,115,0.012603993527591228,
+314,True,0.00975774135440588,0.012279989197850227,0.045283980667591095,0.04332670196890831,115,0.012279989197850227,
+315,True,0.010635731741786003,0.01289568841457367,0.04870691895484924,0.050001200288534164,115,0.01289568841457367,
+316,True,0.010008910670876503,0.01172915380448103,0.034417394548654556,0.02002383954823017,115,0.01172915380448103,
+317,True,0.009787488728761673,0.012721158564090729,0.03541651740670204,0.014879558235406876,115,0.012721158564090729,
+318,True,0.012245526537299156,0.014163553714752197,0.05396442487835884,0.05155310779809952,115,0.014163553714752197,
+319,True,0.0111441221088171,0.01384173147380352,0.03692283853888512,0.024165784940123558,115,0.01384173147380352,
+320,True,0.012102073058485985,0.013329913839697838,0.050624918192625046,0.05184781551361084,115,0.013329913839697838,
+321,True,0.010143120773136616,0.011902468279004097,0.03876736760139465,0.027204077690839767,115,0.011902468279004097,
+322,True,0.010474460199475288,0.012151897884905338,0.04005836695432663,0.03409339860081673,115,0.012151897884905338,
+323,True,0.01096393819898367,0.013003364205360413,0.05046512931585312,0.05190979689359665,115,0.013003364205360413,
+324,True,0.011233394965529442,0.013234411366283894,0.03864045441150665,0.031151296570897102,115,0.013234411366283894,
+325,True,0.010796640999615192,0.011942858807742596,0.039283543825149536,0.034196142107248306,115,0.011942858807742596,
+326,True,0.011364756152033806,0.013643475249409676,0.03446687385439873,0.014515629969537258,115,0.013643475249409676,
+327,True,0.010997493751347065,0.01240344438701868,0.043978720903396606,0.0369742251932621,115,0.01240344438701868,
+328,True,0.009615394286811352,0.012176346965134144,0.03393471986055374,0.012691551819443703,115,0.012176346965134144,
+329,True,0.011005302891135216,0.012086203321814537,0.04513982683420181,0.04459952190518379,115,0.012086203321814537,
+330,True,0.011522319167852402,0.01481376588344574,0.040498871356248856,0.025172986090183258,115,0.01481376588344574,
+331,True,0.011233671568334103,0.013948437757790089,0.0399288572371006,0.02888569049537182,115,0.013948437757790089,
+332,True,0.01094853039830923,0.01182685699313879,0.04225220903754234,0.03928939625620842,115,0.01182685699313879,
+333,True,0.010957827791571617,0.01235399954020977,0.033662308007478714,0.014501894824206829,115,0.01235399954020977,
+334,True,0.010522228665649891,0.012528657913208008,0.035171423107385635,0.021934935823082924,115,0.012528657913208008,
+335,True,0.011681165546178818,0.014869233593344688,0.04404989629983902,0.03693223372101784,115,0.014869233593344688,
+336,True,0.010230462066829205,0.012407016940414906,0.03827652335166931,0.03185355290770531,115,0.012407016940414906,
+337,True,0.012450383976101875,0.0141285490244627,0.04317630082368851,0.03249995410442352,115,0.0141285490244627,
+338,True,0.01040648203343153,0.012462783604860306,0.03390531241893768,0.011931288056075573,115,0.012462783604860306,
+339,True,0.009813087992370129,0.016127776354551315,0.04468565434217453,0.03703887388110161,115,0.016127776354551315,
+340,True,0.011102366261184216,0.013403205201029778,0.044372882694005966,0.043686240911483765,115,0.013403205201029778,
+341,True,0.010543610900640488,0.013400626368820667,0.03904144838452339,0.028493301942944527,115,0.013400626368820667,
+342,True,0.010541833937168121,0.01337279099971056,0.04860565811395645,0.04838969185948372,115,0.01337279099971056,
+343,True,0.010492951609194279,0.012373487465083599,0.03531397134065628,0.024326510727405548,115,0.012373487465083599,
+344,True,0.011077499948441982,0.012256180867552757,0.04672115668654442,0.041085973381996155,115,0.012256180867552757,
+345,True,0.01137775182723999,0.012188037857413292,0.034527674317359924,0.016077488660812378,115,0.012188037857413292,
+346,True,0.012414089404046535,0.013443263247609138,0.0486348420381546,0.044714704155921936,115,0.013443263247609138,
+347,True,0.010977273806929588,0.01249057799577713,0.043742112815380096,0.03610444813966751,115,0.01249057799577713,
+348,True,0.00925192330032587,0.012694220058619976,0.03584397956728935,0.017420483753085136,115,0.012694220058619976,
+349,True,0.013966660015285015,0.018003711476922035,0.05483357980847359,0.05684798210859299,115,0.018003711476922035,
+350,False,0.01106477677822113,0.013206787593662738,0.03651430830359459,0.022525833174586295,115,0.013206787593662738,290;92;276;210;28
+351,False,0.010699992440640927,0.012531449273228645,0.035466445982456206,0.020056487433612345,115,0.012531449273228645,85;33;200;343;63
+352,False,0.01099071241915226,0.013177142478525639,0.04898545369505882,0.049662868678569796,115,0.013177142478525639,243;282;87;90;183
+353,False,0.010996765270829201,0.012637670524418354,0.041707663983106616,0.03496098667383194,115,0.012637670524418354,114;118;174;278;322
+354,False,0.010281649231910706,0.012723585218191147,0.041948963701725,0.03695052452385426,115,0.012723585218191147,30;64;187;15;125

splits/compute_chamfer_splits.py

@@ -0,0 +1,818 @@
+#!/usr/bin/env python3
+"""Compute STL-based Chamfer geometry splits for WindsorML.
+
+This is intentionally standalone so it can be copied to the machine that has
+the STL files. It expects a WindsorML-style directory layout:
+
+    DATA_ROOT/
+      run_0/windsor_0.stl
+      run_1/windsor_1.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 ../windsorml_hf_assets \
+      --output-dir /tmp/windsorml_chamfer \
+      --samples 4096 \
+      --workers 16 \
+      --allow-missing
+"""
+
+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 = 355
+PUBLIC_RUN_IDS = list(range(N_CASES))
+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 WindsorML geometry splits.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument(
+        "--data-root",
+        type=Path,
+        required=True,
+        help="Directory containing run_N/windsor_N.stl files and aggregate CSVs.",
+    )
+    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.",
+    )
+    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 "
+            "0,1,10-20. For WindsorML, public and all both mean 0..354."
+        ),
+    )
+    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(N_CASES))
+
+    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 < 0 or rid >= N_CASES]
+    if bad:
+        raise SystemExit(f"Run IDs must be in 0..{N_CASES - 1}; 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"windsor_{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 _clean_row(row: dict[str, str]) -> dict[str, str]:
+    return {key.strip(): value.strip() for key, value in row.items() if key is not None}
+
+
+def load_imputation_features(data_root: Path) -> dict[int, list[float]]:
+    tables: list[dict[int, dict[str, float]]] = []
+    for filename in ["force_mom_all.csv", "geo_parameters_all.csv"]:
+        path = data_root / filename
+        if not path.exists():
+            raise SystemExit(f"Missing {path}; aggregate CSVs are required to impute absent STL scores")
+        records: dict[int, dict[str, float]] = {}
+        with path.open(encoding="utf-8-sig", newline="") as f:
+            for raw in csv.DictReader(f):
+                row = _clean_row(raw)
+                records[int(row["run"])] = {key: float(value) for key, value in row.items() if key != "run"}
+        tables.append(records)
+
+    missing = sorted(set(PUBLIC_RUN_IDS) - set(tables[0]) | (set(PUBLIC_RUN_IDS) - set(tables[1])))
+    if missing:
+        raise SystemExit(f"Aggregate CSVs are missing WindsorML runs: {missing}")
+    fields = [sorted(next(iter(table.values())).keys()) for table in tables]
+    return {
+        run: [value for table, names in zip(tables, fields) for name in names for value in [table[run][name]]]
+        for run in PUBLIC_RUN_IDS
+    }
+
+
+def complete_metrics(
+    requested_runs: list[int],
+    metrics: list[dict[str, float | int]],
+    scores: dict[int, float],
+    data_root: Path,
+    neighbor_count: int = 5,
+) -> tuple[list[dict[str, float | int | str | bool]], dict[int, float], int]:
+    rows_by_run = {int(row["run"]): row for row in metrics}
+    observed_runs = sorted(rows_by_run)
+    missing_runs = sorted(set(requested_runs) - set(observed_runs))
+    complete_scores = scores.copy()
+    complete_rows: dict[int, dict[str, float | int | str | bool]] = {}
+    for run in observed_runs:
+        complete_rows[run] = {
+            **rows_by_run[run],
+            "geometry_observed": True,
+            "imputation_neighbors": "",
+        }
+
+    if missing_runs:
+        features = load_imputation_features(data_root)
+        all_matrix = np.asarray([features[run] for run in PUBLIC_RUN_IDS], dtype=float)
+        means = all_matrix.mean(axis=0)
+        stds = all_matrix.std(axis=0)
+        stds[stds == 0.0] = 1.0
+        standardized = (all_matrix - means) / stds
+        numeric_fields = [key for key in metrics[0] if key not in {"run", "medoid_run"}]
+        for run in missing_runs:
+            nearest = sorted(
+                observed_runs,
+                key=lambda candidate: (float(np.linalg.norm(standardized[candidate] - standardized[run])), candidate),
+            )[: max(1, min(neighbor_count, len(observed_runs)))]
+            row: dict[str, float | int | str | bool] = {
+                "run": run,
+                "geometry_observed": False,
+                "medoid_run": int(metrics[0]["medoid_run"]),
+                "imputation_neighbors": ";".join(str(value) for value in nearest),
+            }
+            for field in numeric_fields:
+                row[field] = float(np.mean([float(rows_by_run[candidate][field]) for candidate in nearest]))
+            complete_scores[run] = float(np.mean([scores[candidate] for candidate in nearest]))
+            complete_rows[run] = row
+    return [complete_rows[run] for run in sorted(complete_rows)], complete_scores, len(missing_runs)
+
+
+def write_metrics_csv(
+    path: Path,
+    metrics: list[dict[str, float | int | str | bool]],
+    scores: dict[int, float],
+) -> None:
+    metric_fields = [key for key in metrics[0] if key not in {"run", "geometry_observed", "imputation_neighbors"}]
+    fieldnames = ["run", "geometry_observed", *metric_fields, "ood_score", "imputation_neighbors"]
+    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)
+    observed_scores = score_map(run_ids, matrix, metrics, args.score, args.k_neighbors)
+    complete_rows, scores, missing_count = complete_metrics(
+        requested_runs,
+        metrics,
+        observed_scores,
+        args.data_root,
+    )
+    write_metrics_csv(args.output_dir / "chamfer_metrics.csv", complete_rows, 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(requested_runs)} ({len(run_ids)} observed STL, {missing_count} imputed)")
+    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/compute_image_metrics.py

@@ -0,0 +1,197 @@
+"""Compute WindsorML image-derived wake scores from velocity PNGs.
+
+The score measures the area and intensity of low streamwise velocity in two
+near-centreline z-constant views and three x-constant planes immediately behind
+the body. Missing image scores can be imputed from the five nearest observed
+cases in standardized force/geometry feature space; the CSV records whether
+each score was observed or imputed.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import os
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+
+N_CASES = 355
+RUN_IDS = list(range(N_CASES))
+SCRIPT_DIR = Path(__file__).resolve().parent
+REPOSITORY_ROOT = SCRIPT_DIR.parent
+DATA_DIR = SCRIPT_DIR
+DEFAULT_ASSET_ROOT = Path(os.environ.get("WINDSORML_ASSET_ROOT", REPOSITORY_ROOT.parent / "windsorml_hf_assets"))
+CENTERLINE_Z_INDICES = (4, 5)
+NEAR_WAKE_X_INDICES = (53, 55, 57)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Compute WindsorML velocity-image wake metrics.")
+    parser.add_argument("--asset-root", type=Path, default=DEFAULT_ASSET_ROOT, help="Directory containing run_*/images assets.")
+    parser.add_argument("--data-root", type=Path, default=REPOSITORY_ROOT, help="Directory containing aggregate force/geometry CSVs.")
+    parser.add_argument("--output", type=Path, default=DATA_DIR / "image_metrics.csv", help="CSV output path.")
+    parser.add_argument("--neighbors", type=int, default=5, help="Nearest observed cases used to impute a missing score.")
+    parser.add_argument("--no-impute", action="store_true", help="Leave missing scores blank instead of imputing them.")
+    return parser.parse_args()
+
+
+def clean_row(row: dict[str, str]) -> dict[str, str]:
+    return {key.strip(): value.strip() for key, value in row.items() if key is not None}
+
+
+def load_features(data_root: Path) -> tuple[dict[int, list[float]], list[str]]:
+    force: dict[int, dict[str, float]] = {}
+    with (data_root / "force_mom_all.csv").open(encoding="utf-8-sig", newline="") as f:
+        for raw in csv.DictReader(f):
+            row = clean_row(raw)
+            force[int(row["run"])] = {key: float(value) for key, value in row.items() if key != "run"}
+
+    geometry: dict[int, dict[str, float]] = {}
+    with (data_root / "geo_parameters_all.csv").open(encoding="utf-8-sig", newline="") as f:
+        for raw in csv.DictReader(f):
+            row = clean_row(raw)
+            geometry[int(row["run"])] = {key: float(value) for key, value in row.items() if key != "run"}
+
+    missing = sorted(set(RUN_IDS) - set(force) | (set(RUN_IDS) - set(geometry)))
+    if missing:
+        raise ValueError(f"Aggregate CSVs are missing WindsorML runs: {missing}")
+    force_fields = [field for field in ("cd", "cs", "cl", "cmy") if field in next(iter(force.values()))]
+    geometry_fields = sorted(next(iter(geometry.values())).keys())
+    labels = [f"force:{field}" for field in force_fields] + [f"geometry:{field}" for field in geometry_fields]
+    features = {
+        run: [force[run][field] for field in force_fields] + [geometry[run][field] for field in geometry_fields]
+        for run in RUN_IDS
+    }
+    return features, labels
+
+
+def valid_png(path: Path) -> bool:
+    if path.name.startswith("._"):
+        return False
+    try:
+        with path.open("rb") as f:
+            return f.read(8) == b"\x89PNG\r\n\x1a\n"
+    except OSError:
+        return False
+
+
+def read_rgb(path: Path) -> np.ndarray:
+    with Image.open(path) as image:
+        return np.asarray(image.convert("RGB"), dtype=np.float32) / 255.0
+
+
+def image_path(asset_root: Path, run: int, view: str, index: int) -> Path:
+    return asset_root / f"run_{run}" / "images" / "velocityxavg" / f"{view}_scan_{index:04d}.png"
+
+
+def low_speed_score(rgb: np.ndarray, crop: tuple[float, float, float, float]) -> tuple[float, float]:
+    height, width, _ = rgb.shape
+    x0, x1, y0, y1 = crop
+    region = rgb[int(y0 * height):int(y1 * height), int(x0 * width):int(x1 * width)]
+    # The published velocity color map is orange at freestream and blue/purple
+    # at low speed. B-R therefore gives a stable low-speed signal while
+    # excluding the neutral gray body.
+    coolness = np.clip(region[:, :, 2] - region[:, :, 0], 0.0, 1.0)
+    area_fraction = float(np.mean(coolness > 0.03))
+    intensity = float(np.mean(coolness))
+    return area_fraction, 0.75 * area_fraction + 0.25 * intensity
+
+
+def observed_run_score(asset_root: Path, run: int) -> tuple[float, float, float, int] | None:
+    z_paths = [image_path(asset_root, run, "view1_constz", index) for index in CENTERLINE_Z_INDICES]
+    x_paths = [image_path(asset_root, run, "view2_constx", index) for index in NEAR_WAKE_X_INDICES]
+    paths = z_paths + x_paths
+    if not all(valid_png(path) for path in paths):
+        return None
+
+    centreline = [low_speed_score(read_rgb(path), (0.43, 0.89, 0.47, 0.97)) for path in z_paths]
+    near_base = [low_speed_score(read_rgb(path), (0.23, 0.77, 0.43, 0.96)) for path in x_paths]
+    centreline_area = float(np.mean([value[0] for value in centreline]))
+    near_base_area = float(np.mean([value[0] for value in near_base]))
+    centreline_score = float(np.mean([value[1] for value in centreline]))
+    near_base_score = float(np.mean([value[1] for value in near_base]))
+    return 0.5 * centreline_score + 0.5 * near_base_score, centreline_area, near_base_area, len(paths)
+
+
+def nearest_observed(
+    features: dict[int, list[float]],
+    observed_runs: list[int],
+    target_run: int,
+    count: int,
+) -> list[int]:
+    runs = RUN_IDS
+    matrix = np.asarray([features[run] for run in runs], dtype=float)
+    means = matrix.mean(axis=0)
+    stds = matrix.std(axis=0)
+    stds[stds == 0.0] = 1.0
+    standardized = (matrix - means) / stds
+    target = standardized[target_run]
+    ranked = sorted(observed_runs, key=lambda run: (float(np.linalg.norm(standardized[run] - target)), run))
+    return ranked[: max(1, min(count, len(ranked)))]
+
+
+def main() -> None:
+    args = parse_args()
+    features, _ = load_features(args.data_root)
+    values: dict[int, tuple[float, float, float, int]] = {}
+    observed: dict[int, bool] = {}
+    neighbors: dict[int, list[int]] = {}
+    for run in RUN_IDS:
+        value = observed_run_score(args.asset_root, run)
+        if value is not None:
+            values[run] = value
+            observed[run] = True
+
+    observed_runs = sorted(values)
+    missing_runs = sorted(set(RUN_IDS) - set(observed_runs))
+    if not observed_runs:
+        raise SystemExit(f"No complete targeted velocity-image sets found under {args.asset_root}")
+    if missing_runs and args.no_impute:
+        for run in missing_runs:
+            observed[run] = False
+            neighbors[run] = []
+    else:
+        for run in missing_runs:
+            nearest = nearest_observed(features, observed_runs, run, args.neighbors)
+            array = np.asarray([values[neighbor] for neighbor in nearest], dtype=float)
+            values[run] = tuple(float(value) for value in array.mean(axis=0))  # type: ignore[assignment]
+            observed[run] = False
+            neighbors[run] = nearest
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    with args.output.open("w", encoding="utf-8", newline="") as f:
+        fieldnames = [
+            "run",
+            "image_wake_score",
+            "image_wake_observed",
+            "centreline_low_speed_area",
+            "near_base_low_speed_area",
+            "velocity_images",
+            "velocity_slices",
+            "imputation_neighbors",
+        ]
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        for run in RUN_IDS:
+            value = values.get(run)
+            writer.writerow(
+                {
+                    "run": run,
+                    "image_wake_score": "" if value is None else value[0],
+                    "image_wake_observed": str(observed.get(run, False)).lower(),
+                    "centreline_low_speed_area": "" if value is None else value[1],
+                    "near_base_low_speed_area": "" if value is None else value[2],
+                    "velocity_images": 0 if value is None or not observed.get(run, False) else int(value[3]),
+                    "velocity_slices": "Z-4;Z-5;X-53;X-55;X-57",
+                    "imputation_neighbors": ";".join(str(value) for value in neighbors.get(run, [])),
+                }
+            )
+    print(f"Wrote {args.output}")
+    print(f"Observed: {len(observed_runs)}; imputed/missing: {len(missing_runs)}")
+
+
+if __name__ == "__main__":
+    main()

splits/create_example_figures.py

@@ -0,0 +1,181 @@
+"""Create WindsorML geometry and image-wake examples for the report."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import os
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+from PIL import Image
+
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+REPOSITORY_ROOT = SCRIPT_DIR.parent
+DATA_DIR = SCRIPT_DIR
+DOCS_DIR = SCRIPT_DIR
+DEFAULT_ASSET_ROOT = Path(os.environ.get("WINDSORML_ASSET_ROOT", REPOSITORY_ROOT.parent / "windsorml_hf_assets"))
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Create WindsorML report example figures.")
+    parser.add_argument("--data-root", type=Path, default=DATA_DIR, help="Directory containing force and metric CSVs.")
+    parser.add_argument("--force-root", type=Path, default=REPOSITORY_ROOT, help="Directory containing force_mom_all.csv.")
+    parser.add_argument("--asset-root", type=Path, default=DEFAULT_ASSET_ROOT, help="Directory containing run_*/ PNG assets.")
+    parser.add_argument("--output-dir", type=Path, default=DOCS_DIR, help="Directory for report figures.")
+    return parser.parse_args()
+
+
+def clean_row(row: dict[str, str]) -> dict[str, str]:
+    return {key.strip(): value.strip() for key, value in row.items() if key is not None}
+
+
+def load_force(force_root: Path) -> dict[int, dict[str, float]]:
+    candidates = [
+        force_root / "force_mom_all.csv",
+        force_root / "data" / "force_mom_all.csv",
+        REPOSITORY_ROOT / "force_mom_all.csv",
+        REPOSITORY_ROOT / "data" / "force_mom_all.csv",
+    ]
+    force_path = next((path for path in candidates if path.exists()), candidates[0])
+    with force_path.open(encoding="utf-8-sig", newline="") as f:
+        return {
+            int(clean_row(raw)["run"]): {
+                "cd": float(clean_row(raw)["cd"]),
+                "cl": float(clean_row(raw)["cl"]),
+            }
+            for raw in csv.DictReader(f)
+        }
+
+
+def load_metric(path: Path, column: str, observed_column: str) -> tuple[dict[int, float], set[int]]:
+    scores: dict[int, float] = {}
+    observed: set[int] = set()
+    with path.open(encoding="utf-8-sig", newline="") as f:
+        for raw in csv.DictReader(f):
+            row = clean_row(raw)
+            if row.get(column, ""):
+                run = int(row["run"])
+                scores[run] = float(row[column])
+                if row.get(observed_column, "true").lower() == "true":
+                    observed.add(run)
+    return scores, observed
+
+
+def low_high(scores: dict[int, float], observed: set[int]) -> tuple[int, int]:
+    ordered = sorted(observed, key=lambda run: (scores[run], run))
+    if not ordered:
+        raise ValueError("No observed metric cases are available for examples")
+    return ordered[0], ordered[-1]
+
+
+def read_rgb(path: Path) -> np.ndarray:
+    with Image.open(path) as image:
+        return np.asarray(image.convert("RGB"), dtype=np.float32) / 255.0
+
+
+def velocity_path(asset_root: Path, run: int, view: str, index: int) -> Path:
+    return asset_root / f"run_{run}" / "images" / "velocityxavg" / f"{view}_scan_{index:04d}.png"
+
+
+def wake_crop(rgb: np.ndarray, view: str) -> np.ndarray:
+    height, width, _ = rgb.shape
+    if view == "view1_constz":
+        return rgb[int(0.37 * height):int(0.98 * height), int(0.04 * width):int(0.94 * width)]
+    return rgb[int(0.28 * height):int(0.98 * height), int(0.14 * width):int(0.86 * width)]
+
+
+def make_wake_examples(data_root: Path, asset_root: Path, output_dir: Path, force: dict[int, dict[str, float]]) -> tuple[int, int]:
+    scores, observed = load_metric(data_root / "image_metrics.csv", "image_wake_score", "image_wake_observed")
+    low_run, high_run = low_high(scores, observed)
+    views = [("view1_constz", 5, "near-centreline z-plane"), ("view2_constx", 53, "near-base x-plane")]
+    fig, axes = plt.subplots(2, 2, figsize=(11.0, 6.2), constrained_layout=True)
+    for row, (view, index, label) in enumerate(views):
+        for col, (score_label, run) in enumerate([("Low wake score", low_run), ("High wake score", high_run)]):
+            axes[row, col].imshow(wake_crop(read_rgb(velocity_path(asset_root, run, view, index)), view))
+            axes[row, col].set_axis_off()
+            axes[row, col].set_title(
+                f"{score_label}: run_{run}\n{label}, score={scores[run]:.4f}, "
+                f"Cd={force[run]['cd']:.4f}, Cl={force[run]['cl']:.4f}",
+                fontsize=9,
+            )
+    fig.suptitle("Image-wake split examples from streamwise-velocity PNGs", fontsize=12)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    fig.savefig(output_dir / "wake_score_examples.png", dpi=180)
+    plt.close(fig)
+    return low_run, high_run
+
+
+def geometry_path(asset_root: Path, run: int) -> Path:
+    return asset_root / f"run_{run}" / "images" / f"windsor_{run}.png"
+
+
+def transparent_silhouette(rgb: np.ndarray, color: str, alpha: float) -> np.ndarray:
+    color_rgb = np.asarray([int(color[index:index + 2], 16) for index in (1, 3, 5)], dtype=np.float32) / 255.0
+    brightness = rgb.mean(axis=2)
+    mask = brightness > 0.08
+    rgba = np.zeros((*rgb.shape[:2], 4), dtype=np.float32)
+    rgba[:, :, :3] = color_rgb
+    rgba[:, :, 3] = mask.astype(np.float32) * alpha
+    return rgba
+
+
+def content_bounds(images: list[np.ndarray], padding: int = 20) -> tuple[slice, slice]:
+    mask = np.zeros(images[0].shape[:2], dtype=bool)
+    for rgb in images:
+        mask |= rgb.mean(axis=2) > 0.08
+    rows, cols = np.where(mask)
+    if len(rows) == 0:
+        return slice(0, images[0].shape[0]), slice(0, images[0].shape[1])
+    y0, y1 = max(0, int(rows.min()) - padding), min(images[0].shape[0], int(rows.max()) + padding + 1)
+    x0, x1 = max(0, int(cols.min()) - padding), min(images[0].shape[1], int(cols.max()) + padding + 1)
+    return slice(y0, y1), slice(x0, x1)
+
+
+def make_geometry_examples(data_root: Path, asset_root: Path, output_dir: Path, force: dict[int, dict[str, float]]) -> tuple[int, int]:
+    scores, observed = load_metric(data_root / "chamfer_metrics.csv", "ood_score", "geometry_observed")
+    available = {run for run in observed if geometry_path(asset_root, run).exists()}
+    low_run, high_run = low_high(scores, available)
+    low_rgb = read_rgb(geometry_path(asset_root, low_run))
+    high_rgb = read_rgb(geometry_path(asset_root, high_run))
+    union_y, union_x = content_bounds([low_rgb, high_rgb], padding=28)
+    low_y, low_x = content_bounds([low_rgb], padding=28)
+    high_y, high_x = content_bounds([high_rgb], padding=28)
+
+    fig = plt.figure(figsize=(11.0, 5.8), constrained_layout=True)
+    grid = fig.add_gridspec(2, 2, height_ratios=(1.0, 1.15))
+    axes = [fig.add_subplot(grid[0, 0]), fig.add_subplot(grid[0, 1]), fig.add_subplot(grid[1, :])]
+    for ax, rgb, label, run in [
+        (axes[0], low_rgb[low_y, low_x], "Low geometry score", low_run),
+        (axes[1], high_rgb[high_y, high_x], "High geometry score", high_run),
+    ]:
+        ax.imshow(rgb)
+        ax.set_axis_off()
+        ax.set_title(
+            f"{label}: run_{run}\nscore={scores[run]:.5f}, Cd={force[run]['cd']:.4f}, Cl={force[run]['cl']:.4f}",
+            fontsize=9,
+        )
+    axes[2].imshow(transparent_silhouette(low_rgb[union_y, union_x], "#6b7280", 0.55))
+    axes[2].imshow(transparent_silhouette(high_rgb[union_y, union_x], "#008c95", 0.55))
+    axes[2].set_axis_off()
+    axes[2].set_title(f"Transparent side-view overlay: run_{low_run} (gray) and run_{high_run} (teal)", fontsize=10)
+    fig.suptitle("STL-Chamfer geometry split examples", fontsize=12)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    fig.savefig(output_dir / "geometry_score_examples.png", dpi=180)
+    plt.close(fig)
+    return low_run, high_run
+
+
+def main() -> None:
+    args = parse_args()
+    force = load_force(args.force_root)
+    wake_runs = make_wake_examples(args.data_root, args.asset_root, args.output_dir, force)
+    geometry_runs = make_geometry_examples(args.data_root, args.asset_root, args.output_dir, force)
+    print(f"Wrote {args.output_dir / 'wake_score_examples.png'} using runs {wake_runs}")
+    print(f"Wrote {args.output_dir / 'geometry_score_examples.png'} using runs {geometry_runs}")
+
+
+if __name__ == "__main__":
+    main()

splits/download_hf_inputs.py

@@ -0,0 +1,207 @@
+"""Download WindsorML inputs needed to regenerate the split package.
+
+Default behavior downloads the two small aggregate CSV files used by the split
+generator. Large per-run
+assets should be kept outside this repository, for example:
+
+    python3 splits/download_hf_inputs.py \
+      --output-dir ../windsorml_hf_assets \
+      --include-stls --include-wake-images --include-geometry-images \
+      --workers 6 --allow-missing
+"""
+
+from __future__ import annotations
+
+import argparse
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import os
+from pathlib import Path
+import random
+import time
+from urllib.error import HTTPError, URLError
+from urllib.parse import quote
+from urllib.request import Request, urlopen
+
+
+REPO_ID = "neashton/windsorml"
+REVISION = "main"
+N_CASES = 355
+RUN_IDS = list(range(N_CASES))
+AGGREGATE_FILES = [
+    "force_mom_all.csv",
+    "geo_parameters_all.csv",
+]
+
+# z ranges from -0.4 to 0.4 over 10 images; indices 4 and 5 bracket z=0.
+# x ranges from -0.5 to 1.0 over 80 images; indices 53, 55, and 57 are
+# immediately behind the Windsor base at x=0.48 m.
+WAKE_IMAGE_PATHS = [
+    *(f"images/velocityxavg/view1_constz_scan_{index:04d}.png" for index in (4, 5)),
+    *(f"images/velocityxavg/view2_constx_scan_{index:04d}.png" for index in (53, 55, 57)),
+]
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Download WindsorML split-regeneration inputs.")
+    parser.add_argument("--repo-id", default=REPO_ID, help=f"Hugging Face dataset repository. Default: {REPO_ID}")
+    parser.add_argument("--revision", default=REVISION, help=f"Hub branch, tag, or revision. Default: {REVISION}")
+    parser.add_argument("--output-dir", type=Path, default=Path("data"), help="Directory where files are written.")
+    parser.add_argument("--include-stls", action="store_true", help="Download run_*/windsor_*.stl files.")
+    parser.add_argument(
+        "--include-wake-images",
+        action="store_true",
+        help="Download the five velocity PNGs per run used by the image_wake score.",
+    )
+    parser.add_argument(
+        "--include-geometry-images",
+        action="store_true",
+        help="Download run_*/images/windsor_*.png side-view geometry images for the report.",
+    )
+    parser.add_argument("--runs", default="all", help="Run IDs for per-run downloads: all or a comma/range expression.")
+    parser.add_argument("--workers", type=int, default=4, help="Parallel download workers.")
+    parser.add_argument("--retries", type=int, default=6, help="Retries for throttling and transient failures.")
+    parser.add_argument("--retry-sleep", type=float, default=4.0, help="Initial retry delay in seconds.")
+    parser.add_argument("--overwrite", action="store_true", help="Redownload existing non-empty files.")
+    parser.add_argument(
+        "--allow-missing",
+        action="store_true",
+        help="Finish successfully when a requested Hub file returns 404; all misses are still reported.",
+    )
+    parser.add_argument("--dry-run", action="store_true", help="Print the requested file list without downloading.")
+    return parser.parse_args()
+
+
+def parse_run_expression(expr: str) -> list[int]:
+    expr = expr.strip().lower()
+    if expr == "all":
+        return RUN_IDS.copy()
+    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)
+    invalid = [run for run in runs if run not in RUN_IDS]
+    if invalid:
+        raise SystemExit(f"Run IDs must be in 0..{N_CASES - 1}; invalid values: {invalid}")
+    return runs
+
+
+def hub_url(repo_id: str, revision: str, rel_path: str) -> str:
+    encoded = "/".join(quote(part) for part in rel_path.split("/"))
+    return f"https://huggingface.co/datasets/{repo_id}/resolve/{quote(revision, safe='')}/{encoded}"
+
+
+def retry_delay(base: float, attempt: int, retry_after: str | None = None) -> float:
+    if retry_after:
+        try:
+            return max(base, float(retry_after))
+        except ValueError:
+            pass
+    return base * (2**attempt) + random.random()
+
+
+def download_one(
+    repo_id: str,
+    revision: str,
+    output_dir: Path,
+    rel_path: str,
+    overwrite: bool,
+    retries: int,
+    retry_sleep: float,
+) -> tuple[str, str]:
+    destination = output_dir / rel_path
+    if destination.exists() and destination.stat().st_size > 0 and not overwrite:
+        return rel_path, "exists"
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    headers: dict[str, str] = {}
+    if os.environ.get("HF_TOKEN"):
+        headers["Authorization"] = f"Bearer {os.environ['HF_TOKEN']}"
+
+    for attempt in range(retries + 1):
+        request = Request(hub_url(repo_id, revision, rel_path), headers=headers)
+        part = destination.with_name(destination.name + ".part")
+        try:
+            with urlopen(request, timeout=180) as response, part.open("wb") as output:
+                while chunk := response.read(1024 * 1024):
+                    output.write(chunk)
+            part.replace(destination)
+            return rel_path, "ok"
+        except HTTPError as exc:
+            part.unlink(missing_ok=True)
+            retryable = exc.code == 429 or 500 <= exc.code <= 599
+            if retryable and attempt < retries:
+                time.sleep(retry_delay(retry_sleep, attempt, exc.headers.get("Retry-After")))
+                continue
+            return rel_path, f"http_{exc.code}"
+        except (OSError, URLError) as exc:
+            part.unlink(missing_ok=True)
+            if attempt < retries:
+                time.sleep(retry_delay(retry_sleep, attempt))
+                continue
+            reason = getattr(exc, "reason", str(exc))
+            return rel_path, f"error:{reason}"
+    return rel_path, "failed"
+
+
+def requested_files(args: argparse.Namespace) -> list[str]:
+    files = AGGREGATE_FILES.copy()
+    for run in parse_run_expression(args.runs):
+        if args.include_stls:
+            files.append(f"run_{run}/windsor_{run}.stl")
+        if args.include_wake_images:
+            files.extend(f"run_{run}/{path}" for path in WAKE_IMAGE_PATHS)
+        if args.include_geometry_images:
+            files.append(f"run_{run}/images/windsor_{run}.png")
+    return files
+
+
+def main() -> None:
+    args = parse_args()
+    files = requested_files(args)
+    print(f"Repository: {args.repo_id}@{args.revision}")
+    print(f"Output dir: {args.output_dir}")
+    print(f"Files: {len(files)}")
+    if args.dry_run:
+        for path in files:
+            print(path)
+        return
+
+    failures: list[tuple[str, str]] = []
+    counts: dict[str, int] = {}
+    with ThreadPoolExecutor(max_workers=max(1, args.workers)) as pool:
+        futures = [
+            pool.submit(
+                download_one,
+                args.repo_id,
+                args.revision,
+                args.output_dir,
+                path,
+                args.overwrite,
+                args.retries,
+                args.retry_sleep,
+            )
+            for path in files
+        ]
+        for future in as_completed(futures):
+            path, status = future.result()
+            counts[status] = counts.get(status, 0) + 1
+            if status not in {"ok", "exists"}:
+                failures.append((path, status))
+                print(f"{status:<12s} {path}")
+
+    print("Summary: " + ", ".join(f"{key}={value}" for key, value in sorted(counts.items())))
+    if failures and not args.allow_missing:
+        raise SystemExit(f"{len(failures)} downloads failed; rerun with --allow-missing only if the Hub mirror is incomplete.")
+
+
+if __name__ == "__main__":
+    main()

splits/generate_splits.py

@@ -0,0 +1,329 @@
+"""Generate deterministic train/validation/test splits for WindsorML.
+
+Split families:
+  1. full         - seed-42 random split, approximately 80/10/10
+  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-Chamfer local-isolation split
+  6. high_drag    - OOD high-drag split from fixed-reference force coefficients
+  7. low_drag     - OOD low-drag split from fixed-reference force coefficients
+  8. image_wake   - OOD image-derived low-speed wake split
+
+For every OOD split, validation is drawn from the training-side population so
+model selection does not see the held-out extreme regime.
+"""
+
+from __future__ import annotations
+
+import csv
+import hashlib
+import json
+import math
+import os
+import random
+from pathlib import Path
+
+import numpy as np
+
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+REPOSITORY_ROOT = SCRIPT_DIR.parent
+PACKAGE_ROOT = SCRIPT_DIR
+DATA_DIR = SCRIPT_DIR
+SPLITS_DIR = SCRIPT_DIR
+DATA_ROOT = Path(os.environ.get("WINDSORML_DATA_ROOT", REPOSITORY_ROOT))
+CHAMFER_METRICS = "chamfer_metrics.csv"
+IMAGE_METRICS = "image_metrics.csv"
+
+N_CASES = 355
+RUN_IDS = list(range(N_CASES))
+SEED = 42
+FULL_TRAIN_COUNT = 284
+FULL_VAL_COUNT = 35
+FULL_TEST_COUNT = 36
+MEDIUM_FRACTION = 1 / 3
+SCARCE_FRACTION = 1 / 6
+SUPER_SCARCE_FRACTION = 1 / 36
+OOD_TEST_FRACTION = 0.2
+VAL_FRACTION = 0.1
+VAL_FRACTION_OF_POOL = VAL_FRACTION / (1 - OOD_TEST_FRACTION)
+
+
+def case_id(run: int) -> str:
+    return f"run_{run}"
+
+
+def run_id(case: str) -> int:
+    if not case.startswith("run_"):
+        raise ValueError(f"Malformed case ID: {case!r}")
+    return int(case.split("_", 1)[1])
+
+
+def make_case_ids(values: list[int]) -> list[str]:
+    return [case_id(value) for value in sorted(values)]
+
+
+def _rng(salt: str) -> random.Random:
+    seed_bytes = hashlib.sha256(f"{SEED}:{salt}".encode("utf-8")).digest()[:8]
+    return random.Random(int.from_bytes(seed_bytes, "big"))
+
+
+def _unit_hash(run: int, salt: str) -> float:
+    seed = hashlib.sha256(f"{SEED}:{salt}:{run}".encode("utf-8")).digest()[:8]
+    return int.from_bytes(seed, "big") / 2**64
+
+
+# Generated once with torch.randperm(355, generator=torch.Generator().manual_seed(42)).
+# The IDs are committed so split regeneration does not require PyTorch.
+FULL_TRAIN_IDS = [
+    0, 1, 2, 3, 4, 5, 6, 9, 10, 12, 13, 14, 15, 16, 17, 19, 20, 21, 22, 24, 26, 29, 30, 31, 33, 34, 35,
+    36, 38, 39, 40, 41, 42, 45, 48, 49, 52, 53, 54, 55, 59, 60, 61, 62, 63, 64, 65, 67, 68, 70, 71, 72, 73,
+    74, 75, 76, 78, 79, 80, 81, 82, 84, 86, 87, 88, 90, 91, 92, 93, 96, 101, 102, 103, 105, 106, 107, 108,
+    109, 110, 111, 112, 114, 115, 116, 117, 118, 119, 120, 121, 122, 124, 126, 127, 128, 129, 131, 132, 133,
+    134, 135, 138, 140, 141, 142, 143, 144, 145, 146, 147, 150, 151, 152, 153, 154, 155, 157, 158, 159, 160,
+    161, 162, 163, 164, 165, 166, 167, 169, 170, 171, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183,
+    184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204,
+    205, 206, 207, 208, 209, 211, 212, 213, 214, 215, 217, 218, 219, 220, 221, 223, 224, 225, 226, 227, 228,
+    229, 230, 231, 233, 234, 235, 237, 238, 239, 240, 241, 243, 245, 246, 247, 248, 249, 251, 252, 254, 255,
+    258, 259, 260, 261, 262, 263, 264, 265, 266, 268, 269, 271, 272, 275, 276, 277, 278, 280, 281, 282, 284,
+    285, 286, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 301, 302, 303, 304, 306, 307, 308, 309,
+    310, 311, 312, 313, 314, 315, 316, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 332,
+    334, 335, 337, 338, 339, 340, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353,
+]
+FULL_VAL_IDS = [
+    8, 11, 25, 27, 37, 43, 44, 46, 50, 51, 56, 57, 77, 83, 94, 99, 137, 149, 156, 168, 210, 222, 236, 242,
+    244, 250, 267, 273, 274, 279, 287, 300, 305, 317, 331,
+]
+FULL_TEST_IDS = [
+    7, 18, 23, 28, 32, 47, 58, 66, 69, 85, 89, 95, 97, 98, 100, 104, 113, 123, 125, 130, 136, 139, 148, 172,
+    216, 232, 253, 256, 257, 270, 283, 299, 333, 336, 341, 354,
+]
+
+
+def _split_pool(pool: list[int], *, salt: str) -> tuple[list[int], list[int]]:
+    shuffled = pool.copy()
+    _rng(salt).shuffle(shuffled)
+    n_val = round(len(pool) * VAL_FRACTION_OF_POOL)
+    return sorted(shuffled[n_val:]), sorted(shuffled[:n_val])
+
+
+def _candidate_paths(filename: str) -> list[Path]:
+    roots = [
+        DATA_ROOT,
+        DATA_ROOT / "data",
+        DATA_DIR,
+        PACKAGE_ROOT,
+        REPOSITORY_ROOT,
+        REPOSITORY_ROOT / "data",
+        Path.cwd(),
+        Path.cwd() / "data",
+    ]
+    paths: list[Path] = []
+    seen: set[Path] = set()
+    for root in roots:
+        path = root / filename
+        key = path.resolve() if path.exists() else path.absolute()
+        if key not in seen:
+            paths.append(path)
+            seen.add(key)
+    return paths
+
+
+def _clean_row(row: dict[str, str]) -> dict[str, str]:
+    return {key.strip(): value.strip() for key, value in row.items() if key is not None}
+
+
+def load_table(filename: str) -> tuple[dict[int, dict[str, float]], str]:
+    for path in _candidate_paths(filename):
+        if not path.exists():
+            continue
+        records: dict[int, dict[str, float]] = {}
+        with path.open(encoding="utf-8-sig", newline="") as f:
+            for raw in csv.DictReader(f):
+                row = _clean_row(raw)
+                records[int(row["run"])] = {key: float(value) for key, value in row.items() if key != "run"}
+        missing = sorted(set(RUN_IDS) - set(records))
+        if missing:
+            raise ValueError(f"{path} is missing WindsorML runs: {missing}")
+        return records, str(path)
+    raise FileNotFoundError(f"{filename} not found; run splits/download_hf_inputs.py")
+
+
+def load_force_mom() -> tuple[dict[int, dict[str, float]], str]:
+    records, source = load_table("force_mom_all.csv")
+    required = {"cd", "cl"}
+    if not required <= set(next(iter(records.values()))):
+        raise ValueError(f"{source} must contain {sorted(required)}")
+    return records, source
+
+
+def load_geo_parameters() -> tuple[dict[int, dict[str, float]], str]:
+    return load_table("geo_parameters_all.csv")
+
+
+def _standardized_matrix(records: dict[int, dict[str, float]], fields: list[str], runs: list[int]) -> np.ndarray:
+    matrix = np.asarray([[records[run][field] for field in fields] for run in runs], dtype=float)
+    means = matrix.mean(axis=0)
+    stds = matrix.std(axis=0)
+    stds[stds == 0.0] = 1.0
+    return (matrix - means) / stds
+
+
+def load_metric_scores(filename: str, column: str) -> tuple[dict[int, float], str]:
+    for path in _candidate_paths(filename):
+        if not path.exists():
+            continue
+        scores: dict[int, float] = {}
+        with path.open(encoding="utf-8-sig", newline="") as f:
+            for raw in csv.DictReader(f):
+                row = _clean_row(raw)
+                if row.get(column, ""):
+                    scores[int(row["run"])] = float(row[column])
+        missing = sorted(set(RUN_IDS) - set(scores))
+        if missing:
+            raise ValueError(f"{path} is missing {column} for runs: {missing}")
+        return scores, str(path)
+    raise FileNotFoundError(f"{filename} not found; compute it before running this generator")
+
+
+def force_scores(records: dict[int, dict[str, float]]) -> dict[str, dict[int, float]]:
+    cd = {run: row["cd"] for run, row in records.items()}
+    return {"high_drag": cd, "low_drag": {run: -value for run, value in cd.items()}}
+
+
+def ranked_ood_split(scores: dict[int, float], *, salt: str) -> tuple[list[int], list[int], list[int]]:
+    ranked = sorted(scores, key=lambda run: (scores[run], run))
+    n_test = round(len(ranked) * OOD_TEST_FRACTION)
+    test = sorted(ranked[-n_test:])
+    train, val = _split_pool(sorted(ranked[:-n_test]), salt=salt)
+    return train, val, test
+
+
+def diverse_training_order(
+    force_records: dict[int, dict[str, float]],
+    geo_records: dict[int, dict[str, float]],
+) -> list[int]:
+    feature_rows: dict[int, list[float]] = {run: [] for run in FULL_TRAIN_IDS}
+    for field in ["cd", "cl"]:
+        values = np.asarray([force_records[run][field] for run in FULL_TRAIN_IDS], dtype=float)
+        mean, std = float(values.mean()), float(values.std()) or 1.0
+        for run in FULL_TRAIN_IDS:
+            feature_rows[run].append((force_records[run][field] - mean) / std)
+    for field in sorted(next(iter(geo_records.values())).keys()):
+        values = np.asarray([geo_records[run][field] for run in FULL_TRAIN_IDS], dtype=float)
+        mean, std = float(values.mean()), float(values.std()) or 1.0
+        for run in FULL_TRAIN_IDS:
+            feature_rows[run].append((geo_records[run][field] - mean) / std)
+
+    def distance(a: int, b: int) -> float:
+        return math.sqrt(sum((x - y) ** 2 for x, y in zip(feature_rows[a], feature_rows[b])))
+
+    first = max(
+        FULL_TRAIN_IDS,
+        key=lambda run: (
+            math.sqrt(sum(value * value for value in feature_rows[run])),
+            _unit_hash(run, "sparse_first_tie_break"),
+        ),
+    )
+    selected = [first]
+    remaining = [run for run in FULL_TRAIN_IDS if run != first]
+    while remaining:
+        next_run = max(
+            remaining,
+            key=lambda run: (
+                min(distance(run, chosen) for chosen in selected),
+                _unit_hash(run, "sparse_tie_break"),
+            ),
+        )
+        selected.append(next_run)
+        remaining.remove(next_run)
+    return selected
+
+
+def generate_splits() -> tuple[dict[str, list[str]], tuple[str, str, str, str]]:
+    force_records, force_source = load_force_mom()
+    geo_records, geo_source = load_geo_parameters()
+    geometry_scores, geometry_source = load_metric_scores(CHAMFER_METRICS, "ood_score")
+    image_scores, image_source = load_metric_scores(IMAGE_METRICS, "image_wake_score")
+
+    splits: dict[str, list[str]] = {
+        "full_train": make_case_ids(FULL_TRAIN_IDS),
+        "full_val": make_case_ids(FULL_VAL_IDS),
+        "full_test": make_case_ids(FULL_TEST_IDS),
+    }
+    order = diverse_training_order(force_records, geo_records)
+    sizes = {
+        "medium": round(len(FULL_TRAIN_IDS) * MEDIUM_FRACTION),
+        "scarce": round(len(FULL_TRAIN_IDS) * SCARCE_FRACTION),
+        "super_scarce": max(1, round(len(FULL_TRAIN_IDS) * SUPER_SCARCE_FRACTION)),
+    }
+    for name, size in sizes.items():
+        splits[f"{name}_train"] = make_case_ids(order[:size])
+        splits[f"{name}_val"] = splits["full_val"]
+        splits[f"{name}_test"] = splits["full_test"]
+
+    score_families = {**force_scores(force_records), "geometry": geometry_scores, "image_wake": image_scores}
+    for name, scores in score_families.items():
+        train, val, test = ranked_ood_split(scores, 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)
+    return splits, (force_source, geo_source, geometry_source, image_source)
+
+
+def validate_splits(splits: dict[str, list[str]]) -> None:
+    all_cases = {case_id(run) for run in RUN_IDS}
+    families = sorted({key.rsplit("_", 1)[0] for key in splits})
+    for name in families:
+        train = set(splits[f"{name}_train"])
+        val = set(splits[f"{name}_val"])
+        test = set(splits[f"{name}_test"])
+        assert not (train & val), f"{name}: train/val overlap"
+        assert not (train & test), f"{name}: train/test overlap"
+        assert not (val & test), f"{name}: val/test overlap"
+        assert train | val | test <= all_cases, f"{name}: invalid run included"
+
+    assert (len(splits["full_train"]), len(splits["full_val"]), len(splits["full_test"])) == (284, 35, 36)
+    for name in ["medium", "scarce", "super_scarce"]:
+        assert splits[f"{name}_val"] == splits["full_val"]
+        assert splits[f"{name}_test"] == splits["full_test"]
+    assert set(splits["super_scarce_train"]) < set(splits["scarce_train"])
+    assert set(splits["scarce_train"]) < set(splits["medium_train"])
+    assert set(splits["medium_train"]) < set(splits["full_train"])
+
+    for name in ["full"]:
+        sizes = tuple(len(splits[f"{name}_{part}"]) for part in ("train", "val", "test"))
+        assert sizes == (284, 35, 36), f"{name}: unexpected sizes {sizes}"
+        assert set().union(*(set(splits[f"{name}_{part}"]) for part in ("train", "val", "test"))) == all_cases
+    for name in ["geometry", "high_drag", "low_drag", "image_wake"]:
+        sizes = tuple(len(splits[f"{name}_{part}"]) for part in ("train", "val", "test"))
+        assert sizes == (248, 36, 71), f"{name}: unexpected sizes {sizes}"
+        assert set().union(*(set(splits[f"{name}_{part}"]) for part in ("train", "val", "test"))) == all_cases
+
+
+def main() -> None:
+    splits, sources = generate_splits()
+    validate_splits(splits)
+    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("WindsorML Splits")
+    print("=" * 60)
+    print(f"  Runs: {N_CASES}")
+    print(f"  Seed: {SEED}")
+    for label, source in zip(["Force/moment", "Geometry parameters", "STL-Chamfer", "Image wake"], sources):
+        print(f"  {label} source: {source}")
+    print()
+    print(f"  {'Split':<18s} {'Train':>6s} {'Val':>6s} {'Test':>6s} {'Total':>6s}")
+    print(f"  {'-' * 46}")
+    for name in sorted({key.rsplit('_', 1)[0] for key in splits}):
+        sizes = [len(splits[f"{name}_{part}"]) for part in ("train", "val", "test")]
+        print(f"  {name:<18s} {sizes[0]:>6d} {sizes[1]:>6d} {sizes[2]:>6d} {sum(sizes):>6d}")
+    print(f"\n  Manifest: {output}")
+    print("All validations passed.")
+
+
+if __name__ == "__main__":
+    main()

splits/image_metrics.csv

@@ -0,0 +1,356 @@
+run,image_wake_score,image_wake_observed,centreline_low_speed_area,near_base_low_speed_area,velocity_images,velocity_slices,imputation_neighbors
+0,0.03877850197553976,true,0.017176292940732352,0.07971135083288218,5,Z-4;Z-5;X-53;X-55;X-57,
+1,0.11175936664484712,true,0.08548508871272179,0.19430046392552472,5,Z-4;Z-5;X-53;X-55;X-57,
+2,0.09873744056086073,true,0.06457468227003901,0.18223418724559404,5,Z-4;Z-5;X-53;X-55;X-57,
+3,0.08169155164058886,true,0.041891856465752275,0.162432775737966,5,Z-4;Z-5;X-53;X-55;X-57,
+4,0.1411331040509459,true,0.12026996560546957,0.2325063845055756,5,Z-4;Z-5;X-53;X-55;X-57,
+5,0.07873306510890984,true,0.06081225619730716,0.13623920497194467,5,Z-4;Z-5;X-53;X-55;X-57,
+6,0.12151503228719832,true,0.10129608657354977,0.20262331733081673,5,Z-4;Z-5;X-53;X-55;X-57,
+7,0.05002508720802104,true,0.020810525984648297,0.10428599214549579,5,Z-4;Z-5;X-53;X-55;X-57,
+8,0.1518974509004773,true,0.1640849796568936,0.21578119174160604,5,Z-4;Z-5;X-53;X-55;X-57,
+9,0.08149589080663742,true,0.046530137158676224,0.15720720625832516,5,Z-4;Z-5;X-53;X-55;X-57,
+10,0.037527198759745944,true,0.015276991317478294,0.07869530688810386,5,Z-4;Z-5;X-53;X-55;X-57,
+11,0.040076591087224445,true,0.014278448890566672,0.08580817623973863,5,Z-4;Z-5;X-53;X-55;X-57,
+12,0.05403811270348723,true,0.02534525607147351,0.10974384036524217,5,Z-4;Z-5;X-53;X-55;X-57,
+13,0.11065698891961617,true,0.0940451847657397,0.18295026299879716,5,Z-4;Z-5;X-53;X-55;X-57,
+14,0.12324622247217319,true,0.08974219831382912,0.21846166593289618,5,Z-4;Z-5;X-53;X-55;X-57,
+15,0.0841924513580682,true,0.05569580764229688,0.1549717691452662,5,Z-4;Z-5;X-53;X-55;X-57,
+16,0.06787510302763539,true,0.036777505138207295,0.13295514309929216,5,Z-4;Z-5;X-53;X-55;X-57,
+17,0.1124978464872093,true,0.07775103812759532,0.20352209842916938,5,Z-4;Z-5;X-53;X-55;X-57,
+18,0.10872274575436655,true,0.08579311899668637,0.18622294967317368,5,Z-4;Z-5;X-53;X-55;X-57,
+19,0.10837345432470852,true,0.09971766075248521,0.1713613233428197,5,Z-4;Z-5;X-53;X-55;X-57,
+20,0.02379629945378361,true,0.010788138081456315,0.04859583007700729,5,Z-4;Z-5;X-53;X-55;X-57,
+21,0.05247670391271904,true,0.025336867161612348,0.1058994446515854,5,Z-4;Z-5;X-53;X-55;X-57,
+22,0.1257161544265483,true,0.10228964808523133,0.21222721467035446,5,Z-4;Z-5;X-53;X-55;X-57,
+23,0.10456202550119444,true,0.07003560043622331,0.19151620860428423,5,Z-4;Z-5;X-53;X-55;X-57,
+24,0.09177046851439355,true,0.06491364665911664,0.16477199398097533,5,Z-4;Z-5;X-53;X-55;X-57,
+25,0.13336812455381072,true,0.10849534415502705,0.22500732015074243,5,Z-4;Z-5;X-53;X-55;X-57,
+26,0.07648182974591561,true,0.04880877479971478,0.14255482740243133,5,Z-4;Z-5;X-53;X-55;X-57,
+27,0.06056268883688161,true,0.030405341638354094,0.12105106832070477,5,Z-4;Z-5;X-53;X-55;X-57,
+28,0.11182376590032649,true,0.07797255777861667,0.2016736989265885,5,Z-4;Z-5;X-53;X-55;X-57,
+29,0.04996005956841298,true,0.02431944968751311,0.10054776494908195,5,Z-4;Z-5;X-53;X-55;X-57,
+30,0.0735869680878733,true,0.045347563021685335,0.1388630840409479,5,Z-4;Z-5;X-53;X-55;X-57,
+31,0.0735869680878733,true,0.045347563021685335,0.1388630840409479,5,Z-4;Z-5;X-53;X-55;X-57,
+32,0.03280933105366002,true,0.01330140304517428,0.06858331735890365,5,Z-4;Z-5;X-53;X-55;X-57,
+33,0.1147474142375048,true,0.09026283503208757,0.19678938539522847,5,Z-4;Z-5;X-53;X-55;X-57,
+34,0.10837076182813471,true,0.09111168784866407,0.18054096791702567,5,Z-4;Z-5;X-53;X-55;X-57,
+35,0.13082252836391298,true,0.10162220544440251,0.22541766989595904,5,Z-4;Z-5;X-53;X-55;X-57,
+36,0.07711185794124864,true,0.03528506564321966,0.15739468637805965,5,Z-4;Z-5;X-53;X-55;X-57,
+37,0.12040165516783553,true,0.08471540623296003,0.21635276034633968,5,Z-4;Z-5;X-53;X-55;X-57,
+38,0.06384989630477943,true,0.03339520154355941,0.12623380526362724,5,Z-4;Z-5;X-53;X-55;X-57,
+39,0.0486665890940582,true,0.0199244473805629,0.10169427258766801,5,Z-4;Z-5;X-53;X-55;X-57,
+40,0.12000091811883898,true,0.11656495113460005,0.18352646594356917,5,Z-4;Z-5;X-53;X-55;X-57,
+41,0.10954779773112451,true,0.07649375026215344,0.1974615051353403,5,Z-4;Z-5;X-53;X-55;X-57,
+42,0.0864340931187311,true,0.04963062581267565,0.16659651961063118,5,Z-4;Z-5;X-53;X-55;X-57,
+43,0.11710611799551775,true,0.0918672140430351,0.20104665867594096,5,Z-4;Z-5;X-53;X-55;X-57,
+44,0.11741473943438584,true,0.1077867434251919,0.18592902016710308,5,Z-4;Z-5;X-53;X-55;X-57,
+45,0.13480146053800168,true,0.11731549641374103,0.21976602200188042,5,Z-4;Z-5;X-53;X-55;X-57,
+46,0.09238860778873452,true,0.07580454888637222,0.1553707436922068,5,Z-4;Z-5;X-53;X-55;X-57,
+47,0.13630857952330844,true,0.11212721781804455,0.22856536982384593,5,Z-4;Z-5;X-53;X-55;X-57,
+48,0.07885151380175778,true,0.06786890231114467,0.1290336488195423,5,Z-4;Z-5;X-53;X-55;X-57,
+49,0.09587273576451748,true,0.07033104735539616,0.16952050730575619,5,Z-4;Z-5;X-53;X-55;X-57,
+50,0.1086000717094707,true,0.08689704710372886,0.18472324914984437,5,Z-4;Z-5;X-53;X-55;X-57,
+51,0.028638593641467345,true,0.011562277169581813,0.059908394545241335,5,Z-4;Z-5;X-53;X-55;X-57,
+52,0.12017025598562592,true,0.09471393817373433,0.20566667439056674,5,Z-4;Z-5;X-53;X-55;X-57,
+53,0.06736326455884638,true,0.0320485193574095,0.13646853458657124,5,Z-4;Z-5;X-53;X-55;X-57,
+54,0.08899690085965162,true,0.056762247808397295,0.16571992717064413,5,Z-4;Z-5;X-53;X-55;X-57,
+55,0.0889997142956714,true,0.06134285474602576,0.1613349988870562,5,Z-4;Z-5;X-53;X-55;X-57,
+56,0.0776363381771215,true,0.047480181200453,0.14683176151967028,5,Z-4;Z-5;X-53;X-55;X-57,
+57,0.14678789583013013,true,0.14559031710079273,0.2212780807653121,5,Z-4;Z-5;X-53;X-55;X-57,
+58,0.12289359760059965,true,0.10661150958432952,0.20095635926246583,5,Z-4;Z-5;X-53;X-55;X-57,
+59,0.11737335128424334,true,0.09052918292017953,0.20300164799940457,5,Z-4;Z-5;X-53;X-55;X-57,
+60,0.04219869369997156,true,0.021015005662514158,0.08393674547151249,5,Z-4;Z-5;X-53;X-55;X-57,
+61,0.100282112579657,true,0.06817693259510926,0.18271924816961124,5,Z-4;Z-5;X-53;X-55;X-57,
+62,0.11021172526122912,true,0.07710745144918418,0.19835509015546804,5,Z-4;Z-5;X-53;X-55;X-57,
+63,0.13280532165981462,true,0.10024537561343903,0.23173525841009837,5,Z-4;Z-5;X-53;X-55;X-57,
+64,0.09825685733150205,true,0.08062345329474435,0.16511212645288317,5,Z-4;Z-5;X-53;X-55;X-57,
+65,0.027033384499960223,true,0.009792741495742628,0.05769809521602696,5,Z-4;Z-5;X-53;X-55;X-57,
+66,0.021395560258590525,true,0.006491967618807936,0.046768917060058944,5,Z-4;Z-5;X-53;X-55;X-57,
+67,0.07937118795997246,true,0.05306955454888637,0.14534764923101554,5,Z-4;Z-5;X-53;X-55;X-57,
+68,0.060493257890865765,true,0.033144582861457154,0.11814280929480092,5,Z-4;Z-5;X-53;X-55;X-57,
+69,0.09800567093988338,true,0.0753088167442641,0.1697869116406898,5,Z-4;Z-5;X-53;X-55;X-57,
+70,0.10525043418019739,true,0.08614361813682311,0.17722755522413003,5,Z-4;Z-5;X-53;X-55;X-57,
+71,0.0774752205907227,true,0.04714383834570697,0.14659456757043318,5,Z-4;Z-5;X-53;X-55;X-57,
+72,0.024929177170606567,true,0.012876190176586554,0.049562862365016065,5,Z-4;Z-5;X-53;X-55;X-57,
+73,0.03488587328954691,true,0.013417799169497924,0.07371549786504379,5,Z-4;Z-5;X-53;X-55;X-57,
+74,0.05287973111282907,true,0.022294314416341596,0.10985085148976477,5,Z-4;Z-5;X-53;X-55;X-57,
+75,0.11071795472249302,true,0.0898929365378969,0.18719602064668706,5,Z-4;Z-5;X-53;X-55;X-57,
+76,0.09593664206860215,true,0.07208616459041148,0.16803246284979612,5,Z-4;Z-5;X-53;X-55;X-57,
+77,0.06820266365094887,true,0.04031657648588566,0.13026160849516658,5,Z-4;Z-5;X-53;X-55;X-57,
+78,0.09141185260539715,true,0.0673469548257204,0.16130677154318607,5,Z-4;Z-5;X-53;X-55;X-57,
+79,0.10475319494756317,true,0.07744746445199446,0.18480849291964127,5,Z-4;Z-5;X-53;X-55;X-57,
+80,0.03089286085824469,true,0.012036774883603876,0.0650078538020196,5,Z-4;Z-5;X-53;X-55;X-57,
+81,0.11646828531348012,true,0.08933402541839688,0.20171807624331972,5,Z-4;Z-5;X-53;X-55;X-57,
+82,0.0635174847087025,true,0.03285621408497966,0.12585294677320033,5,Z-4;Z-5;X-53;X-55;X-57,
+83,0.11226157269532708,true,0.08270547586091187,0.198247517292759,5,Z-4;Z-5;X-53;X-55;X-57,
+84,0.14158110948788227,true,0.16245150161486516,0.19140119271060443,5,Z-4;Z-5;X-53;X-55;X-57,
+85,0.11011414348554606,true,0.07359249821735665,0.20180317957856997,5,Z-4;Z-5;X-53;X-55;X-57,
+86,0.0951495419861941,true,0.07152305901598087,0.16661955087627647,5,Z-4;Z-5;X-53;X-55;X-57,
+87,0.1392124306640168,true,0.11965049704290928,0.22827354683597456,5,Z-4;Z-5;X-53;X-55;X-57,
+88,0.11251064448176903,true,0.07881040015100038,0.20262542384901602,5,Z-4;Z-5;X-53;X-55;X-57,
+89,0.037273550796595174,true,0.012872520028522294,0.08017843613493232,5,Z-4;Z-5;X-53;X-55;X-57,
+90,0.10965789404712134,true,0.08300039847321841,0.19129446245517503,5,Z-4;Z-5;X-53;X-55;X-57,
+91,0.06869256058099894,true,0.033613837506815986,0.13814897437139742,5,Z-4;Z-5;X-53;X-55;X-57,
+92,0.1282584040083785,true,0.09629839352376159,0.22431553957410413,5,Z-4;Z-5;X-53;X-55;X-57,
+93,0.11659601072901604,true,0.0915395222515834,0.2002488500166064,5,Z-4;Z-5;X-53;X-55;X-57,
+94,0.031217667332913472,true,0.014406904072815738,0.0634175729961219,5,Z-4;Z-5;X-53;X-55;X-57,
+95,0.09881762232848125,true,0.08141437020259218,0.1658362069752435,5,Z-4;Z-5;X-53;X-55;X-57,
+96,0.07895083426743557,true,0.044906883100541084,0.15263676393865536,5,Z-4;Z-5;X-53;X-55;X-57,
+97,0.11671080268668668,true,0.07830654125246425,0.21341163963652732,5,Z-4;Z-5;X-53;X-55;X-57,
+98,0.06140261442234819,true,0.03612395662933601,0.117495686903987,5,Z-4;Z-5;X-53;X-55;X-57,
+99,0.1253222270225043,true,0.09875214965815192,0.21477834864420978,5,Z-4;Z-5;X-53;X-55;X-57,
+100,0.10706458130642578,true,0.09580869091061617,0.17267410548460102,5,Z-4;Z-5;X-53;X-55;X-57,
+101,0.1088789903516427,true,0.08006716370957594,0.19236569717677407,5,Z-4;Z-5;X-53;X-55;X-57,
+102,0.10889502211591183,true,0.10489361813682313,0.1665753139940919,5,Z-4;Z-5;X-53;X-55;X-57,
+103,0.10314205073133266,true,0.07663714819009271,0.1814894628448809,5,Z-4;Z-5;X-53;X-55;X-57,
+104,0.12122839287928402,true,0.09890262572878655,0.2042046103257309,5,Z-4;Z-5;X-53;X-55;X-57,
+105,0.08678587044067,true,0.06704180822952058,0.14991570416339278,5,Z-4;Z-5;X-53;X-55;X-57,
+106,0.06300079452833014,true,0.029460016358374228,0.12814554074673262,5,Z-4;Z-5;X-53;X-55;X-57,
+107,0.09877503950233699,true,0.07149789228639739,0.17544684517301887,5,Z-4;Z-5;X-53;X-55;X-57,
+108,0.11726449357680534,true,0.10636429889685836,0.1873865903264471,5,Z-4;Z-5;X-53;X-55;X-57,
+109,0.0992969279563608,true,0.0758976133551445,0.17252440225790666,5,Z-4;Z-5;X-53;X-55;X-57,
+110,0.08545225765863493,true,0.047275701522587144,0.16639288951803566,5,Z-4;Z-5;X-53;X-55;X-57,
+111,0.10206148511414065,true,0.06801282454595026,0.18712524163519176,5,Z-4;Z-5;X-53;X-55;X-57,
+112,0.12127582805526732,true,0.08924043664275827,0.21433906938238997,5,Z-4;Z-5;X-53;X-55;X-57,
+113,0.10638624418967622,true,0.08291467430057464,0.18330106849624794,5,Z-4;Z-5;X-53;X-55;X-57,
+114,0.11040535995463215,true,0.08769766368860367,0.18856399356528908,5,Z-4;Z-5;X-53;X-55;X-57,
+115,0.09841083574947809,true,0.07903401702948701,0.16706360491268132,5,Z-4;Z-5;X-53;X-55;X-57,
+116,0.056621158442902594,true,0.02911371167316807,0.11246138927683931,5,Z-4;Z-5;X-53;X-55;X-57,
+117,0.11140887819658418,true,0.08805995973323266,0.19044904648453712,5,Z-4;Z-5;X-53;X-55;X-57,
+118,0.0823874921786826,true,0.048604557275282075,0.15748821578610694,5,Z-4;Z-5;X-53;X-55;X-57,
+119,0.13938621810917812,true,0.13765283545153306,0.20946444583474647,5,Z-4;Z-5;X-53;X-55;X-57,
+120,0.07044177118575651,true,0.03698198481607315,0.13915322181425985,5,Z-4;Z-5;X-53;X-55;X-57,
+121,0.03085697108023839,true,0.011745522419361604,0.06517763916888027,5,Z-4;Z-5;X-53;X-55;X-57,
+122,0.09526653244956712,true,0.07264324063587937,0.1658098052804794,5,Z-4;Z-5;X-53;X-55;X-57,
+123,0.12235069890145045,true,0.08671904492261232,0.21914333522217797,5,Z-4;Z-5;X-53;X-55;X-57,
+124,0.12126480326711288,true,0.10219317562182795,0.20125239528673575,5,Z-4;Z-5;X-53;X-55;X-57,
+125,0.05839690081578837,true,0.03320540245795059,0.1130141396523262,5,Z-4;Z-5;X-53;X-55;X-57,
+126,0.12427556440495094,true,0.09476741747409925,0.21621471318701457,5,Z-4;Z-5;X-53;X-55;X-57,
+127,0.06251337807737567,true,0.03144556646113837,0.12449845557107357,5,Z-4;Z-5;X-53;X-55;X-57,
+128,0.11731091200935242,true,0.0862136131034772,0.20720780310514827,5,Z-4;Z-5;X-53;X-55;X-57,
+129,0.08275240985421875,true,0.06267380772618598,0.14307738435039544,5,Z-4;Z-5;X-53;X-55;X-57,
+130,0.10252373293072059,true,0.07520133383666794,0.1810367018665858,5,Z-4;Z-5;X-53;X-55;X-57,
+131,0.04057678705962092,true,0.018161727695985907,0.08321112016913938,5,Z-4;Z-5;X-53;X-55;X-57,
+132,0.09409362948598816,true,0.06599004865567719,0.16945099220518048,5,Z-4;Z-5;X-53;X-55;X-57,
+133,0.0772225980356767,true,0.05523310683276708,0.1379630390316757,5,Z-4;Z-5;X-53;X-55;X-57,
+134,0.0772225980356767,true,0.05523310683276708,0.1379630390316757,5,Z-4;Z-5;X-53;X-55;X-57,
+135,0.0552449130630971,true,0.02751614865148274,0.11067351706385069,5,Z-4;Z-5;X-53;X-55;X-57,
+136,0.11806124882341407,true,0.0943403695314794,0.20105115258143272,5,Z-4;Z-5;X-53;X-55;X-57,
+137,0.10847272660735664,true,0.08146050920682857,0.18990598609276685,5,Z-4;Z-5;X-53;X-55;X-57,
+138,0.10182114024487765,true,0.06704128392265425,0.18783050392830536,5,Z-4;Z-5;X-53;X-55;X-57,
+139,0.02855358071625331,true,0.015298750052430688,0.05595642596887549,5,Z-4;Z-5;X-53;X-55;X-57,
+140,0.10928731488109017,true,0.08246298393523763,0.19060015405669764,5,Z-4;Z-5;X-53;X-55;X-57,
+141,0.06554771557759262,true,0.03812182794345875,0.12593411794114528,5,Z-4;Z-5;X-53;X-55;X-57,
+142,0.11264486714335228,true,0.08710493477622583,0.19467107069404857,5,Z-4;Z-5;X-53;X-55;X-57,
+143,0.11521976581717802,true,0.09030713896229184,0.19795541343579437,5,Z-4;Z-5;X-53;X-55;X-57,
+144,0.0836744080058199,true,0.045985906631433246,0.16325052610292026,5,Z-4;Z-5;X-53;X-55;X-57,
+145,0.1044851853453729,true,0.07380064804328677,0.18757350870799516,5,Z-4;Z-5;X-53;X-55;X-57,
+146,0.11702218158719813,true,0.08879739734071557,0.20380998924973545,5,Z-4;Z-5;X-53;X-55;X-57,
+147,0.053165118404289766,true,0.02719055408749633,0.10574300056665341,5,Z-4;Z-5;X-53;X-55;X-57,
+148,0.11784197986302969,true,0.12107163080407701,0.17415470690959034,5,Z-4;Z-5;X-53;X-55;X-57,
+149,0.032369672674472334,true,0.013348066356277003,0.06746840749330654,5,Z-4;Z-5;X-53;X-55;X-57,
+150,0.07620329891833336,true,0.04052026970345204,0.15007495693925715,5,Z-4;Z-5;X-53;X-55;X-57,
+151,0.1253168997380211,true,0.08857351830879577,0.2249074711880973,5,Z-4;Z-5;X-53;X-55;X-57,
+152,0.0449787438329796,true,0.02339535883561931,0.08905614643391045,5,Z-4;Z-5;X-53;X-55;X-57,
+153,0.12302710829401428,true,0.11572081707982049,0.19229913120167738,5,Z-4;Z-5;X-53;X-55;X-57,
+154,0.11411546374098203,true,0.09456608363743131,0.19081024413843753,5,Z-4;Z-5;X-53;X-55;X-57,
+155,0.12372695953978927,true,0.09431677572249486,0.21492060883993339,5,Z-4;Z-5;X-53;X-55;X-57,
+156,0.06890746921527743,true,0.04116044838723208,0.13116488349901098,5,Z-4;Z-5;X-53;X-55;X-57,
+157,0.11224952635623109,true,0.10451637934650393,0.17548504336969883,5,Z-4;Z-5;X-53;X-55;X-57,
+158,0.09671192046394925,true,0.07523384086237993,0.16680773316874406,5,Z-4;Z-5;X-53;X-55;X-57,
+159,0.1200738490604276,true,0.08365132544775807,0.2166155133830612,5,Z-4;Z-5;X-53;X-55;X-57,
+160,0.1027239565415993,true,0.07973527746319366,0.1772129500312818,5,Z-4;Z-5;X-53;X-55;X-57,
+161,0.007594402539493079,true,0.002353351369489535,0.0166801132745053,5,Z-4;Z-5;X-53;X-55;X-57,
+162,0.11528737331157862,true,0.0916941927771486,0.19682547707370915,5,Z-4;Z-5;X-53;X-55;X-57,
+163,0.05131789932191742,true,0.02477402374061491,0.10302559208960287,5,Z-4;Z-5;X-53;X-55;X-57,
+164,0.10311385078679494,true,0.07805277672916405,0.1799748762596101,5,Z-4;Z-5;X-53;X-55;X-57,
+165,0.1323239933943378,true,0.10114062958768508,0.2297476882718195,5,Z-4;Z-5;X-53;X-55;X-57,
+166,0.08218959304579927,true,0.0544188582693679,0.151206859384995,5,Z-4;Z-5;X-53;X-55;X-57,
+167,0.03256425613969208,true,0.012507340296128518,0.06879565439338947,5,Z-4;Z-5;X-53;X-55;X-57,
+168,0.11552474705667401,true,0.0867971666456944,0.20225271056229288,5,Z-4;Z-5;X-53;X-55;X-57,
+169,0.030627865425466083,true,0.014135313116060567,0.06235139391820108,5,Z-4;Z-5;X-53;X-55;X-57,
+170,0.11185861833003269,true,0.07153275869300785,0.20786896895062393,5,Z-4;Z-5;X-53;X-55;X-57,
+171,0.11646168301093043,true,0.08574776645274947,0.20557103846432015,5,Z-4;Z-5;X-53;X-55;X-57,
+172,0.11785654385823052,true,0.10305618472379514,0.19211572368379473,5,Z-4;Z-5;X-53;X-55;X-57,
+173,0.11875486858725896,true,0.10898924122310305,0.1882614975518748,5,Z-4;Z-5;X-53;X-55;X-57,
+174,0.08166061870674615,true,0.05135821693720901,0.15299473159798363,5,Z-4;Z-5;X-53;X-55;X-57,
+175,0.12819267467970624,true,0.09958684618933769,0.2206987882605145,5,Z-4;Z-5;X-53;X-55;X-57,
+176,0.12222614814114212,true,0.1215505851264628,0.18416375791611986,5,Z-4;Z-5;X-53;X-55;X-57,
+177,0.12232992545296116,true,0.09800710960110734,0.20816992018402544,5,Z-4;Z-5;X-53;X-55;X-57,
+178,0.05575219335115485,true,0.032364676397802106,0.10714313299643086,5,Z-4;Z-5;X-53;X-55;X-57,
+179,0.11469493903505179,true,0.10468074954909609,0.1823437261919558,5,Z-4;Z-5;X-53;X-55;X-57,
+180,0.1099099709917311,true,0.07791907847825175,0.19688530219056824,5,Z-4;Z-5;X-53;X-55;X-57,
+181,0.11086113009573031,true,0.07392884107210268,0.20327058015617724,5,Z-4;Z-5;X-53;X-55;X-57,
+182,0.0636894285430119,true,0.028815905373096765,0.13049079767524652,5,Z-4;Z-5;X-53;X-55;X-57,
+183,0.040819810061526796,true,0.019446017365043415,0.0826193289896928,5,Z-4;Z-5;X-53;X-55;X-57,
+184,0.1031332472870779,true,0.07461646952728493,0.18346537691579054,5,Z-4;Z-5;X-53;X-55;X-57,
+185,0.1075489198745446,true,0.08482944297638523,0.18408118240270868,5,Z-4;Z-5;X-53;X-55;X-57,
+186,0.0864859424105302,true,0.05126908476993415,0.16499331882644466,5,Z-4;Z-5;X-53;X-55;X-57,
+187,0.062390095274532986,true,0.037175191896313076,0.11887222632993272,5,Z-4;Z-5;X-53;X-55;X-57,
+188,0.12064304966270878,true,0.09292185730464325,0.20889610722458504,5,Z-4;Z-5;X-53;X-55;X-57,
+189,0.05256823788539468,true,0.026734931420661884,0.10477231698043254,5,Z-4;Z-5;X-53;X-55;X-57,
+190,0.11895961037449893,true,0.10600278931252884,0.19165186837631684,5,Z-4;Z-5;X-53;X-55;X-57,
+191,0.13620216794628806,true,0.10909069460173651,0.23494109824028495,5,Z-4;Z-5;X-53;X-55;X-57,
+192,0.061690546350893494,true,0.02617392307369657,0.126862249859741,5,Z-4;Z-5;X-53;X-55;X-57,
+193,0.03165982479238247,true,0.010002202088838556,0.06894858761465603,5,Z-4;Z-5;X-53;X-55;X-57,
+194,0.06530614816145165,true,0.0346918124239755,0.12838357730324945,5,Z-4;Z-5;X-53;X-55;X-57,
+195,0.09339953426492997,true,0.05854017239209765,0.17505390931158282,5,Z-4;Z-5;X-53;X-55;X-57,
+196,0.124276889582019,true,0.08982975756050501,0.22089792444761827,5,Z-4;Z-5;X-53;X-55;X-57,
+197,0.08605707162685367,true,0.07661827314290508,0.13830555889087603,5,Z-4;Z-5;X-53;X-55;X-57,
+198,0.13740447977243408,true,0.11368860366595361,0.22958618854320925,5,Z-4;Z-5;X-53;X-55;X-57,
+199,0.05643961511017226,true,0.023984155446499726,0.11709811670251258,5,Z-4;Z-5;X-53;X-55;X-57,
+200,0.10452134508025404,true,0.07994368944255693,0.18148145807572372,5,Z-4;Z-5;X-53;X-55;X-57,
+201,0.09490991550740706,true,0.05974555387777358,0.1776831248933575,5,Z-4;Z-5;X-53;X-55;X-57,
+202,0.022876765987344144,true,0.00938273352627826,0.04769704897865465,5,Z-4;Z-5;X-53;X-55;X-57,
+203,0.06208140339697418,true,0.031162178599890945,0.12421281170325338,5,Z-4;Z-5;X-53;X-55;X-57,
+204,0.12851937035992747,true,0.11098920976469108,0.21050099322333096,5,Z-4;Z-5;X-53;X-55;X-57,
+205,0.10124148644354578,true,0.08852318484962879,0.16486706816903543,5,Z-4;Z-5;X-53;X-55;X-57,
+206,0.07431450167250214,true,0.040753324105532486,0.145091496617985,5,Z-4;Z-5;X-53;X-55;X-57,
+207,0.06027253060787138,true,0.03043863512436559,0.12024048011762796,5,Z-4;Z-5;X-53;X-55;X-57,
+208,0.09170374695747124,true,0.05761450861960489,0.171611296835799,5,Z-4;Z-5;X-53;X-55;X-57,
+209,0.04642838103341257,true,0.01827445367224529,0.09780423564636054,5,Z-4;Z-5;X-53;X-55;X-57,
+210,0.11300417154216047,true,0.08437984983851349,0.19816283526114856,5,Z-4;Z-5;X-53;X-55;X-57,
+211,0.08810785361993798,true,0.06567887253051466,0.15477010513632333,5,Z-4;Z-5;X-53;X-55;X-57,
+212,0.11904144575511114,true,0.07882639151042323,0.21874969718800885,5,Z-4;Z-5;X-53;X-55;X-57,
+213,0.10104412456610734,true,0.06995774086657439,0.1828011215102893,5,Z-4;Z-5;X-53;X-55;X-57,
+214,0.11096548774381476,true,0.08303316765236357,0.19466039766850565,5,Z-4;Z-5;X-53;X-55;X-57,
+215,0.0788100281751737,true,0.04386927981208842,0.1531042705443454,5,Z-4;Z-5;X-53;X-55;X-57,
+216,0.1334411659407847,true,0.1027552325825259,0.23103041742062466,5,Z-4;Z-5;X-53;X-55;X-57,
+217,0.07260450842814184,true,0.04274516589069251,0.1388694035955457,5,Z-4;Z-5;X-53;X-55;X-57,
+218,0.04409001290773808,true,0.020713004907512267,0.089484893104734,5,Z-4;Z-5;X-53;X-55;X-57,
+219,0.10193375882623112,true,0.08079175579883394,0.17431185316725542,5,Z-4;Z-5;X-53;X-55;X-57,
+220,0.1322792752661082,true,0.11280121429470241,0.21807378571513836,5,Z-4;Z-5;X-53;X-55;X-57,
+221,0.020665027691196144,true,0.009709901010863638,0.041980801193131904,5,Z-4;Z-5;X-53;X-55;X-57,
+222,0.11329585996897264,true,0.08557684241432825,0.19782916277838516,5,Z-4;Z-5;X-53;X-55;X-57,
+223,0.11212104407345774,true,0.11369568180864896,0.16622268284753514,5,Z-4;Z-5;X-53;X-55;X-57,
+224,0.11578229195825296,true,0.08244122520028523,0.20713112584269508,5,Z-4;Z-5;X-53;X-55;X-57,
+225,0.10469596659789121,true,0.08301481691204228,0.17909027905046584,5,Z-4;Z-5;X-53;X-55;X-57,
+226,0.07410949356687435,true,0.05062156579002559,0.1348562055568546,5,Z-4;Z-5;X-53;X-55;X-57,
+227,0.1129557881839366,true,0.08921159976511053,0.19319355882908482,5,Z-4;Z-5;X-53;X-55;X-57,
+228,0.10298347639193206,true,0.08221865693553124,0.17521386426018026,5,Z-4;Z-5;X-53;X-55;X-57,
+229,0.017401005781848198,true,0.006753596745102974,0.03659569806853346,5,Z-4;Z-5;X-53;X-55;X-57,
+230,0.09162675690238684,true,0.05731539155236777,0.17189019984538156,5,Z-4;Z-5;X-53;X-55;X-57,
+231,0.09162675690238684,true,0.05731539155236777,0.17189019984538156,5,Z-4;Z-5;X-53;X-55;X-57,
+232,0.12460270169614786,true,0.12294078478251752,0.18847860936094554,5,Z-4;Z-5;X-53;X-55;X-57,
+233,0.11656580846106801,true,0.0946347678369196,0.19701773196802866,5,Z-4;Z-5;X-53;X-55;X-57,
+234,0.09444277604056493,true,0.07565590788976972,0.16074685900582172,5,Z-4;Z-5;X-53;X-55;X-57,
+235,0.06941988005211253,true,0.037853907134767835,0.13568856111465707,5,Z-4;Z-5;X-53;X-55;X-57,
+236,0.11301003691738293,true,0.08173524600478169,0.2007405113643146,5,Z-4;Z-5;X-53;X-55;X-57,
+237,0.11165959035726175,true,0.08314117486682605,0.19634645483519655,5,Z-4;Z-5;X-53;X-55;X-57,
+238,0.046909420082338796,true,0.025670064175160438,0.09163073297705089,5,Z-4;Z-5;X-53;X-55;X-57,
+239,0.0929033365618617,true,0.06479803699509248,0.16760020531530717,5,Z-4;Z-5;X-53;X-55;X-57,
+240,0.10802682724724849,true,0.08512121974749381,0.18489893276766298,5,Z-4;Z-5;X-53;X-55;X-57,
+241,0.09457972852734786,true,0.06880347930036491,0.16783627578817137,5,Z-4;Z-5;X-53;X-55;X-57,
+242,0.09457972852734786,true,0.06880347930036491,0.16783627578817137,5,Z-4;Z-5;X-53;X-55;X-57,
+243,0.12458652545562734,true,0.13347253680634202,0.17744719485503993,5,Z-4;Z-5;X-53;X-55;X-57,
+244,0.03545187798270505,true,0.016560756679669476,0.07200528595633468,5,Z-4;Z-5;X-53;X-55;X-57,
+245,0.10778467527794149,true,0.09142810704248983,0.1783206977350014,5,Z-4;Z-5;X-53;X-55;X-57,
+246,0.11120413979869492,true,0.08334696531185773,0.19469129326876153,5,Z-4;Z-5;X-53;X-55;X-57,
+247,0.0761977346120205,true,0.04704081204647456,0.14356988830538334,5,Z-4;Z-5;X-53;X-55;X-57,
+248,0.12626685232274112,true,0.09120475231743636,0.22442423591318617,5,Z-4;Z-5;X-53;X-55;X-57,
+249,0.1004129345448971,true,0.07493865609664024,0.1762681064016386,5,Z-4;Z-5;X-53;X-55;X-57,
+250,0.130279000162781,true,0.10182930665659998,0.22383469168648548,5,Z-4;Z-5;X-53;X-55;X-57,
+251,0.08446097760792386,true,0.054284373558156115,0.1570872751555137,5,Z-4;Z-5;X-53;X-55;X-57,
+252,0.011901983196702423,true,0.005624764061910155,0.024211477575060508,5,Z-4;Z-5;X-53;X-55;X-57,
+253,0.03348005681851174,true,0.012312560295289626,0.0713583040000674,5,Z-4;Z-5;X-53;X-55;X-57,
+254,0.051450399306145485,true,0.0263752569103645,0.10219773043729212,5,Z-4;Z-5;X-53;X-55;X-57,
+255,0.09665305046714232,true,0.06668265802608951,0.1752124599147141,5,Z-4;Z-5;X-53;X-55;X-57,
+256,0.08611829204135558,true,0.06201318107461935,0.15345044170175776,5,Z-4;Z-5;X-53;X-55;X-57,
+257,0.06643002611626736,true,0.03610665450274737,0.1300957552956112,5,Z-4;Z-5;X-53;X-55;X-57,
+258,0.11768990150310236,true,0.10456566419193825,0.18996524947143945,5,Z-4;Z-5;X-53;X-55;X-57,
+259,0.10193656087217387,true,0.07719972945765698,0.17755729553958813,5,Z-4;Z-5;X-53;X-55;X-57,
+260,0.11166841368830147,true,0.08106911413111867,0.1981016057988233,5,Z-4;Z-5;X-53;X-55;X-57,
+261,0.06804334497697756,true,0.035068264753995215,0.1351445176810605,5,Z-4;Z-5;X-53;X-55;X-57,
+262,0.1282397203001044,true,0.10241023866448555,0.21842768077261468,5,Z-4;Z-5;X-53;X-55;X-57,
+263,0.12559461623755475,true,0.10683879661088042,0.207390789319391,5,Z-4;Z-5;X-53;X-55;X-57,
+264,0.08958525704789233,true,0.06040041315381066,0.16378291346914758,5,Z-4;Z-5;X-53;X-55;X-57,
+265,0.06823763002782127,true,0.04256978524390755,0.12809975908453528,5,Z-4;Z-5;X-53;X-55;X-57,
+266,0.0988361866374742,true,0.06386450861960488,0.18335611883852207,5,Z-4;Z-5;X-53;X-55;X-57,
+267,0.11369022821697158,true,0.0799269116228346,0.20432187317215658,5,Z-4;Z-5;X-53;X-55;X-57,
+268,0.04491716985698301,true,0.019270898871691623,0.09298030897004601,5,Z-4;Z-5;X-53;X-55;X-57,
+269,0.09183969044571688,true,0.05797208590243698,0.17166101066530162,5,Z-4;Z-5;X-53;X-55;X-57,
+270,0.07673089219848768,true,0.05044382576234219,0.1416521141367734,5,Z-4;Z-5;X-53;X-55;X-57,
+271,0.07685297196386627,true,0.050692085063545986,0.14171067534271295,5,Z-4;Z-5;X-53;X-55;X-57,
+272,0.02956161946521775,true,0.008160836374313158,0.06561087974519557,5,Z-4;Z-5;X-53;X-55;X-57,
+273,0.11887381619657401,true,0.09728461473931463,0.20012217805555732,5,Z-4;Z-5;X-53;X-55;X-57,
+274,0.09943659543488009,true,0.07852334214168868,0.17038389889836122,5,Z-4;Z-5;X-53;X-55;X-57,
+275,0.07654632925467197,true,0.04663919298687136,0.14495330902411332,5,Z-4;Z-5;X-53;X-55;X-57,
+276,0.12153607808304527,true,0.0863669728618766,0.21729802527962272,5,Z-4;Z-5;X-53;X-55;X-57,
+277,0.05538832007730167,true,0.02971037288704333,0.10887721877806496,5,Z-4;Z-5;X-53;X-55;X-57,
+278,0.12593731282998633,true,0.13078965857136865,0.18371745692696914,5,Z-4;Z-5;X-53;X-55;X-57,
+279,0.10689673356976143,true,0.07350022020888386,0.1938458772981236,5,Z-4;Z-5;X-53;X-55;X-57,
+280,0.10170931995005764,true,0.07581582148399815,0.17862010418839014,5,Z-4;Z-5;X-53;X-55;X-57,
+281,0.10620971424215192,true,0.07820089341890021,0.18751354315658944,5,Z-4;Z-5;X-53;X-55;X-57,
+282,0.11966178451009413,true,0.08824661297764355,0.2111475538759584,5,Z-4;Z-5;X-53;X-55;X-57,
+283,0.08756619781604275,true,0.0587976070634621,0.16030111975485747,5,Z-4;Z-5;X-53;X-55;X-57,
+284,0.07009269806451113,true,0.03799075122687807,0.13738416783051796,5,Z-4;Z-5;X-53;X-55;X-57,
+285,0.043393069808168476,true,0.01905226290843505,0.08928996995402876,5,Z-4;Z-5;X-53;X-55;X-57,
+286,0.13561512842999912,true,0.13860628748794096,0.20025741652395004,5,Z-4;Z-5;X-53;X-55;X-57,
+287,0.10402599271995613,true,0.08785783943626525,0.17231290783070052,5,Z-4;Z-5;X-53;X-55;X-57,
+288,0.024576829199911242,true,0.009625225451952518,0.05164677060227462,5,Z-4;Z-5;X-53;X-55;X-57,
+289,0.07748873843453238,true,0.03978964808523132,0.1539154204856086,5,Z-4;Z-5;X-53;X-55;X-57,
+290,0.09694306830849139,true,0.0664228639738266,0.1759170200350946,5,Z-4;Z-5;X-53;X-55;X-57,
+291,0.06397016668613743,true,0.03034976511052389,0.12966209341565607,5,Z-4;Z-5;X-53;X-55;X-57,
+292,0.09681203521787272,true,0.07197343861415209,0.17025820997913846,5,Z-4;Z-5;X-53;X-55;X-57,
+293,0.1186769283804774,true,0.10934550773876935,0.18782404393916094,5,Z-4;Z-5;X-53;X-55;X-57,
+294,0.10031813812785403,true,0.08091549221928611,0.17018981835493566,5,Z-4;Z-5;X-53;X-55;X-57,
+295,0.11007863523155118,true,0.08741139213959145,0.18778261574790875,5,Z-4;Z-5;X-53;X-55;X-57,
+296,0.06390492255266063,true,0.03303945933475945,0.1267713887080794,5,Z-4;Z-5;X-53;X-55;X-57,
+297,0.1411457646142668,true,0.14164779161947905,0.21139387607072566,5,Z-4;Z-5;X-53;X-55;X-57,
+298,0.1294709457549593,true,0.10954841449603625,0.21406859244560442,5,Z-4;Z-5;X-53;X-55;X-57,
+299,0.1282373050714672,true,0.0929677341554465,0.22761518968143124,5,Z-4;Z-5;X-53;X-55;X-57,
+300,0.10393543023770158,true,0.08403066146554256,0.17600507249582384,5,Z-4;Z-5;X-53;X-55;X-57,
+301,0.032097486455123586,true,0.01023420787718636,0.06993078683369952,5,Z-4;Z-5;X-53;X-55;X-57,
+302,0.09804089594790345,true,0.06740856088251332,0.17786358328576113,5,Z-4;Z-5;X-53;X-55;X-57,
+303,0.03884935142211383,true,0.019766368860366597,0.0769064516332889,5,Z-4;Z-5;X-53;X-55;X-57,
+304,0.10335981293818944,true,0.08192923954532108,0.17675344819474903,5,Z-4;Z-5;X-53;X-55;X-57,
+305,0.10331781000416648,true,0.08175438320540246,0.17680976244794266,5,Z-4;Z-5;X-53;X-55;X-57,
+306,0.06956608438861775,true,0.04817279057086531,0.12599633044529687,5,Z-4;Z-5;X-53;X-55;X-57,
+307,0.09275279033566275,true,0.07286921689526446,0.15906501487552935,5,Z-4;Z-5;X-53;X-55;X-57,
+308,0.11245820870432753,true,0.0860555345832809,0.19502524662061818,5,Z-4;Z-5;X-53;X-55;X-57,
+309,0.07666789195725376,true,0.04173666163332075,0.15010444819404686,5,Z-4;Z-5;X-53;X-55;X-57,
+310,0.10493311516794514,true,0.07779114760286901,0.18450304778074797,5,Z-4;Z-5;X-53;X-55;X-57,
+311,0.048871869288865076,true,0.02521758734952393,0.09648794264091376,5,Z-4;Z-5;X-53;X-55;X-57,
+312,0.04407594596186509,true,0.018449047858730756,0.09170600589403792,5,Z-4;Z-5;X-53;X-55;X-57,
+313,0.10313505386296537,true,0.08616930917327292,0.1719397732403376,5,Z-4;Z-5;X-53;X-55;X-57,
+314,0.12283602599806681,true,0.08766804035065642,0.2197706563419188,5,Z-4;Z-5;X-53;X-55;X-57,
+315,0.15178309543403534,true,0.14813084602155951,0.2311172059704343,5,Z-4;Z-5;X-53;X-55;X-57,
+316,0.06195709271896449,true,0.03177954993498595,0.12309523358127052,5,Z-4;Z-5;X-53;X-55;X-57,
+317,0.10697451175981638,true,0.08227030116186401,0.18542373666837295,5,Z-4;Z-5;X-53;X-55;X-57,
+318,0.029146808945027546,true,0.011447453965857137,0.061157419402858265,5,Z-4;Z-5;X-53;X-55;X-57,
+319,0.09625215675529361,true,0.06402599513443227,0.17660458757533437,5,Z-4;Z-5;X-53;X-55;X-57,
+320,0.06897607469256113,true,0.04186852481020091,0.1307140886043685,5,Z-4;Z-5;X-53;X-55;X-57,
+321,0.11159337353769058,true,0.08011304056037918,0.1991191945236144,5,Z-4;Z-5;X-53;X-55;X-57,
+322,0.12264011822194198,true,0.12038452665576108,0.18648120880440344,5,Z-4;Z-5;X-53;X-55;X-57,
+323,0.09338573686152463,true,0.08198009731135439,0.1513576860880623,5,Z-4;Z-5;X-53;X-55;X-57,
+324,0.1251450883054189,true,0.08999517637682983,0.2228339551072885,5,Z-4;Z-5;X-53;X-55;X-57,
+325,0.09895334705824667,true,0.06487956671280568,0.18256856190109053,5,Z-4;Z-5;X-53;X-55;X-57,
+326,0.05230520585596135,true,0.029461851432406358,0.10129965151167257,5,Z-4;Z-5;X-53;X-55;X-57,
+327,0.029668715621972073,true,0.013215416719097354,0.060795379141678096,5,Z-4;Z-5;X-53;X-55;X-57,
+328,0.0852884873779044,true,0.05520138626735456,0.15814938163158263,5,Z-4;Z-5;X-53;X-55;X-57,
+329,0.14328075907284382,true,0.13258488528165766,0.22649522417215592,5,Z-4;Z-5;X-53;X-55;X-57,
+330,0.10680867634282874,true,0.08709707017323098,0.18020743586880886,5,Z-4;Z-5;X-53;X-55;X-57,
+331,0.028175941332423383,true,0.011202078352418102,0.059098508514897646,5,Z-4;Z-5;X-53;X-55;X-57,
+332,0.14610598411905268,true,0.11915607566796696,0.2488098523260525,5,Z-4;Z-5;X-53;X-55;X-57,
+333,0.0999342212750803,true,0.07884579086447716,0.17137620940476114,5,Z-4;Z-5;X-53;X-55;X-57,
+334,0.07726168114384421,true,0.04758530472715071,0.1457478876888757,5,Z-4;Z-5;X-53;X-55;X-57,
+335,0.12753877712196687,true,0.09823098863302714,0.22031441890642212,5,Z-4;Z-5;X-53;X-55;X-57,
+336,0.056761434172213736,true,0.030508105784153347,0.11136459546775586,5,Z-4;Z-5;X-53;X-55;X-57,
+337,0.09458153661377325,true,0.06066440166100415,0.1760488880743685,5,Z-4;Z-5;X-53;X-55;X-57,
+338,0.11969436618322073,true,0.0815776917914517,0.2177805583818008,5,Z-4;Z-5;X-53;X-55;X-57,
+339,0.01360788985497658,true,0.0051806761461348095,0.028850873257119502,5,Z-4;Z-5;X-53;X-55;X-57,
+340,0.06428744817040424,true,0.0316469002978063,0.12838835207783442,5,Z-4;Z-5;X-53;X-55;X-57,
+341,0.11202422881370679,true,0.08915445031668134,0.19121371259086994,5,Z-4;Z-5;X-53;X-55;X-57,
+342,0.11443533801931678,true,0.11710839520154356,0.16865276224220604,5,Z-4;Z-5;X-53;X-55;X-57,
+343,0.1183993486170461,true,0.08436674216685541,0.21159750616332115,5,Z-4;Z-5;X-53;X-55;X-57,
+344,0.06973862608045184,true,0.04104143072857682,0.13331971118231142,5,Z-4;Z-5;X-53;X-55;X-57,
+345,0.06106400185138944,true,0.032772849293234346,0.11992913672777676,5,Z-4;Z-5;X-53;X-55;X-57,
+346,0.04384205959007187,true,0.021267721572081708,0.08798982692144303,5,Z-4;Z-5;X-53;X-55;X-57,
+347,0.09366410838419317,true,0.0722319218992492,0.1619988329889176,5,Z-4;Z-5;X-53;X-55;X-57,
+348,0.09711378813277914,true,0.07221304685206158,0.17066027408610462,5,Z-4;Z-5;X-53;X-55;X-57,
+349,0.0239805662501483,true,0.007243037204815235,0.05259554639922312,5,Z-4;Z-5;X-53;X-55;X-57,
+350,0.11431309756848043,false,0.08228812759531899,0.2034734238153117,0,Z-4;Z-5;X-53;X-55;X-57,290;92;276;210;28
+351,0.11611751461603312,false,0.08568222809445912,0.20468135752458835,0,Z-4;Z-5;X-53;X-55;X-57,85;33;200;343;63
+352,0.10678768894767728,false,0.08876321253303134,0.17815641740236815,0,Z-4;Z-5;X-53;X-55;X-57,243;282;87;90;183
+353,0.10460618037839783,false,0.08776692462564491,0.17384912133615044,0,Z-4;Z-5;X-53;X-55;X-57,114;118;174;278;322
+354,0.07536465457355299,false,0.05040948366259805,0.13816666912427125,0,Z-4;Z-5;X-53;X-55;X-57,30;64;187;15;125

splits/manifest.json

@@ -0,0 +1,2188 @@
+{
+    "full_train": [
+        "run_0",
+        "run_1",
+        "run_2",
+        "run_3",
+        "run_4",
+        "run_5",
+        "run_6",
+        "run_9",
+        "run_10",
+        "run_12",
+        "run_13",
+        "run_14",
+        "run_15",
+        "run_16",
+        "run_17",
+        "run_19",
+        "run_20",
+        "run_21",
+        "run_22",
+        "run_24",
+        "run_26",
+        "run_29",
+        "run_30",
+        "run_31",
+        "run_33",
+        "run_34",
+        "run_35",
+        "run_36",
+        "run_38",
+        "run_39",
+        "run_40",
+        "run_41",
+        "run_42",
+        "run_45",
+        "run_48",
+        "run_49",
+        "run_52",
+        "run_53",
+        "run_54",
+        "run_55",
+        "run_59",
+        "run_60",
+        "run_61",
+        "run_62",
+        "run_63",
+        "run_64",
+        "run_65",
+        "run_67",
+        "run_68",
+        "run_70",
+        "run_71",
+        "run_72",
+        "run_73",
+        "run_74",
+        "run_75",
+        "run_76",
+        "run_78",
+        "run_79",
+        "run_80",
+        "run_81",
+        "run_82",
+        "run_84",
+        "run_86",
+        "run_87",
+        "run_88",
+        "run_90",
+        "run_91",
+        "run_92",
+        "run_93",
+        "run_96",
+        "run_101",
+        "run_102",
+        "run_103",
+        "run_105",
+        "run_106",
+        "run_107",
+        "run_108",
+        "run_109",
+        "run_110",
+        "run_111",
+        "run_112",
+        "run_114",
+        "run_115",
+        "run_116",
+        "run_117",
+        "run_118",
+        "run_119",
+        "run_120",
+        "run_121",
+        "run_122",
+        "run_124",
+        "run_126",
+        "run_127",
+        "run_128",
+        "run_129",
+        "run_131",
+        "run_132",
+        "run_133",
+        "run_134",
+        "run_135",
+        "run_138",
+        "run_140",
+        "run_141",
+        "run_142",
+        "run_143",
+        "run_144",
+        "run_145",
+        "run_146",
+        "run_147",
+        "run_150",
+        "run_151",
+        "run_152",
+        "run_153",
+        "run_154",
+        "run_155",
+        "run_157",
+        "run_158",
+        "run_159",
+        "run_160",
+        "run_161",
+        "run_162",
+        "run_163",
+        "run_164",
+        "run_165",
+        "run_166",
+        "run_167",
+        "run_169",
+        "run_170",
+        "run_171",
+        "run_173",
+        "run_174",
+        "run_175",
+        "run_176",
+        "run_177",
+        "run_178",
+        "run_179",
+        "run_180",
+        "run_181",
+        "run_182",
+        "run_183",
+        "run_184",
+        "run_185",
+        "run_186",
+        "run_187",
+        "run_188",
+        "run_189",
+        "run_190",
+        "run_191",
+        "run_192",
+        "run_193",
+        "run_194",
+        "run_195",
+        "run_196",
+        "run_197",
+        "run_198",
+        "run_199",
+        "run_200",
+        "run_201",
+        "run_202",
+        "run_203",
+        "run_204",
+        "run_205",
+        "run_206",
+        "run_207",
+        "run_208",
+        "run_209",
+        "run_211",
+        "run_212",
+        "run_213",
+        "run_214",
+        "run_215",
+        "run_217",
+        "run_218",
+        "run_219",
+        "run_220",
+        "run_221",
+        "run_223",
+        "run_224",
+        "run_225",
+        "run_226",
+        "run_227",
+        "run_228",
+        "run_229",
+        "run_230",
+        "run_231",
+        "run_233",
+        "run_234",
+        "run_235",
+        "run_237",
+        "run_238",
+        "run_239",
+        "run_240",
+        "run_241",
+        "run_243",
+        "run_245",
+        "run_246",
+        "run_247",
+        "run_248",
+        "run_249",
+        "run_251",
+        "run_252",
+        "run_254",
+        "run_255",
+        "run_258",
+        "run_259",
+        "run_260",
+        "run_261",
+        "run_262",
+        "run_263",
+        "run_264",
+        "run_265",
+        "run_266",
+        "run_268",
+        "run_269",
+        "run_271",
+        "run_272",
+        "run_275",
+        "run_276",
+        "run_277",
+        "run_278",
+        "run_280",
+        "run_281",
+        "run_282",
+        "run_284",
+        "run_285",
+        "run_286",
+        "run_288",
+        "run_289",
+        "run_290",
+        "run_291",
+        "run_292",
+        "run_293",
+        "run_294",
+        "run_295",
+        "run_296",
+        "run_297",
+        "run_298",
+        "run_301",
+        "run_302",
+        "run_303",
+        "run_304",
+        "run_306",
+        "run_307",
+        "run_308",
+        "run_309",
+        "run_310",
+        "run_311",
+        "run_312",
+        "run_313",
+        "run_314",
+        "run_315",
+        "run_316",
+        "run_318",
+        "run_319",
+        "run_320",
+        "run_321",
+        "run_322",
+        "run_323",
+        "run_324",
+        "run_325",
+        "run_326",
+        "run_327",
+        "run_328",
+        "run_329",
+        "run_330",
+        "run_332",
+        "run_334",
+        "run_335",
+        "run_337",
+        "run_338",
+        "run_339",
+        "run_340",
+        "run_342",
+        "run_343",
+        "run_344",
+        "run_345",
+        "run_346",
+        "run_347",
+        "run_348",
+        "run_349",
+        "run_350",
+        "run_351",
+        "run_352",
+        "run_353"
+    ],
+    "full_val": [
+        "run_8",
+        "run_11",
+        "run_25",
+        "run_27",
+        "run_37",
+        "run_43",
+        "run_44",
+        "run_46",
+        "run_50",
+        "run_51",
+        "run_56",
+        "run_57",
+        "run_77",
+        "run_83",
+        "run_94",
+        "run_99",
+        "run_137",
+        "run_149",
+        "run_156",
+        "run_168",
+        "run_210",
+        "run_222",
+        "run_236",
+        "run_242",
+        "run_244",
+        "run_250",
+        "run_267",
+        "run_273",
+        "run_274",
+        "run_279",
+        "run_287",
+        "run_300",
+        "run_305",
+        "run_317",
+        "run_331"
+    ],
+    "full_test": [
+        "run_7",
+        "run_18",
+        "run_23",
+        "run_28",
+        "run_32",
+        "run_47",
+        "run_58",
+        "run_66",
+        "run_69",
+        "run_85",
+        "run_89",
+        "run_95",
+        "run_97",
+        "run_98",
+        "run_100",
+        "run_104",
+        "run_113",
+        "run_123",
+        "run_125",
+        "run_130",
+        "run_136",
+        "run_139",
+        "run_148",
+        "run_172",
+        "run_216",
+        "run_232",
+        "run_253",
+        "run_256",
+        "run_257",
+        "run_270",
+        "run_283",
+        "run_299",
+        "run_333",
+        "run_336",
+        "run_341",
+        "run_354"
+    ],
+    "medium_train": [
+        "run_3",
+        "run_4",
+        "run_5",
+        "run_10",
+        "run_13",
+        "run_17",
+        "run_21",
+        "run_22",
+        "run_26",
+        "run_29",
+        "run_31",
+        "run_34",
+        "run_36",
+        "run_40",
+        "run_45",
+        "run_48",
+        "run_52",
+        "run_65",
+        "run_70",
+        "run_74",
+        "run_80",
+        "run_84",
+        "run_91",
+        "run_96",
+        "run_102",
+        "run_103",
+        "run_105",
+        "run_107",
+        "run_109",
+        "run_121",
+        "run_129",
+        "run_132",
+        "run_133",
+        "run_134",
+        "run_141",
+        "run_142",
+        "run_143",
+        "run_147",
+        "run_153",
+        "run_154",
+        "run_161",
+        "run_163",
+        "run_164",
+        "run_165",
+        "run_167",
+        "run_169",
+        "run_175",
+        "run_176",
+        "run_178",
+        "run_179",
+        "run_188",
+        "run_189",
+        "run_192",
+        "run_194",
+        "run_196",
+        "run_198",
+        "run_200",
+        "run_204",
+        "run_219",
+        "run_221",
+        "run_223",
+        "run_225",
+        "run_226",
+        "run_243",
+        "run_248",
+        "run_252",
+        "run_254",
+        "run_258",
+        "run_261",
+        "run_262",
+        "run_269",
+        "run_271",
+        "run_275",
+        "run_285",
+        "run_286",
+        "run_288",
+        "run_293",
+        "run_294",
+        "run_298",
+        "run_303",
+        "run_306",
+        "run_309",
+        "run_310",
+        "run_311",
+        "run_315",
+        "run_322",
+        "run_327",
+        "run_329",
+        "run_335",
+        "run_337",
+        "run_340",
+        "run_342",
+        "run_346",
+        "run_352",
+        "run_353"
+    ],
+    "medium_val": [
+        "run_8",
+        "run_11",
+        "run_25",
+        "run_27",
+        "run_37",
+        "run_43",
+        "run_44",
+        "run_46",
+        "run_50",
+        "run_51",
+        "run_56",
+        "run_57",
+        "run_77",
+        "run_83",
+        "run_94",
+        "run_99",
+        "run_137",
+        "run_149",
+        "run_156",
+        "run_168",
+        "run_210",
+        "run_222",
+        "run_236",
+        "run_242",
+        "run_244",
+        "run_250",
+        "run_267",
+        "run_273",
+        "run_274",
+        "run_279",
+        "run_287",
+        "run_300",
+        "run_305",
+        "run_317",
+        "run_331"
+    ],
+    "medium_test": [
+        "run_7",
+        "run_18",
+        "run_23",
+        "run_28",
+        "run_32",
+        "run_47",
+        "run_58",
+        "run_66",
+        "run_69",
+        "run_85",
+        "run_89",
+        "run_95",
+        "run_97",
+        "run_98",
+        "run_100",
+        "run_104",
+        "run_113",
+        "run_123",
+        "run_125",
+        "run_130",
+        "run_136",
+        "run_139",
+        "run_148",
+        "run_172",
+        "run_216",
+        "run_232",
+        "run_253",
+        "run_256",
+        "run_257",
+        "run_270",
+        "run_283",
+        "run_299",
+        "run_333",
+        "run_336",
+        "run_341",
+        "run_354"
+    ],
+    "scarce_train": [
+        "run_3",
+        "run_13",
+        "run_17",
+        "run_36",
+        "run_40",
+        "run_45",
+        "run_48",
+        "run_52",
+        "run_70",
+        "run_84",
+        "run_91",
+        "run_107",
+        "run_121",
+        "run_129",
+        "run_132",
+        "run_133",
+        "run_134",
+        "run_147",
+        "run_161",
+        "run_165",
+        "run_169",
+        "run_175",
+        "run_178",
+        "run_179",
+        "run_188",
+        "run_189",
+        "run_198",
+        "run_221",
+        "run_252",
+        "run_254",
+        "run_258",
+        "run_261",
+        "run_262",
+        "run_271",
+        "run_275",
+        "run_286",
+        "run_288",
+        "run_303",
+        "run_306",
+        "run_309",
+        "run_310",
+        "run_311",
+        "run_315",
+        "run_327",
+        "run_335",
+        "run_340",
+        "run_346"
+    ],
+    "scarce_val": [
+        "run_8",
+        "run_11",
+        "run_25",
+        "run_27",
+        "run_37",
+        "run_43",
+        "run_44",
+        "run_46",
+        "run_50",
+        "run_51",
+        "run_56",
+        "run_57",
+        "run_77",
+        "run_83",
+        "run_94",
+        "run_99",
+        "run_137",
+        "run_149",
+        "run_156",
+        "run_168",
+        "run_210",
+        "run_222",
+        "run_236",
+        "run_242",
+        "run_244",
+        "run_250",
+        "run_267",
+        "run_273",
+        "run_274",
+        "run_279",
+        "run_287",
+        "run_300",
+        "run_305",
+        "run_317",
+        "run_331"
+    ],
+    "scarce_test": [
+        "run_7",
+        "run_18",
+        "run_23",
+        "run_28",
+        "run_32",
+        "run_47",
+        "run_58",
+        "run_66",
+        "run_69",
+        "run_85",
+        "run_89",
+        "run_95",
+        "run_97",
+        "run_98",
+        "run_100",
+        "run_104",
+        "run_113",
+        "run_123",
+        "run_125",
+        "run_130",
+        "run_136",
+        "run_139",
+        "run_148",
+        "run_172",
+        "run_216",
+        "run_232",
+        "run_253",
+        "run_256",
+        "run_257",
+        "run_270",
+        "run_283",
+        "run_299",
+        "run_333",
+        "run_336",
+        "run_341",
+        "run_354"
+    ],
+    "super_scarce_train": [
+        "run_132",
+        "run_252",
+        "run_271",
+        "run_303",
+        "run_306",
+        "run_315",
+        "run_335",
+        "run_340"
+    ],
+    "super_scarce_val": [
+        "run_8",
+        "run_11",
+        "run_25",
+        "run_27",
+        "run_37",
+        "run_43",
+        "run_44",
+        "run_46",
+        "run_50",
+        "run_51",
+        "run_56",
+        "run_57",
+        "run_77",
+        "run_83",
+        "run_94",
+        "run_99",
+        "run_137",
+        "run_149",
+        "run_156",
+        "run_168",
+        "run_210",
+        "run_222",
+        "run_236",
+        "run_242",
+        "run_244",
+        "run_250",
+        "run_267",
+        "run_273",
+        "run_274",
+        "run_279",
+        "run_287",
+        "run_300",
+        "run_305",
+        "run_317",
+        "run_331"
+    ],
+    "super_scarce_test": [
+        "run_7",
+        "run_18",
+        "run_23",
+        "run_28",
+        "run_32",
+        "run_47",
+        "run_58",
+        "run_66",
+        "run_69",
+        "run_85",
+        "run_89",
+        "run_95",
+        "run_97",
+        "run_98",
+        "run_100",
+        "run_104",
+        "run_113",
+        "run_123",
+        "run_125",
+        "run_130",
+        "run_136",
+        "run_139",
+        "run_148",
+        "run_172",
+        "run_216",
+        "run_232",
+        "run_253",
+        "run_256",
+        "run_257",
+        "run_270",
+        "run_283",
+        "run_299",
+        "run_333",
+        "run_336",
+        "run_341",
+        "run_354"
+    ],
+    "high_drag_train": [
+        "run_0",
+        "run_1",
+        "run_3",
+        "run_4",
+        "run_5",
+        "run_6",
+        "run_7",
+        "run_8",
+        "run_9",
+        "run_12",
+        "run_13",
+        "run_15",
+        "run_16",
+        "run_18",
+        "run_19",
+        "run_21",
+        "run_22",
+        "run_26",
+        "run_27",
+        "run_30",
+        "run_31",
+        "run_33",
+        "run_35",
+        "run_37",
+        "run_39",
+        "run_41",
+        "run_42",
+        "run_43",
+        "run_44",
+        "run_45",
+        "run_46",
+        "run_47",
+        "run_48",
+        "run_49",
+        "run_51",
+        "run_53",
+        "run_54",
+        "run_55",
+        "run_56",
+        "run_57",
+        "run_60",
+        "run_61",
+        "run_64",
+        "run_65",
+        "run_67",
+        "run_69",
+        "run_70",
+        "run_71",
+        "run_73",
+        "run_77",
+        "run_78",
+        "run_79",
+        "run_82",
+        "run_83",
+        "run_84",
+        "run_86",
+        "run_87",
+        "run_90",
+        "run_91",
+        "run_92",
+        "run_93",
+        "run_94",
+        "run_95",
+        "run_96",
+        "run_97",
+        "run_99",
+        "run_100",
+        "run_101",
+        "run_102",
+        "run_104",
+        "run_105",
+        "run_106",
+        "run_107",
+        "run_108",
+        "run_109",
+        "run_110",
+        "run_111",
+        "run_112",
+        "run_113",
+        "run_114",
+        "run_115",
+        "run_117",
+        "run_118",
+        "run_122",
+        "run_124",
+        "run_126",
+        "run_130",
+        "run_131",
+        "run_132",
+        "run_133",
+        "run_134",
+        "run_135",
+        "run_136",
+        "run_137",
+        "run_138",
+        "run_141",
+        "run_142",
+        "run_143",
+        "run_144",
+        "run_145",
+        "run_146",
+        "run_147",
+        "run_150",
+        "run_152",
+        "run_153",
+        "run_154",
+        "run_155",
+        "run_156",
+        "run_157",
+        "run_158",
+        "run_159",
+        "run_160",
+        "run_161",
+        "run_162",
+        "run_165",
+        "run_166",
+        "run_168",
+        "run_172",
+        "run_173",
+        "run_175",
+        "run_177",
+        "run_178",
+        "run_179",
+        "run_180",
+        "run_183",
+        "run_184",
+        "run_185",
+        "run_186",
+        "run_188",
+        "run_189",
+        "run_190",
+        "run_191",
+        "run_195",
+        "run_197",
+        "run_198",
+        "run_200",
+        "run_201",
+        "run_202",
+        "run_203",
+        "run_204",
+        "run_206",
+        "run_207",
+        "run_208",
+        "run_209",
+        "run_210",
+        "run_211",
+        "run_213",
+        "run_215",
+        "run_216",
+        "run_217",
+        "run_218",
+        "run_220",
+        "run_223",
+        "run_225",
+        "run_226",
+        "run_227",
+        "run_228",
+        "run_229",
+        "run_230",
+        "run_231",
+        "run_232",
+        "run_233",
+        "run_234",
+        "run_235",
+        "run_236",
+        "run_237",
+        "run_238",
+        "run_239",
+        "run_241",
+        "run_242",
+        "run_244",
+        "run_245",
+        "run_246",
+        "run_247",
+        "run_248",
+        "run_249",
+        "run_250",
+        "run_251",
+        "run_253",
+        "run_255",
+        "run_256",
+        "run_257",
+        "run_258",
+        "run_259",
+        "run_262",
+        "run_263",
+        "run_264",
+        "run_265",
+        "run_268",
+        "run_270",
+        "run_271",
+        "run_272",
+        "run_273",
+        "run_276",
+        "run_277",
+        "run_278",
+        "run_280",
+        "run_283",
+        "run_286",
+        "run_287",
+        "run_288",
+        "run_289",
+        "run_290",
+        "run_292",
+        "run_294",
+        "run_295",
+        "run_296",
+        "run_298",
+        "run_300",
+        "run_301",
+        "run_302",
+        "run_304",
+        "run_306",
+        "run_307",
+        "run_308",
+        "run_309",
+        "run_312",
+        "run_313",
+        "run_314",
+        "run_316",
+        "run_317",
+        "run_319",
+        "run_320",
+        "run_321",
+        "run_322",
+        "run_323",
+        "run_325",
+        "run_326",
+        "run_328",
+        "run_329",
+        "run_330",
+        "run_331",
+        "run_332",
+        "run_333",
+        "run_336",
+        "run_337",
+        "run_341",
+        "run_342",
+        "run_343",
+        "run_344",
+        "run_345",
+        "run_347",
+        "run_348",
+        "run_349",
+        "run_350",
+        "run_351",
+        "run_353",
+        "run_354"
+    ],
+    "high_drag_val": [
+        "run_24",
+        "run_28",
+        "run_29",
+        "run_32",
+        "run_34",
+        "run_38",
+        "run_40",
+        "run_58",
+        "run_59",
+        "run_68",
+        "run_76",
+        "run_98",
+        "run_116",
+        "run_120",
+        "run_125",
+        "run_129",
+        "run_148",
+        "run_164",
+        "run_174",
+        "run_176",
+        "run_182",
+        "run_187",
+        "run_205",
+        "run_214",
+        "run_219",
+        "run_254",
+        "run_260",
+        "run_269",
+        "run_274",
+        "run_275",
+        "run_281",
+        "run_282",
+        "run_284",
+        "run_297",
+        "run_305",
+        "run_334"
+    ],
+    "high_drag_test": [
+        "run_2",
+        "run_10",
+        "run_11",
+        "run_14",
+        "run_17",
+        "run_20",
+        "run_23",
+        "run_25",
+        "run_36",
+        "run_50",
+        "run_52",
+        "run_62",
+        "run_63",
+        "run_66",
+        "run_72",
+        "run_74",
+        "run_75",
+        "run_80",
+        "run_81",
+        "run_85",
+        "run_88",
+        "run_89",
+        "run_103",
+        "run_119",
+        "run_121",
+        "run_123",
+        "run_127",
+        "run_128",
+        "run_139",
+        "run_140",
+        "run_149",
+        "run_151",
+        "run_163",
+        "run_167",
+        "run_169",
+        "run_170",
+        "run_171",
+        "run_181",
+        "run_192",
+        "run_193",
+        "run_194",
+        "run_196",
+        "run_199",
+        "run_212",
+        "run_221",
+        "run_222",
+        "run_224",
+        "run_240",
+        "run_243",
+        "run_252",
+        "run_261",
+        "run_266",
+        "run_267",
+        "run_279",
+        "run_285",
+        "run_291",
+        "run_293",
+        "run_299",
+        "run_303",
+        "run_310",
+        "run_311",
+        "run_315",
+        "run_318",
+        "run_324",
+        "run_327",
+        "run_335",
+        "run_338",
+        "run_339",
+        "run_340",
+        "run_346",
+        "run_352"
+    ],
+    "low_drag_train": [
+        "run_1",
+        "run_2",
+        "run_3",
+        "run_4",
+        "run_6",
+        "run_8",
+        "run_9",
+        "run_10",
+        "run_11",
+        "run_12",
+        "run_13",
+        "run_14",
+        "run_16",
+        "run_17",
+        "run_18",
+        "run_20",
+        "run_21",
+        "run_22",
+        "run_23",
+        "run_24",
+        "run_27",
+        "run_28",
+        "run_29",
+        "run_32",
+        "run_33",
+        "run_34",
+        "run_35",
+        "run_36",
+        "run_39",
+        "run_41",
+        "run_42",
+        "run_43",
+        "run_44",
+        "run_45",
+        "run_47",
+        "run_49",
+        "run_50",
+        "run_52",
+        "run_53",
+        "run_54",
+        "run_56",
+        "run_57",
+        "run_59",
+        "run_61",
+        "run_62",
+        "run_63",
+        "run_64",
+        "run_65",
+        "run_66",
+        "run_67",
+        "run_69",
+        "run_70",
+        "run_71",
+        "run_72",
+        "run_73",
+        "run_74",
+        "run_75",
+        "run_78",
+        "run_79",
+        "run_80",
+        "run_81",
+        "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_97",
+        "run_99",
+        "run_101",
+        "run_102",
+        "run_103",
+        "run_104",
+        "run_106",
+        "run_107",
+        "run_108",
+        "run_109",
+        "run_110",
+        "run_113",
+        "run_114",
+        "run_115",
+        "run_117",
+        "run_119",
+        "run_120",
+        "run_121",
+        "run_122",
+        "run_123",
+        "run_126",
+        "run_127",
+        "run_128",
+        "run_129",
+        "run_130",
+        "run_131",
+        "run_132",
+        "run_136",
+        "run_137",
+        "run_138",
+        "run_139",
+        "run_140",
+        "run_142",
+        "run_145",
+        "run_146",
+        "run_148",
+        "run_149",
+        "run_150",
+        "run_151",
+        "run_152",
+        "run_153",
+        "run_154",
+        "run_155",
+        "run_157",
+        "run_159",
+        "run_160",
+        "run_162",
+        "run_163",
+        "run_164",
+        "run_167",
+        "run_168",
+        "run_169",
+        "run_170",
+        "run_171",
+        "run_172",
+        "run_173",
+        "run_175",
+        "run_176",
+        "run_177",
+        "run_179",
+        "run_180",
+        "run_181",
+        "run_182",
+        "run_183",
+        "run_184",
+        "run_185",
+        "run_186",
+        "run_188",
+        "run_190",
+        "run_191",
+        "run_192",
+        "run_193",
+        "run_194",
+        "run_196",
+        "run_199",
+        "run_200",
+        "run_201",
+        "run_202",
+        "run_208",
+        "run_209",
+        "run_210",
+        "run_213",
+        "run_214",
+        "run_215",
+        "run_216",
+        "run_219",
+        "run_221",
+        "run_222",
+        "run_223",
+        "run_224",
+        "run_227",
+        "run_229",
+        "run_230",
+        "run_233",
+        "run_235",
+        "run_236",
+        "run_237",
+        "run_239",
+        "run_240",
+        "run_241",
+        "run_242",
+        "run_243",
+        "run_244",
+        "run_246",
+        "run_247",
+        "run_248",
+        "run_249",
+        "run_251",
+        "run_254",
+        "run_255",
+        "run_258",
+        "run_259",
+        "run_260",
+        "run_261",
+        "run_262",
+        "run_263",
+        "run_264",
+        "run_266",
+        "run_269",
+        "run_275",
+        "run_276",
+        "run_279",
+        "run_280",
+        "run_281",
+        "run_282",
+        "run_283",
+        "run_284",
+        "run_285",
+        "run_286",
+        "run_288",
+        "run_290",
+        "run_291",
+        "run_292",
+        "run_295",
+        "run_296",
+        "run_297",
+        "run_299",
+        "run_300",
+        "run_302",
+        "run_303",
+        "run_305",
+        "run_307",
+        "run_308",
+        "run_309",
+        "run_310",
+        "run_311",
+        "run_312",
+        "run_313",
+        "run_314",
+        "run_315",
+        "run_317",
+        "run_319",
+        "run_321",
+        "run_322",
+        "run_324",
+        "run_325",
+        "run_327",
+        "run_330",
+        "run_332",
+        "run_334",
+        "run_337",
+        "run_338",
+        "run_339",
+        "run_340",
+        "run_341",
+        "run_342",
+        "run_343",
+        "run_345",
+        "run_346",
+        "run_347",
+        "run_348",
+        "run_350",
+        "run_351",
+        "run_352",
+        "run_353"
+    ],
+    "low_drag_val": [
+        "run_7",
+        "run_25",
+        "run_37",
+        "run_40",
+        "run_51",
+        "run_58",
+        "run_60",
+        "run_82",
+        "run_96",
+        "run_111",
+        "run_112",
+        "run_124",
+        "run_143",
+        "run_161",
+        "run_165",
+        "run_198",
+        "run_203",
+        "run_204",
+        "run_207",
+        "run_212",
+        "run_220",
+        "run_231",
+        "run_232",
+        "run_250",
+        "run_252",
+        "run_253",
+        "run_267",
+        "run_272",
+        "run_273",
+        "run_278",
+        "run_289",
+        "run_293",
+        "run_298",
+        "run_318",
+        "run_329",
+        "run_335"
+    ],
+    "low_drag_test": [
+        "run_0",
+        "run_5",
+        "run_15",
+        "run_19",
+        "run_26",
+        "run_30",
+        "run_31",
+        "run_38",
+        "run_46",
+        "run_48",
+        "run_55",
+        "run_68",
+        "run_76",
+        "run_77",
+        "run_95",
+        "run_98",
+        "run_100",
+        "run_105",
+        "run_116",
+        "run_118",
+        "run_125",
+        "run_133",
+        "run_134",
+        "run_135",
+        "run_141",
+        "run_144",
+        "run_147",
+        "run_156",
+        "run_158",
+        "run_166",
+        "run_174",
+        "run_178",
+        "run_187",
+        "run_189",
+        "run_195",
+        "run_197",
+        "run_205",
+        "run_206",
+        "run_211",
+        "run_217",
+        "run_218",
+        "run_225",
+        "run_226",
+        "run_228",
+        "run_234",
+        "run_238",
+        "run_245",
+        "run_256",
+        "run_257",
+        "run_265",
+        "run_268",
+        "run_270",
+        "run_271",
+        "run_274",
+        "run_277",
+        "run_287",
+        "run_294",
+        "run_301",
+        "run_304",
+        "run_306",
+        "run_316",
+        "run_320",
+        "run_323",
+        "run_326",
+        "run_328",
+        "run_331",
+        "run_333",
+        "run_336",
+        "run_344",
+        "run_349",
+        "run_354"
+    ],
+    "geometry_train": [
+        "run_0",
+        "run_1",
+        "run_4",
+        "run_6",
+        "run_7",
+        "run_8",
+        "run_9",
+        "run_12",
+        "run_13",
+        "run_15",
+        "run_16",
+        "run_18",
+        "run_21",
+        "run_22",
+        "run_25",
+        "run_26",
+        "run_27",
+        "run_28",
+        "run_29",
+        "run_30",
+        "run_31",
+        "run_33",
+        "run_35",
+        "run_36",
+        "run_37",
+        "run_38",
+        "run_39",
+        "run_41",
+        "run_42",
+        "run_44",
+        "run_45",
+        "run_46",
+        "run_48",
+        "run_49",
+        "run_51",
+        "run_52",
+        "run_53",
+        "run_54",
+        "run_55",
+        "run_56",
+        "run_62",
+        "run_63",
+        "run_64",
+        "run_67",
+        "run_68",
+        "run_70",
+        "run_71",
+        "run_74",
+        "run_76",
+        "run_77",
+        "run_78",
+        "run_80",
+        "run_82",
+        "run_83",
+        "run_84",
+        "run_85",
+        "run_87",
+        "run_88",
+        "run_90",
+        "run_92",
+        "run_93",
+        "run_96",
+        "run_98",
+        "run_100",
+        "run_101",
+        "run_102",
+        "run_103",
+        "run_104",
+        "run_105",
+        "run_106",
+        "run_108",
+        "run_109",
+        "run_112",
+        "run_113",
+        "run_114",
+        "run_115",
+        "run_116",
+        "run_118",
+        "run_119",
+        "run_120",
+        "run_122",
+        "run_124",
+        "run_125",
+        "run_126",
+        "run_127",
+        "run_129",
+        "run_131",
+        "run_133",
+        "run_135",
+        "run_136",
+        "run_137",
+        "run_138",
+        "run_141",
+        "run_142",
+        "run_144",
+        "run_145",
+        "run_146",
+        "run_147",
+        "run_150",
+        "run_151",
+        "run_153",
+        "run_155",
+        "run_157",
+        "run_158",
+        "run_159",
+        "run_162",
+        "run_163",
+        "run_164",
+        "run_165",
+        "run_166",
+        "run_168",
+        "run_170",
+        "run_171",
+        "run_172",
+        "run_173",
+        "run_174",
+        "run_175",
+        "run_176",
+        "run_177",
+        "run_179",
+        "run_180",
+        "run_181",
+        "run_183",
+        "run_184",
+        "run_185",
+        "run_186",
+        "run_187",
+        "run_188",
+        "run_189",
+        "run_191",
+        "run_192",
+        "run_193",
+        "run_194",
+        "run_195",
+        "run_196",
+        "run_197",
+        "run_198",
+        "run_199",
+        "run_200",
+        "run_201",
+        "run_203",
+        "run_204",
+        "run_205",
+        "run_206",
+        "run_207",
+        "run_208",
+        "run_209",
+        "run_210",
+        "run_212",
+        "run_213",
+        "run_214",
+        "run_215",
+        "run_216",
+        "run_217",
+        "run_219",
+        "run_222",
+        "run_223",
+        "run_226",
+        "run_227",
+        "run_230",
+        "run_232",
+        "run_233",
+        "run_237",
+        "run_241",
+        "run_242",
+        "run_243",
+        "run_245",
+        "run_247",
+        "run_249",
+        "run_250",
+        "run_251",
+        "run_253",
+        "run_255",
+        "run_256",
+        "run_257",
+        "run_258",
+        "run_259",
+        "run_260",
+        "run_261",
+        "run_262",
+        "run_263",
+        "run_265",
+        "run_269",
+        "run_270",
+        "run_271",
+        "run_272",
+        "run_273",
+        "run_274",
+        "run_275",
+        "run_276",
+        "run_278",
+        "run_279",
+        "run_280",
+        "run_281",
+        "run_282",
+        "run_283",
+        "run_284",
+        "run_285",
+        "run_286",
+        "run_289",
+        "run_290",
+        "run_291",
+        "run_293",
+        "run_294",
+        "run_296",
+        "run_297",
+        "run_300",
+        "run_301",
+        "run_302",
+        "run_303",
+        "run_304",
+        "run_305",
+        "run_306",
+        "run_307",
+        "run_308",
+        "run_309",
+        "run_312",
+        "run_313",
+        "run_314",
+        "run_315",
+        "run_316",
+        "run_317",
+        "run_320",
+        "run_321",
+        "run_323",
+        "run_324",
+        "run_325",
+        "run_326",
+        "run_327",
+        "run_328",
+        "run_329",
+        "run_334",
+        "run_336",
+        "run_338",
+        "run_340",
+        "run_341",
+        "run_342",
+        "run_343",
+        "run_344",
+        "run_345",
+        "run_346",
+        "run_347",
+        "run_348",
+        "run_350",
+        "run_351",
+        "run_352",
+        "run_353",
+        "run_354"
+    ],
+    "geometry_val": [
+        "run_2",
+        "run_3",
+        "run_19",
+        "run_23",
+        "run_24",
+        "run_32",
+        "run_34",
+        "run_43",
+        "run_58",
+        "run_61",
+        "run_65",
+        "run_69",
+        "run_73",
+        "run_75",
+        "run_86",
+        "run_89",
+        "run_91",
+        "run_95",
+        "run_99",
+        "run_128",
+        "run_134",
+        "run_156",
+        "run_218",
+        "run_220",
+        "run_225",
+        "run_231",
+        "run_234",
+        "run_235",
+        "run_266",
+        "run_267",
+        "run_277",
+        "run_292",
+        "run_319",
+        "run_322",
+        "run_332",
+        "run_333"
+    ],
+    "geometry_test": [
+        "run_5",
+        "run_10",
+        "run_11",
+        "run_14",
+        "run_17",
+        "run_20",
+        "run_40",
+        "run_47",
+        "run_50",
+        "run_57",
+        "run_59",
+        "run_60",
+        "run_66",
+        "run_72",
+        "run_79",
+        "run_81",
+        "run_94",
+        "run_97",
+        "run_107",
+        "run_110",
+        "run_111",
+        "run_117",
+        "run_121",
+        "run_123",
+        "run_130",
+        "run_132",
+        "run_139",
+        "run_140",
+        "run_143",
+        "run_148",
+        "run_149",
+        "run_152",
+        "run_154",
+        "run_160",
+        "run_161",
+        "run_167",
+        "run_169",
+        "run_178",
+        "run_182",
+        "run_190",
+        "run_202",
+        "run_211",
+        "run_221",
+        "run_224",
+        "run_228",
+        "run_229",
+        "run_236",
+        "run_238",
+        "run_239",
+        "run_240",
+        "run_244",
+        "run_246",
+        "run_248",
+        "run_252",
+        "run_254",
+        "run_264",
+        "run_268",
+        "run_287",
+        "run_288",
+        "run_295",
+        "run_298",
+        "run_299",
+        "run_310",
+        "run_311",
+        "run_318",
+        "run_330",
+        "run_331",
+        "run_335",
+        "run_337",
+        "run_339",
+        "run_349"
+    ],
+    "image_wake_train": [
+        "run_0",
+        "run_1",
+        "run_2",
+        "run_3",
+        "run_5",
+        "run_7",
+        "run_9",
+        "run_11",
+        "run_12",
+        "run_13",
+        "run_16",
+        "run_17",
+        "run_18",
+        "run_19",
+        "run_20",
+        "run_21",
+        "run_23",
+        "run_24",
+        "run_26",
+        "run_27",
+        "run_28",
+        "run_29",
+        "run_30",
+        "run_31",
+        "run_32",
+        "run_33",
+        "run_34",
+        "run_36",
+        "run_38",
+        "run_39",
+        "run_41",
+        "run_42",
+        "run_46",
+        "run_48",
+        "run_49",
+        "run_50",
+        "run_51",
+        "run_53",
+        "run_54",
+        "run_55",
+        "run_56",
+        "run_59",
+        "run_60",
+        "run_61",
+        "run_62",
+        "run_64",
+        "run_66",
+        "run_67",
+        "run_68",
+        "run_69",
+        "run_70",
+        "run_71",
+        "run_72",
+        "run_73",
+        "run_74",
+        "run_75",
+        "run_76",
+        "run_78",
+        "run_79",
+        "run_80",
+        "run_81",
+        "run_82",
+        "run_83",
+        "run_85",
+        "run_86",
+        "run_88",
+        "run_89",
+        "run_91",
+        "run_93",
+        "run_94",
+        "run_96",
+        "run_97",
+        "run_100",
+        "run_102",
+        "run_103",
+        "run_105",
+        "run_106",
+        "run_107",
+        "run_108",
+        "run_109",
+        "run_110",
+        "run_111",
+        "run_113",
+        "run_114",
+        "run_115",
+        "run_116",
+        "run_117",
+        "run_118",
+        "run_120",
+        "run_121",
+        "run_122",
+        "run_125",
+        "run_127",
+        "run_128",
+        "run_129",
+        "run_130",
+        "run_131",
+        "run_132",
+        "run_134",
+        "run_135",
+        "run_137",
+        "run_138",
+        "run_139",
+        "run_141",
+        "run_142",
+        "run_143",
+        "run_144",
+        "run_145",
+        "run_146",
+        "run_147",
+        "run_149",
+        "run_150",
+        "run_152",
+        "run_154",
+        "run_156",
+        "run_157",
+        "run_158",
+        "run_160",
+        "run_161",
+        "run_162",
+        "run_163",
+        "run_164",
+        "run_166",
+        "run_167",
+        "run_168",
+        "run_169",
+        "run_170",
+        "run_171",
+        "run_174",
+        "run_178",
+        "run_179",
+        "run_180",
+        "run_181",
+        "run_182",
+        "run_183",
+        "run_184",
+        "run_185",
+        "run_186",
+        "run_187",
+        "run_189",
+        "run_192",
+        "run_193",
+        "run_194",
+        "run_195",
+        "run_197",
+        "run_199",
+        "run_200",
+        "run_202",
+        "run_203",
+        "run_205",
+        "run_206",
+        "run_207",
+        "run_208",
+        "run_210",
+        "run_211",
+        "run_213",
+        "run_215",
+        "run_217",
+        "run_218",
+        "run_219",
+        "run_221",
+        "run_222",
+        "run_223",
+        "run_224",
+        "run_226",
+        "run_228",
+        "run_229",
+        "run_230",
+        "run_233",
+        "run_234",
+        "run_236",
+        "run_237",
+        "run_238",
+        "run_241",
+        "run_242",
+        "run_244",
+        "run_245",
+        "run_247",
+        "run_249",
+        "run_251",
+        "run_252",
+        "run_253",
+        "run_255",
+        "run_256",
+        "run_257",
+        "run_259",
+        "run_260",
+        "run_261",
+        "run_264",
+        "run_266",
+        "run_267",
+        "run_268",
+        "run_269",
+        "run_270",
+        "run_271",
+        "run_272",
+        "run_274",
+        "run_275",
+        "run_277",
+        "run_279",
+        "run_280",
+        "run_281",
+        "run_284",
+        "run_285",
+        "run_287",
+        "run_289",
+        "run_290",
+        "run_291",
+        "run_294",
+        "run_295",
+        "run_296",
+        "run_300",
+        "run_301",
+        "run_303",
+        "run_304",
+        "run_305",
+        "run_306",
+        "run_308",
+        "run_309",
+        "run_310",
+        "run_311",
+        "run_313",
+        "run_316",
+        "run_318",
+        "run_319",
+        "run_321",
+        "run_323",
+        "run_326",
+        "run_327",
+        "run_328",
+        "run_330",
+        "run_331",
+        "run_333",
+        "run_334",
+        "run_337",
+        "run_339",
+        "run_340",
+        "run_341",
+        "run_342",
+        "run_344",
+        "run_345",
+        "run_346",
+        "run_347",
+        "run_349",
+        "run_351",
+        "run_352",
+        "run_353",
+        "run_354"
+    ],
+    "image_wake_val": [
+        "run_10",
+        "run_15",
+        "run_43",
+        "run_44",
+        "run_65",
+        "run_77",
+        "run_90",
+        "run_95",
+        "run_98",
+        "run_101",
+        "run_133",
+        "run_140",
+        "run_201",
+        "run_209",
+        "run_214",
+        "run_225",
+        "run_227",
+        "run_231",
+        "run_235",
+        "run_239",
+        "run_240",
+        "run_246",
+        "run_254",
+        "run_265",
+        "run_283",
+        "run_288",
+        "run_292",
+        "run_302",
+        "run_307",
+        "run_312",
+        "run_317",
+        "run_320",
+        "run_325",
+        "run_336",
+        "run_348",
+        "run_350"
+    ],
+    "image_wake_test": [
+        "run_4",
+        "run_6",
+        "run_8",
+        "run_14",
+        "run_22",
+        "run_25",
+        "run_35",
+        "run_37",
+        "run_40",
+        "run_45",
+        "run_47",
+        "run_52",
+        "run_57",
+        "run_58",
+        "run_63",
+        "run_84",
+        "run_87",
+        "run_92",
+        "run_99",
+        "run_104",
+        "run_112",
+        "run_119",
+        "run_123",
+        "run_124",
+        "run_126",
+        "run_136",
+        "run_148",
+        "run_151",
+        "run_153",
+        "run_155",
+        "run_159",
+        "run_165",
+        "run_172",
+        "run_173",
+        "run_175",
+        "run_176",
+        "run_177",
+        "run_188",
+        "run_190",
+        "run_191",
+        "run_196",
+        "run_198",
+        "run_204",
+        "run_212",
+        "run_216",
+        "run_220",
+        "run_232",
+        "run_243",
+        "run_248",
+        "run_250",
+        "run_258",
+        "run_262",
+        "run_263",
+        "run_273",
+        "run_276",
+        "run_278",
+        "run_282",
+        "run_286",
+        "run_293",
+        "run_297",
+        "run_298",
+        "run_299",
+        "run_314",
+        "run_315",
+        "run_322",
+        "run_324",
+        "run_329",
+        "run_332",
+        "run_335",
+        "run_338",
+        "run_343"
+    ]
+}

splits/visualize_splits.py

@@ -0,0 +1,110 @@
+"""Create WindsorML train/validation/test diagnostic plots."""
+
+from __future__ import annotations
+
+import csv
+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_force_mom, run_id
+
+
+PACKAGE_ROOT = Path(__file__).resolve().parent
+DATA_DIR = PACKAGE_ROOT
+DOCS_DIR = PACKAGE_ROOT
+MANIFEST = PACKAGE_ROOT / "manifest.json"
+OUT = DOCS_DIR / "split_diagnostics.png"
+
+
+def ids(manifest: dict[str, list[str]], key: str) -> set[int]:
+    return {run_id(case) for case in manifest[key]}
+
+
+def load_scores(path: Path, column: str) -> dict[int, float]:
+    with path.open(encoding="utf-8-sig", newline="") as f:
+        return {int(row["run"]): float(row[column]) for row in csv.DictReader(f) if row.get(column, "")}
+
+
+def arrays(values: dict[int, float]) -> tuple[np.ndarray, np.ndarray]:
+    runs = np.asarray(sorted(values))
+    return runs, np.asarray([values[int(run)] for run in runs], dtype=float)
+
+
+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:
+    masks = {
+        "train": np.asarray([int(run) in train_ids for run in runs]),
+        "val": np.asarray([int(run) in val_ids for run in runs]),
+        "test": np.asarray([int(run) in test_ids for run in runs]),
+    }
+    sizes = {"train": 30, "val": 48, "test": 48}
+    alpha = {"train": 0.58, "val": 0.95, "test": 0.95}
+    for part in ("train", "val", "test"):
+        ax.scatter(runs[masks[part]], values[masks[part]], s=sizes[part], color=colors[part], linewidth=0, alpha=alpha[part])
+    ax.set_title(title)
+    ax.set_xlabel("run ID")
+    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"))
+    force_records, _ = load_force_mom()
+    geometry_scores = load_scores(DATA_DIR / "chamfer_metrics.csv", "ood_score")
+    image_scores = load_scores(DATA_DIR / "image_metrics.csv", "image_wake_score")
+    runs, cd = arrays({run: values["cd"] for run, values in force_records.items()})
+    _, geometry = arrays(geometry_scores)
+    _, image_wake = arrays(image_scores)
+
+    colors = {"train": "#cfd5dc", "val": "#c28f22", "test": "#2f8f61"}
+    fig, axes = plt.subplots(2, 3, figsize=(14.0, 8.2), constrained_layout=True)
+    panels = [
+        ("full", cd, "Full seed-42 baseline", "Cd"),
+        ("high_drag", cd, "High-drag holdout", "Cd"),
+        ("low_drag", cd, "Low-drag holdout", "Cd"),
+        ("geometry", geometry, "STL-Chamfer geometry holdout", "mean 10-NN Chamfer"),
+        ("image_wake", image_wake, "Image-wake holdout", "low-speed wake score"),
+        ("image_wake", cd, "Image-wake holdout on Cd", "Cd"),
+    ]
+    for ax, (prefix, values, title, ylabel) in zip(axes.flat, panels):
+        plot_partitioned(
+            ax,
+            runs,
+            values,
+            ids(manifest, f"{prefix}_train"),
+            ids(manifest, f"{prefix}_val"),
+            ids(manifest, f"{prefix}_test"),
+            title=title,
+            ylabel=ylabel,
+            colors=colors,
+        )
+    handles = [
+        Line2D([0], [0], marker="o", color="none", markerfacecolor=colors[part], markeredgewidth=0, markersize=8, label=part)
+        for part in ("train", "val", "test")
+    ]
+    fig.legend(handles=handles, frameon=False, loc="upper center", ncol=3, bbox_to_anchor=(0.5, 0.995))
+    fig.suptitle("WindsorML split diagnostics", fontsize=13)
+    DOCS_DIR.mkdir(parents=True, exist_ok=True)
+    fig.savefig(OUT, dpi=180)
+    plt.close(fig)
+    print(f"Wrote {OUT}")
+
+
+if __name__ == "__main__":
+    main()