Publish RDDAC teaser

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+rddac_documentation.pdf filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,188 @@
+---
+license: cc-by-4.0
+language:
+  - en
+pretty_name: "RDDAC — Real Deep Drawing and Cutting Dataset (Teaser)"
+size_categories:
+  - n<1K
+tags:
+  - croissant
+  - experimental-data
+  - measurement
+  - sim-to-real
+  - sim2real
+  - scientific-machine-learning
+  - sciml
+  - sheet-metal-forming
+  - metal-forming
+  - deep-drawing
+  - stamping
+  - cutting
+  - manufacturing
+  - materials-science
+  - process-monitoring
+  - laser-scan
+  - point-cloud
+  - time-series
+  - sensor-data
+  - digital-twin
+  - regression
+  - benchmark
+  - engineering
+  - automotive
+  - hdf5
+task_categories:
+  - tabular-regression
+  - time-series-forecasting
+  - other
+---
+# RDDAC — Real Deep Drawing and Cutting Dataset
+
+[![Code License: MIT](https://img.shields.io/badge/Code-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Dataset License: CC BY 4.0](https://img.shields.io/badge/Dataset-CC_BY_4.0-lightgrey.svg)](https://creativecommons.org/licenses/by/4.0/) [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/) [![Documentation](https://img.shields.io/badge/docs-readthedocs.io-blue.svg)](https://rddac.readthedocs.io) [![DaRUS Repository](https://img.shields.io/badge/repository-DaRUS-green.svg)](https://darus.uni-stuttgart.de/dataset.xhtml?persistentId=doi:10.18419/DARUS-5589) [![DOI](https://img.shields.io/badge/DOI-10.18419%2FDARUS--5589-blue.svg)](https://doi.org/10.18419/DARUS-5589)
+
+![Measured point clouds after OP10 and OP20, colored by deviation from the matching DDACS simulation](https://raw.githubusercontent.com/BaumSebastian/RDDAC/main/docs/images/sim2real_sweep.gif)
+
+*Measured point clouds of one experiment after deep drawing (OP10, left) and cutting (OP20, right), colored by the deviation from the matching DDACS simulation.*
+
+**A large-scale experimental dataset of 9,000 physical deep-drawing and cutting experiments — the real-world counterpart to the [DDACS](https://ddacs.readthedocs.io) FEM simulations.** Each experiment forms a modified quadratic cup from DP600 dual-phase steel (deep drawing in OP10, cutting in OP20) and records press force signals, sheet-thickness and oil-film traverses, and high-resolution 3D laser scans of the part after each operation. Use it to quantify the simulation-to-reality gap, train models on real process data, or validate DDACS-trained surrogates against physical measurements.
+
+|  |  |
+|---|---|
+| **Experiments** | 9,000 |
+| **Total size** | ~87 GB (HDF5, lossless) |
+| **Process steps per experiment** | 2 (OP10 deep drawing, OP20 cutting) |
+| **Parameter space** | 2 geometries x 3 blankholder forces x 3 oil types (18 categories) |
+| **Repetitions** | up to 500 per category |
+| **Train / val / test** | 7,200 / 900 / 900 (predefined, seed 42) |
+| **Matching simulations** | DDACS `rddac.zip` (~9 GB), fetched by `rddac download` |
+
+**[Documentation](https://rddac.readthedocs.io)** · **[Dataset DOI](https://doi.org/10.18419/DARUS-5589)** · **[Paper](https://doi.org/10.1007/s12666-026-03870-5)**
+
+## About this sample
+
+This is a **~174 MB teaser** of RDDAC — 18 experiments (one per category) plus the
+Croissant 1.1 manifest, the complete process-parameter table, and the six tutorial
+notebooks — so you can explore the schema and run every tutorial in seconds before
+committing to the full download.
+
+```
+data/
+  metadata.json             Croissant 1.1 manifest (the dataset schema)
+  process_parameters.csv    parameters + splits for all 9,000 experiments
+  h5/sample.zip             18 experiments, one per category (all modalities)
+rddac_documentation.pdf     dataset documentation
+notebooks/                  six end-to-end tutorials (see notebooks/README.md)
+```
+
+**Croissant manifest.** `data/metadata.json` is the
+[Croissant 1.1](https://mlcommons.org/croissant/) manifest — the machine-readable
+schema (every HDF5 field and CSV column) that `rddac.load()` and any
+Croissant-aware tool consume. It is the same manifest published with the full
+dataset on DaRUS ([doi:10.18419/DARUS-5589](https://doi.org/10.18419/DARUS-5589)).
+
+## Installation
+
+```bash
+pip install rddac          # add the PyTorch adapter with: pip install 'rddac[torch]'
+```
+
+## Basic usage
+
+`rddac.open_h5` opens a single experiment in memory and returns an `h5py.File`;
+the visualization helpers plot the raw modalities directly.
+
+```python
+import rddac
+
+# Open one bundled experiment. Four raw modalities per file.
+with rddac.open_h5(0, data_dir="data") as f:
+    force = f["force/data"][:]                 # (n, 8): time, load cells, temp, position, total force
+    z     = f["pointcloud/op10/z"][:]          # (6400000,) flat laser-scan buffer
+    lumi  = f["pointcloud/op10/luminescence"][:]
+
+# The OP10 scan as a 3D point cloud.
+points = rddac.scan_to_pointcloud(z, lumi, stride=4)
+rddac.plot_point_cloud(points, point_size=0.4)
+```
+
+## PyTorch integration
+
+`RDDACDataset` is a `torch.utils.data.IterableDataset` over a Croissant view. It
+auto-shards across DataLoader workers and DDP ranks, and silently skips
+experiments whose zip is missing — so partial downloads (like this teaser) stream
+cleanly.
+
+```python
+from rddac.pytorch import RDDACDataset
+from torch.utils.data import DataLoader
+
+ds = RDDACDataset(view="force-curve", data_dir="data")
+for batch in DataLoader(ds, batch_size=1, num_workers=0):
+    force = batch["force_data"]
+    break
+```
+
+## Tutorials
+
+Six end-to-end notebooks ship in `notebooks/` and are published on
+[Read the Docs](https://rddac.readthedocs.io/en/latest/tutorials/):
+
+1. **Getting started** — install, inspect one experiment, 3D point cloud plot.
+2. **Build your own view** — `rddac.add_view`, manifest inspection, custom RecordSets.
+3. **PyTorch training** — `RDDACDataset`, filters, train/val/test splits.
+4. **Visualization** — scans, point clouds, force curves, traverses.
+5. **Loose HDF5 recipe** — pandas + `h5py` after `--extract --remove-zip`.
+6. **Streaming & numpy export** — `iter_view`, `export_to_numpy`.
+
+## Relationship to DDACS
+
+RDDAC is the experimental counterpart to the [DDACS](https://ddacs.readthedocs.io)
+simulation dataset: same cup geometry, same DP600 steel, same two-stage OP10/OP20
+process. The matching FEM simulations are published in the DDACS dataset as
+`rddac.zip` (~9 GB); `rddac download` fetches them alongside the measurements. The
+`rddac` package API mirrors `ddacs` one to one, so analysis code moves between
+simulation and experiment by swapping the import.
+
+## ⬇️ Get the full dataset
+
+**This sample contains 18 of 9,000 experiments.** The complete RDDAC dataset —
+**9,000 experiments, ~87 GB of lossless HDF5**, with the predefined
+7,200 / 900 / 900 train/val/test split — is hosted on DaRUS with a citable DOI:
+
+### ➡️ https://doi.org/10.18419/DARUS-5589
+
+Everything you ran here scales to the full release unchanged — just point the same
+code at the full download, or let the package fetch it:
+
+```bash
+pip install rddac
+rddac download            # full release  (rddac download --small for this sample)
+```
+
+## Citation
+
+If you use this dataset or code in your research, please cite both the dataset and the paper:
+
+```bibtex
+@dataset{baum2026rddac,
+  title={Real Deep Drawing and Cutting Dataset},
+  author={Baum, Sebastian and Heinzelmann, Pascal},
+  year={2026},
+  publisher={DaRUS},
+  doi={10.18419/DARUS-5589}
+}
+
+@article{baum2026deviation,
+  title={Statistical Analysis of Simulation to Reality Deviation in Deep Drawing with a Benchmark Dataset},
+  author={Baum, Sebastian and Heinzelmann, Pascal and Clau{\ss}, P. and others},
+  journal={Transactions of the Indian Institute of Metals},
+  volume={79},
+  pages={176},
+  year={2026},
+  doi={10.1007/s12666-026-03870-5}
+}
+```
+
+## License
+
+Data: **CC BY 4.0**. Package code: MIT.

data/h5/sample.zip

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

data/metadata.json

@@ -0,0 +1,610 @@
+{
+  "@context": {
+    "@language": "en",
+    "@vocab": "https://schema.org/",
+    "citeAs": "cr:citeAs",
+    "column": "cr:column",
+    "conformsTo": "dct:conformsTo",
+    "containedIn": "cr:containedIn",
+    "cr": "http://mlcommons.org/croissant/",
+    "rai": "http://mlcommons.org/croissant/RAI/",
+    "data": {
+      "@id": "cr:data",
+      "@type": "@json"
+    },
+    "dataType": {
+      "@id": "cr:dataType",
+      "@type": "@vocab"
+    },
+    "dct": "http://purl.org/dc/terms/",
+    "equivalentProperty": "cr:equivalentProperty",
+    "examples": {
+      "@id": "cr:examples",
+      "@type": "@json"
+    },
+    "extract": "cr:extract",
+    "field": "cr:field",
+    "fileProperty": "cr:fileProperty",
+    "fileObject": "cr:fileObject",
+    "fileSet": "cr:fileSet",
+    "format": "cr:format",
+    "includes": "cr:includes",
+    "isLiveDataset": "cr:isLiveDataset",
+    "jsonPath": "cr:jsonPath",
+    "key": "cr:key",
+    "md5": "cr:md5",
+    "parentField": "cr:parentField",
+    "path": "cr:path",
+    "recordSet": "cr:recordSet",
+    "references": "cr:references",
+    "regex": "cr:regex",
+    "repeated": "cr:repeated",
+    "replace": "cr:replace",
+    "samplingRate": "cr:samplingRate",
+    "sc": "https://schema.org/",
+    "separator": "cr:separator",
+    "source": "cr:source",
+    "subField": "cr:subField",
+    "transform": "cr:transform",
+    "wd": "https://www.wikidata.org/wiki/"
+  },
+  "@type": "sc:Dataset",
+  "name": "Real Deep Drawing and Cutting (RDDAC) Dataset",
+  "description": "The Real Deep Drawing and Cutting (RDDAC) Dataset is the experimental counterpart to the DDACS simulation dataset. It contains physical measurements from a deep drawing and cutting process for DP600 sheet metal, captured on modified quadratic cups, and is intended for studying the deviation between finite element simulation and physical reality.\n\nThe dataset comprises approximately 9000 experiments spanning two base geometries (concave, convex) crossed with three blankholder forces (100, 300, 500 kN) and three lubrication patterns (coarse, medium, fine), giving 18 categories with up to 500 repetitions each. Each experiment is stored as a HDF5 file and captures, where available: press force and process signals (load cells and temperature); a sheet thickness traverse; an oil film traverse; and 3D laser scans (height and luminescence) of the part after deep drawing (OP10) and after cutting (OP20).\n\nEach HDF5 file carries named scalar root attributes matching the columns of process_parameters.csv (process_parameters.tab on the DaRUS UI), the central index that maps every experiment to its parameters, data availability flags, and a recommended ML train, validation, and test split. A sample.zip (one experiment per category, 18 files in total) is provided for fast preview without downloading the full dataset. A Croissant 1.1 manifest (metadata.json) describes every field for direct use with mlcroissant. The accompanying Python package includes an optional preprocessing step that reconstructs cleaned 3D point clouds and aligns them to the matching DDACS simulations.",
+  "url": "https://doi.org/10.18419/DARUS-5589",
+  "version": "1.0",
+  "license": "http://creativecommons.org/licenses/by/4.0",
+  "citeAs": "Baum, S., Heinzelmann, P., Clauß, P. et al. Statistical Analysis of Simulation-to-Reality Deviation in Deep Drawing with a Benchmark Dataset. Trans Indian Inst Met 79, 176 (2026). https://doi.org/10.1007/s12666-026-03870-5",
+  "datePublished": "2026-06-01",
+  "creator": [
+    {
+      "@type": "Person",
+      "name": "Baum, Sebastian",
+      "affiliation": "University of Stuttgart",
+      "identifier": ""
+    },
+    {
+      "@type": "Person",
+      "name": "Heinzelmann, Pascal",
+      "affiliation": "University of Stuttgart",
+      "identifier": ""
+    }
+  ],
+  "keywords": [
+    "Deep Drawing",
+    "Sheet Metal Forming",
+    "Machine Learning",
+    "Point Cloud",
+    "Experimental Measurement",
+    "DP600",
+    "Springback",
+    "Sim-to-Real"
+  ],
+  "measurementTechnique": "Physical deep drawing and cutting experiments with force, lubricant, sheet-thickness, and 3D laser-scan measurements.",
+  "conformsTo": "http://mlcommons.org/croissant/1.1",
+  "isLiveDataset": false,
+  "distribution": [
+    {
+      "@type": "cr:FileObject",
+      "@id": "process_parameters_csv",
+      "name": "process_parameters.csv",
+      "description": "Per-experiment parameter table; join to HDF5 files via `index`.",
+      "encodingFormat": "text/csv",
+      "contentUrl": "https://darus.uni-stuttgart.de/api/access/datafile/598301?format=original",
+      "md5": "b78905067334bcd6860360b5869a85ac"
+    },
+    {
+      "@type": "cr:FileObject",
+      "@id": "concave_zip",
+      "name": "concave.zip",
+      "encodingFormat": "application/zip",
+      "contentUrl": "https://darus.uni-stuttgart.de/api/access/datafile/594673",
+      "md5": "853540085b144d6e7ece154a9e204a19"
+    },
+    {
+      "@type": "cr:FileObject",
+      "@id": "convex_zip",
+      "name": "convex.zip",
+      "encodingFormat": "application/zip",
+      "contentUrl": "https://darus.uni-stuttgart.de/api/access/datafile/594674",
+      "md5": "30cb9044460449f5f93b4ce5eb60f552"
+    },
+    {
+      "@type": "cr:FileObject",
+      "@id": "sample_zip",
+      "name": "sample.zip",
+      "encodingFormat": "application/zip",
+      "contentUrl": "https://darus.uni-stuttgart.de/api/access/datafile/594669",
+      "md5": "4b61770b34f0517641df613e00a15e56",
+      "description": "One experiment per category (18 files) for quick tryout/testing. These ids are excluded from concave.zip/convex.zip, so the three zips partition the dataset with no overlap."
+    },
+    {
+      "@type": "cr:FileSet",
+      "@id": "h5-files",
+      "name": "h5-files",
+      "description": "Every per-experiment HDF5 file across the geometry zips and the sample zip (a non-overlapping partition of all experiments).",
+      "containedIn": [
+        {
+          "@id": "concave_zip"
+        },
+        {
+          "@id": "convex_zip"
+        },
+        {
+          "@id": "sample_zip"
+        }
+      ],
+      "encodingFormat": "application/x-hdf5",
+      "includes": [
+        "**/*.h5"
+      ]
+    }
+  ],
+  "recordSet": [
+    {
+      "@type": "cr:RecordSet",
+      "@id": "process-parameters",
+      "name": "process_parameters",
+      "description": "Per-experiment parameter row from process_parameters.csv. Use `index` to look up the matching HDF5 file.",
+      "key": {
+        "@id": "process-parameters/index"
+      },
+      "field": [
+        {
+          "@type": "cr:Field",
+          "@id": "process-parameters/index",
+          "name": "index",
+          "dataType": "sc:Integer",
+          "source": {
+            "fileObject": {
+              "@id": "process_parameters_csv"
+            },
+            "extract": {
+              "column": "index"
+            }
+          },
+          "description": "Unique experiment identifier; matches the HDF5 filename (e.g. index=42 -> 0042.h5)."
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "process-parameters/experiment_id",
+          "name": "experiment_id",
+          "dataType": "sc:Integer",
+          "source": {
+            "fileObject": {
+              "@id": "process_parameters_csv"
+            },
+            "extract": {
+              "column": "experiment_id"
+            }
+          },
+          "description": "Repetition index (1..500) within one geometry×blankholder_force×oil_type category."
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "process-parameters/category",
+          "name": "category",
+          "dataType": "sc:Integer",
+          "source": {
+            "fileObject": {
+              "@id": "process_parameters_csv"
+            },
+            "extract": {
+              "column": "category"
+            }
+          },
+          "description": "Categorical index 0..17 encoding the geometry×blankholder_force×oil_type combination."
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "process-parameters/geometry",
+          "name": "geometry",
+          "dataType": "sc:Text",
+          "source": {
+            "fileObject": {
+              "@id": "process_parameters_csv"
+            },
+            "extract": {
+              "column": "geometry"
+            }
+          },
+          "description": "Base part geometry. One of 'concave', 'convex'."
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "process-parameters/blankholder_force",
+          "name": "blankholder_force",
+          "dataType": "sc:Integer",
+          "source": {
+            "fileObject": {
+              "@id": "process_parameters_csv"
+            },
+            "extract": {
+              "column": "blankholder_force"
+            }
+          },
+          "description": "Blank holder force applied during deep drawing, in kN. One of 100, 300, 500."
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "process-parameters/mean_punch_temp",
+          "name": "mean_punch_temp",
+          "dataType": "sc:Float",
+          "source": {
+            "fileObject": {
+              "@id": "process_parameters_csv"
+            },
+            "extract": {
+              "column": "mean_punch_temp"
+            }
+          },
+          "description": "Mean punch temperature recorded during the experiment, in degC."
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "process-parameters/oil_type",
+          "name": "oil_type",
+          "dataType": "sc:Text",
+          "source": {
+            "fileObject": {
+              "@id": "process_parameters_csv"
+            },
+            "extract": {
+              "column": "oil_type"
+            }
+          },
+          "description": "Lubrication pattern applied to the blank. One of 'coarse', 'medium', 'fine'."
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "process-parameters/has_pointcloud",
+          "name": "has_pointcloud",
+          "dataType": "sc:Boolean",
+          "source": {
+            "fileObject": {
+              "@id": "process_parameters_csv"
+            },
+            "extract": {
+              "column": "has_pointcloud"
+            }
+          },
+          "description": "True if OP10/OP20 3D point-cloud scans are available for this experiment."
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "process-parameters/has_oil",
+          "name": "has_oil",
+          "dataType": "sc:Boolean",
+          "source": {
+            "fileObject": {
+              "@id": "process_parameters_csv"
+            },
+            "extract": {
+              "column": "has_oil"
+            }
+          },
+          "description": "True if the blank was lubricated (oil applied) for this experiment."
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "process-parameters/split",
+          "name": "split",
+          "dataType": "sc:Text",
+          "source": {
+            "fileObject": {
+              "@id": "process_parameters_csv"
+            },
+            "extract": {
+              "column": "split"
+            }
+          },
+          "description": "Recommended ML data split: 'train' (~80%), 'val' (~10%), 'test' (~10%); deterministic, seed=42."
+        }
+      ]
+    },
+    {
+      "@type": "cr:RecordSet",
+      "@id": "field-map",
+      "name": "field-map",
+      "description": "Every raw HDF5 dataset declared once, with its on-disk path and per-file shape. Use-case RecordSets reference entries here.",
+      "field": [
+        {
+          "@type": "cr:Field",
+          "@id": "field-map/force_data",
+          "name": "force_data",
+          "description": "Press force and process signals, time series. Columns: [time (s), load_cell_1..4 (kN), punch_temp (degC), punch_pos (mm), total_force (kN)]. HDF5 path: force/data. Shape (per file): (1140, 8).",
+          "dataType": "sc:Float",
+          "source": {
+            "fileSet": {
+              "@id": "h5-files"
+            },
+            "extract": {
+              "fileProperty": "content"
+            },
+            "transform": [
+              {
+                "regex": "force/data"
+              }
+            ]
+          }
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "field-map/oil_thickness_data",
+          "name": "oil_thickness_data",
+          "description": "Lubricant film measurement along a sensor traverse. Columns: [sensor_position (mm), oil_value (g/m^2)]. HDF5 path: oil_thickness/data. Shape (per file): (421, 2).",
+          "dataType": "sc:Float",
+          "source": {
+            "fileSet": {
+              "@id": "h5-files"
+            },
+            "extract": {
+              "fileProperty": "content"
+            },
+            "transform": [
+              {
+                "regex": "oil_thickness/data"
+              }
+            ]
+          }
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "field-map/pointcloud_op10_luminescence",
+          "name": "pointcloud_op10_luminescence",
+          "description": "Flattened luminescence/intensity buffer of the OP10 scan, pixel-aligned with op10/z. HDF5 path: pointcloud/op10/luminescence. Shape (per file): (6400000).",
+          "dataType": "sc:Float",
+          "source": {
+            "fileSet": {
+              "@id": "h5-files"
+            },
+            "extract": {
+              "fileProperty": "content"
+            },
+            "transform": [
+              {
+                "regex": "pointcloud/op10/luminescence"
+              }
+            ]
+          }
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "field-map/pointcloud_op10_z",
+          "name": "pointcloud_op10_z",
+          "description": "Flattened height (Z) buffer of the OP10 laser scan (after deep drawing), row-major over a y_shape x x_shape grid (see group attributes). Reshape and apply per-pixel calibration to recover a 3D surface (see the rddacs preprocessing step). HDF5 path: pointcloud/op10/z. Shape (per file): (6400000).",
+          "dataType": "sc:Float",
+          "source": {
+            "fileSet": {
+              "@id": "h5-files"
+            },
+            "extract": {
+              "fileProperty": "content"
+            },
+            "transform": [
+              {
+                "regex": "pointcloud/op10/z"
+              }
+            ]
+          }
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "field-map/pointcloud_op20_luminescence",
+          "name": "pointcloud_op20_luminescence",
+          "description": "Flattened luminescence/intensity buffer of the OP20 scan, pixel-aligned with op20/z. HDF5 path: pointcloud/op20/luminescence. Shape (per file): (6400000).",
+          "dataType": "sc:Float",
+          "source": {
+            "fileSet": {
+              "@id": "h5-files"
+            },
+            "extract": {
+              "fileProperty": "content"
+            },
+            "transform": [
+              {
+                "regex": "pointcloud/op20/luminescence"
+              }
+            ]
+          }
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "field-map/pointcloud_op20_z",
+          "name": "pointcloud_op20_z",
+          "description": "Flattened height (Z) buffer of the OP20 laser scan (after cutting), row-major over a y_shape x x_shape grid (see group attributes). HDF5 path: pointcloud/op20/z. Shape (per file): (6400000).",
+          "dataType": "sc:Float",
+          "source": {
+            "fileSet": {
+              "@id": "h5-files"
+            },
+            "extract": {
+              "fileProperty": "content"
+            },
+            "transform": [
+              {
+                "regex": "pointcloud/op20/z"
+              }
+            ]
+          }
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "field-map/sheet_thickness_data",
+          "name": "sheet_thickness_data",
+          "description": "Blank sheet thickness measurement along a sensor traverse. Columns: [sensor_position (mm), sheet_thickness (um)]. HDF5 path: sheet_thickness/data. Shape (per file): (208, 2).",
+          "dataType": "sc:Float",
+          "source": {
+            "fileSet": {
+              "@id": "h5-files"
+            },
+            "extract": {
+              "fileProperty": "content"
+            },
+            "transform": [
+              {
+                "regex": "sheet_thickness/data"
+              }
+            ]
+          }
+        }
+      ]
+    },
+    {
+      "@type": "cr:RecordSet",
+      "@id": "pointcloud-op10",
+      "name": "pointcloud-op10",
+      "description": "OP10 (after deep drawing) raw laser scan: flattened height (z) and luminescence buffers. Reshape with the group's x_shape/y_shape attrs.",
+      "field": [
+        {
+          "@type": "cr:Field",
+          "@id": "pointcloud-op10/pointcloud_op10_z",
+          "name": "pointcloud_op10_z",
+          "dataType": "sc:Float",
+          "source": {
+            "field": {
+              "@id": "field-map/pointcloud_op10_z"
+            }
+          },
+          "description": "Flattened OP10 height buffer."
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "pointcloud-op10/pointcloud_op10_luminescence",
+          "name": "pointcloud_op10_luminescence",
+          "dataType": "sc:Float",
+          "source": {
+            "field": {
+              "@id": "field-map/pointcloud_op10_luminescence"
+            }
+          },
+          "description": "Flattened OP10 luminescence buffer."
+        }
+      ]
+    },
+    {
+      "@type": "cr:RecordSet",
+      "@id": "pointcloud-op20",
+      "name": "pointcloud-op20",
+      "description": "OP20 (after cutting) raw laser scan: flattened height (z) and luminescence buffers.",
+      "field": [
+        {
+          "@type": "cr:Field",
+          "@id": "pointcloud-op20/pointcloud_op20_z",
+          "name": "pointcloud_op20_z",
+          "dataType": "sc:Float",
+          "source": {
+            "field": {
+              "@id": "field-map/pointcloud_op20_z"
+            }
+          },
+          "description": "Flattened OP20 height buffer."
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "pointcloud-op20/pointcloud_op20_luminescence",
+          "name": "pointcloud_op20_luminescence",
+          "dataType": "sc:Float",
+          "source": {
+            "field": {
+              "@id": "field-map/pointcloud_op20_luminescence"
+            }
+          },
+          "description": "Flattened OP20 luminescence buffer."
+        }
+      ]
+    },
+    {
+      "@type": "cr:RecordSet",
+      "@id": "force-curve",
+      "name": "force-curve",
+      "description": "Press force and process signal time series for one experiment.",
+      "field": [
+        {
+          "@type": "cr:Field",
+          "@id": "force-curve/force_data",
+          "name": "force_data",
+          "dataType": "sc:Float",
+          "source": {
+            "field": {
+              "@id": "field-map/force_data"
+            }
+          },
+          "description": "Force/process signal table; see field-map for column layout."
+        }
+      ]
+    },
+    {
+      "@type": "cr:RecordSet",
+      "@id": "sheet-thickness",
+      "name": "sheet-thickness",
+      "description": "Sheet thickness traverse for one experiment (single modality). Measured on the bare blank before lubrication; sensor positions carry a 50 mm offset (raw 50-257 mm).",
+      "field": [
+        {
+          "@type": "cr:Field",
+          "@id": "sheet-thickness/sheet_thickness_data",
+          "name": "sheet_thickness_data",
+          "dataType": "sc:Float",
+          "source": {
+            "field": {
+              "@id": "field-map/sheet_thickness_data"
+            }
+          },
+          "description": "Sheet thickness traverse."
+        }
+      ]
+    },
+    {
+      "@type": "cr:RecordSet",
+      "@id": "oil-thickness",
+      "name": "oil-thickness",
+      "description": "Oil film traverse for one experiment (single modality). Measured on the blank after lubrication. Only present when has_oil is true (filter with the process-parameters has_oil column).",
+      "field": [
+        {
+          "@type": "cr:Field",
+          "@id": "oil-thickness/oil_thickness_data",
+          "name": "oil_thickness_data",
+          "dataType": "sc:Float",
+          "source": {
+            "field": {
+              "@id": "field-map/oil_thickness_data"
+            }
+          },
+          "description": "Oil/lubricant film traverse."
+        }
+      ]
+    },
+    {
+      "@type": "cr:RecordSet",
+      "@id": "thickness",
+      "name": "thickness",
+      "description": "Sheet thickness and lubricant film traverses combined. Requires has_oil=true experiments; use the single-modality views otherwise.",
+      "field": [
+        {
+          "@type": "cr:Field",
+          "@id": "thickness/sheet_thickness_data",
+          "name": "sheet_thickness_data",
+          "dataType": "sc:Float",
+          "source": {
+            "field": {
+              "@id": "field-map/sheet_thickness_data"
+            }
+          },
+          "description": "Sheet thickness traverse."
+        },
+        {
+          "@type": "cr:Field",
+          "@id": "thickness/oil_thickness_data",
+          "name": "oil_thickness_data",
+          "dataType": "sc:Float",
+          "source": {
+            "field": {
+              "@id": "field-map/oil_thickness_data"
+            }
+          },
+          "description": "Oil/lubricant film traverse."
+        }
+      ]
+    }
+  ]
+}

notebooks/02_views.ipynb

@@ -0,0 +1,470 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "0827618f",
+   "metadata": {},
+   "source": [
+    "# Build your own view\n",
+    "\n",
+    "Companion notebook for the RDDAC [documentation](https://rddac.readthedocs.io). It is written to stand on its own: every step is annotated so the notebook reads top to bottom.\n",
+    "\n",
+    "## Walkthrough\n",
+    "\n",
+    "1. load the dataset and list the published RecordSets,\n",
+    "2. look up the available source fields in the `field-map` RecordSet,\n",
+    "3. append a custom RecordSet with slicing,\n",
+    "4. mix in `process-parameters` CSV columns,\n",
+    "5. inspect the resolved source fields and transforms,\n",
+    "6. stream records of the view with `rddac.streaming.iter_view`,\n",
+    "7. register the prefab recipes from `rddac.views`,\n",
+    "8. read the experiment index directly.\n",
+    "\n",
+    "## Assumptions\n",
+    "\n",
+    "- This notebook lives in `notebooks/` of the repository and reads the dataset from `../data/` (on your machine: the directory `rddac download` wrote to).\n",
+    "- The data directory contains `metadata.json`, `process_parameters.csv`, and at least the bundled `sample.zip`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "1d078b0e",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-07T09:01:56.801007Z",
+     "iopub.status.busy": "2026-07-07T09:01:56.800907Z",
+     "iopub.status.idle": "2026-07-07T09:01:58.620063Z",
+     "shell.execute_reply": "2026-07-07T09:01:58.619307Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "rddac 0.1.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "import rddac\n",
+    "print('rddac', rddac.__version__)\n",
+    "\n",
+    "from pathlib import Path\n",
+    "DATA_DIR = Path('../data')\n",
+    "# DATA_DIR = Path('./data')   # uncomment instead when running from the repository root\n",
+    "assert (DATA_DIR / 'metadata.json').is_file(), f'{DATA_DIR} does not contain the dataset'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fe132196",
+   "metadata": {},
+   "source": [
+    "## 1. Load the dataset\n",
+    "\n",
+    "`rddac.load(data_dir=...)` reads `metadata.json` from `data_dir`, registers any zip files it finds there so the HDF5 members can be read in place, and exposes the published RecordSets through `ds.metadata.record_sets`. Listing them first is good practice: a custom view is only ever needed when none of the published ones fit.\n",
+    "\n",
+    "Four h5-backed views ship with the manifest — `force-curve`, `thickness`, `pointcloud-op10`, and `pointcloud-op20` — plus the `process-parameters` index and the `field-map` lookup table that custom views build on."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "b12ab07e",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-07T09:01:58.622101Z",
+     "iopub.status.busy": "2026-07-07T09:01:58.621779Z",
+     "iopub.status.idle": "2026-07-07T09:01:58.760576Z",
+     "shell.execute_reply": "2026-07-07T09:01:58.759921Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "published RecordSets:\n",
+      "  process-parameters\n",
+      "  field-map\n",
+      "  pointcloud-op10\n",
+      "  pointcloud-op20\n",
+      "  force-curve\n",
+      "  sheet-thickness\n",
+      "  oil-thickness\n",
+      "  thickness\n"
+     ]
+    }
+   ],
+   "source": [
+    "ds = rddac.load(data_dir=DATA_DIR)\n",
+    "print('published RecordSets:')\n",
+    "for rs in ds.metadata.record_sets:\n",
+    "    print(f'  {rs.id}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a8dd6ea5",
+   "metadata": {},
+   "source": [
+    "## 2. The `field-map` RecordSet\n",
+    "\n",
+    "Every HDF5 dataset that a view can pull from is declared once in the manifest's `field-map` RecordSet: the field name is what goes on the right-hand side of `add_view(fields=...)`, and the description documents what the array contains. The helper below prints the full lookup table, so there is no need to memorise anything."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "a32d80a1",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-07T09:01:58.762219Z",
+     "iopub.status.busy": "2026-07-07T09:01:58.762108Z",
+     "iopub.status.idle": "2026-07-07T09:01:58.765113Z",
+     "shell.execute_reply": "2026-07-07T09:01:58.764392Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  force_data                       Press force and process signals, time series. Columns: [time (s), load_cell_1..4 (kN), punch_temp (degC), punch_pos (mm), total_force (kN)]. HDF5 path: force/data. Shape (per file): (1140, 8).\n",
+      "  oil_thickness_data               Lubricant film measurement along a sensor traverse. Columns: [sensor_position (mm), oil_value (g/m^2)]. HDF5 path: oil_thickness/data. Shape (per file): (421, 2).\n",
+      "  pointcloud_op10_luminescence     Flattened luminescence/intensity buffer of the OP10 scan, pixel-aligned with op10/z. HDF5 path: pointcloud/op10/luminescence. Shape (per file): (6400000).\n",
+      "  pointcloud_op10_z                Flattened height (Z) buffer of the OP10 laser scan (after deep drawing), row-major over a y_shape x x_shape grid (see group attributes). Reshape and apply per-pixel calibration to recover a 3D surface (see the rddacs preprocessing step). HDF5 path: pointcloud/op10/z. Shape (per file): (6400000).\n",
+      "  pointcloud_op20_luminescence     Flattened luminescence/intensity buffer of the OP20 scan, pixel-aligned with op20/z. HDF5 path: pointcloud/op20/luminescence. Shape (per file): (6400000).\n",
+      "  pointcloud_op20_z                Flattened height (Z) buffer of the OP20 laser scan (after cutting), row-major over a y_shape x x_shape grid (see group attributes). HDF5 path: pointcloud/op20/z. Shape (per file): (6400000).\n",
+      "  sheet_thickness_data             Blank sheet thickness measurement along a sensor traverse. Columns: [sensor_position (mm), sheet_thickness (um)]. HDF5 path: sheet_thickness/data. Shape (per file): (208, 2).\n"
+     ]
+    }
+   ],
+   "source": [
+    "from rddac.croissant import field_map\n",
+    "\n",
+    "for name, f in field_map(ds).items():\n",
+    "    print(f'  {name:32s} {(f.description or \"\")}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "934737c7",
+   "metadata": {},
+   "source": [
+    "## 3. Append a custom RecordSet\n",
+    "\n",
+    "`rddac.add_view(ds, name, fields)` mutates `ds` in place. After it returns, the new RecordSet is part of `ds.metadata.record_sets` and can be streamed exactly like a published one.\n",
+    "\n",
+    "Each entry of `fields` maps an **alias** (the dict key) to a **source field** from `field-map`, plus an optional **index selection** along the first axis. The raw `force/data` table has shape `(n, 8)` with `n` varying per experiment, which makes it a good demonstrator for every supported shape:\n",
+    "\n",
+    "- `force` keeps the whole table -> `(n, 8)`, the form for a model that consumes the full press stroke.\n",
+    "- `force_head` takes rows `0..99` -> `(100, 8)`, a fixed-size window (handy for batching, see the PyTorch notebook).\n",
+    "- `first_sample` takes row `0` -> `(8,)`, a single snapshot; the integer index drops the axis.\n",
+    "- `sheet` is the shortcut form: a bare string means \"the whole field\", same as `(\"...\", None)`.\n",
+    "\n",
+    "The published manifest on DaRUS is **not** modified; only the in-memory dataset grows."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "32d95a8e",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-07T09:01:58.766703Z",
+     "iopub.status.busy": "2026-07-07T09:01:58.766601Z",
+     "iopub.status.idle": "2026-07-07T09:01:58.840512Z",
+     "shell.execute_reply": "2026-07-07T09:01:58.839804Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "record_sets after add_view:\n",
+      "  process-parameters\n",
+      "  field-map\n",
+      "  pointcloud-op10\n",
+      "  pointcloud-op20\n",
+      "  force-curve\n",
+      "  sheet-thickness\n",
+      "  oil-thickness\n",
+      "  thickness\n",
+      "  my-view\n"
+     ]
+    }
+   ],
+   "source": [
+    "rddac.add_view(\n",
+    "    ds,\n",
+    "    'my-view',\n",
+    "    fields={\n",
+    "        'force':        ('force_data', None),             # whole (n, 8) table\n",
+    "        'force_head':   ('force_data', list(range(100))), # fixed 100-row window\n",
+    "        'first_sample': ('force_data', 0),                # one row\n",
+    "        'sheet':        'sheet_thickness_data',           # whole field, shortcut form\n",
+    "    },\n",
+    ")\n",
+    "\n",
+    "print('record_sets after add_view:')\n",
+    "for rs in ds.metadata.record_sets:\n",
+    "    print(f'  {rs.id}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "455ccba5",
+   "metadata": {},
+   "source": [
+    "## 4. Mix in process-parameters columns\n",
+    "\n",
+    "`add_view` also accepts **qualified** field IDs of the form `\"<record-set>/<field>\"`, which lets a single view combine HDF5 fields from `field-map` with CSV columns from `process-parameters`. The two sources are joined on the experiment id automatically: `mlcroissant` requires an explicit cross-source `references` link to validate the manifest, and `add_view` injects one on the first field-map field for you, so no manual join wiring is needed on the consumer side.\n",
+    "\n",
+    "Iteration via `rddac.streaming.iter_view` returns one record per experiment with both kinds of fields side by side: HDF5 arrays and CSV columns appear under their respective aliases. (At this layer the CSV goes through pandas, so strings arrive as `str`, not `bytes`.)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "7d72add9",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-07T09:01:58.842118Z",
+     "iopub.status.busy": "2026-07-07T09:01:58.842012Z",
+     "iopub.status.idle": "2026-07-07T09:02:00.165174Z",
+     "shell.execute_reply": "2026-07-07T09:02:00.164278Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "experiment    0: force_head.shape=(100, 8)  geometry='concave'  blankholder_force=100 kN  oil_type='coarse'  split='val'\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "experiment 4500: force_head.shape=(100, 8)  geometry='convex'  blankholder_force=100 kN  oil_type='coarse'  split='train'\n"
+     ]
+    }
+   ],
+   "source": [
+    "rddac.add_view(\n",
+    "    ds,\n",
+    "    'my-view-with-params',\n",
+    "    fields={\n",
+    "        'force_head':         ('force_data', list(range(100))),\n",
+    "        'geometry':           'process-parameters/geometry',\n",
+    "        'blankholder_force':  'process-parameters/blankholder_force',\n",
+    "        'oil_type':           'process-parameters/oil_type',\n",
+    "        'split':              'process-parameters/split',\n",
+    "    },\n",
+    ")\n",
+    "\n",
+    "for rec in rddac.streaming.iter_view(\n",
+    "    'my-view-with-params',\n",
+    "    data_dir=DATA_DIR,\n",
+    "    dataset=ds,\n",
+    "    sim_ids=[0, 4500],\n",
+    "):\n",
+    "    print(f\"experiment {rec['_sim_id']:4d}: force_head.shape={rec['force_head'].shape}  \"\n",
+    "          f\"geometry={rec['geometry']!r}  blankholder_force={rec['blankholder_force']} kN  \"\n",
+    "          f\"oil_type={rec['oil_type']!r}  split={rec['split']!r}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "975c5ab0",
+   "metadata": {},
+   "source": [
+    "## 5. Inspect the new view's fields\n",
+    "\n",
+    "Each field of the view stores a **source** (the field-map entry it pulls from) and an **optional JSONPath transform** that records the index selection:\n",
+    "\n",
+    "- `(\"field_id\", 0)` -> JSONPath `$[0]`\n",
+    "- `(\"field_id\", [0, 1, ...])` -> JSONPath `$[0,1,...]`\n",
+    "- `\"field_id\"` or `(\"field_id\", None)` -> no transform (whole field)\n",
+    "\n",
+    "Printing the resolved transforms is a quick way to verify the view was built as expected before you start training on it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "93d5169b",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-07T09:02:00.167153Z",
+     "iopub.status.busy": "2026-07-07T09:02:00.166906Z",
+     "iopub.status.idle": "2026-07-07T09:02:00.171823Z",
+     "shell.execute_reply": "2026-07-07T09:02:00.170983Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  my-view/force            <- field-map/force_data         transforms=[]\n",
+      "  my-view/force_head       <- field-map/force_data         transforms=['$[0,1,2,3,4,5,6,7,8,9,10,11...']\n",
+      "  my-view/first_sample     <- field-map/force_data         transforms=['$[0]']\n",
+      "  my-view/sheet            <- field-map/sheet_thickness_data transforms=[]\n"
+     ]
+    }
+   ],
+   "source": [
+    "view = next(rs for rs in ds.metadata.record_sets if rs.id == 'my-view')\n",
+    "for f in view.fields:\n",
+    "    transforms = [t.json_path for t in (f.source.transforms or [])]\n",
+    "    shown = [t if len(t) <= 30 else t[:27] + '...' for t in transforms]\n",
+    "    print(f'  {f.id:24s} <- {f.source.uuid:28s} transforms={shown}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "048ec63b",
+   "metadata": {},
+   "source": [
+    "## 6. Stream records of the view\n",
+    "\n",
+    "> **Heads up.** Do **not** iterate an h5-backed view through `ds.records(view)`. `mlcroissant` walks the whole FileSet at iterator setup and materialises every HDF5 member of every referenced zip before applying any filter — with the full release local (two ~40 GB zips) it did not produce a first record within several minutes in our tests. This path is fine for CSV-backed RecordSets (step 8 below) but the wrong tool for the measurement data.\n",
+    ">\n",
+    "> Two replacements both work and both scale to the full release. They share the same lazy `experiment id -> local zip` index, open a zip only when a record is actually requested, and silently skip experiments whose zip is missing on a partial download. Both accept the `dataset=` kwarg so the in-memory `add_view` mutation flows through:\n",
+    ">\n",
+    "> ```python\n",
+    "> # No-PyTorch path: plain Python generator (this notebook + 06_streaming).\n",
+    "> for rec in rddac.streaming.iter_view('my-view', data_dir=DATA_DIR, dataset=ds):\n",
+    ">     ...\n",
+    ">\n",
+    "> # PyTorch path: torch.utils.data.IterableDataset for DataLoader batching (03_pytorch).\n",
+    "> from rddac import RDDACDataset\n",
+    "> custom_ds = RDDACDataset(view='my-view', data_dir=DATA_DIR, dataset=ds)\n",
+    "> ```\n",
+    "\n",
+    "Each record is a dict keyed by the aliases declared in `add_view`, with values already sliced according to the JSONPath transform, plus a private `_sim_id` key carrying the experiment id. `first_sample` comes out as `(8,)` (the `$[0]` transform dropped the first axis) while `force` keeps the full per-experiment `(n, 8)` shape — note how `n` differs between the two experiments below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "a007a9b9",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-07T09:02:00.173504Z",
+     "iopub.status.busy": "2026-07-07T09:02:00.173322Z",
+     "iopub.status.idle": "2026-07-07T09:02:00.221711Z",
+     "shell.execute_reply": "2026-07-07T09:02:00.221031Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "experiment    0\n",
+      "  force          shape=(1140, 8)  dtype=float32\n",
+      "  force_head     shape=(100, 8)  dtype=float32\n",
+      "  first_sample   shape=(8,)  dtype=float32\n",
+      "  sheet          shape=(208, 2)  dtype=float32\n",
+      "experiment 4500\n",
+      "  force          shape=(720, 8)  dtype=float32\n",
+      "  force_head     shape=(100, 8)  dtype=float32\n",
+      "  first_sample   shape=(8,)  dtype=float32\n",
+      "  sheet          shape=(208, 2)  dtype=float32\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "for rec in rddac.streaming.iter_view('my-view', data_dir=DATA_DIR, dataset=ds, sim_ids=[0, 4500]):\n",
+    "    print(f\"experiment {rec['_sim_id']:4d}\")\n",
+    "    for k, v in rec.items():\n",
+    "        if k.startswith('_'):\n",
+    "            continue\n",
+    "        arr = np.asarray(v)\n",
+    "        print(f'  {k:14s} shape={arr.shape}  dtype={arr.dtype}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b31d5795",
+   "metadata": {},
+   "source": [
+    "## 8. Read the experiment index\n",
+    "\n",
+    "The `process-parameters` RecordSet is sourced from the CSV (not from the h5 zips), so the plain `mlcroissant` records iterator works regardless of which zips are downloaded locally — this is the one RecordSet where `ds.records(...)` is the canonical access path. For tabular work, `pandas.read_csv(DATA_DIR / 'process_parameters.csv')` is one line away."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "949f0eb6",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-07T09:02:00.223417Z",
+     "iopub.status.busy": "2026-07-07T09:02:00.223299Z",
+     "iopub.status.idle": "2026-07-07T09:02:00.247872Z",
+     "shell.execute_reply": "2026-07-07T09:02:00.247287Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  process-parameters/index                   = 0\n",
+      "  process-parameters/experiment_id           = 1\n",
+      "  process-parameters/category                = 0\n",
+      "  process-parameters/geometry                = b'concave'\n",
+      "  process-parameters/blankholder_force       = 100\n",
+      "  process-parameters/mean_punch_temp         = 20.2\n",
+      "  process-parameters/oil_type                = b'coarse'\n",
+      "  process-parameters/has_pointcloud          = True\n",
+      "  process-parameters/has_oil                 = True\n",
+      "  process-parameters/split                   = b'val'\n"
+     ]
+    }
+   ],
+   "source": [
+    "for n, rec in enumerate(ds.records('process-parameters'), start=1):\n",
+    "    if n == 1:\n",
+    "        for k, v in rec.items():\n",
+    "            print(f'  {k:42s} = {v}')\n",
+    "    if n >= 1:\n",
+    "        break"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

notebooks/03_pytorch.ipynb

@@ -0,0 +1,569 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "5ab3480b",
+   "metadata": {},
+   "source": [
+    "# PyTorch training\n",
+    "\n",
+    "Companion notebook for the RDDAC [documentation](https://rddac.readthedocs.io). It is written to stand on its own: every step is annotated so the notebook reads top to bottom.\n",
+    "\n",
+    "## Walkthrough\n",
+    "\n",
+    "1. construct an `RDDACDataset` over a published view,\n",
+    "2. stream single records through a `DataLoader` (the raw signals are ragged),\n",
+    "3. batch properly with a fixed-shape custom view via `add_view` + `dataset=`,\n",
+    "4. filter via process-parameter columns and an explicit `sim_ids` allowlist,\n",
+    "5. build the canonical train / val / test splits from the CSV `split` column,\n",
+    "6. enable per-shard shuffle and `set_epoch` for multi-epoch training,\n",
+    "7. understand the metadata-column limitation and its workarounds,\n",
+    "8. run a minimal training-loop skeleton.\n",
+    "\n",
+    "## Assumptions\n",
+    "\n",
+    "- This notebook lives in `notebooks/` of the repository and reads the dataset from `../data/` (on your machine: the directory `rddac download` wrote to).\n",
+    "- The data directory contains `metadata.json`, `process_parameters.csv`, and at least the bundled `sample.zip`.\n",
+    "- The PyTorch extra is installed: `pip install rddac[torch]`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "abb54f16",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-07T09:02:01.880898Z",
+     "iopub.status.busy": "2026-07-07T09:02:01.880754Z",
+     "iopub.status.idle": "2026-07-07T09:02:03.720461Z",
+     "shell.execute_reply": "2026-07-07T09:02:03.719726Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "rddac 0.1.0\n",
+      "sample experiments: [0, 500, 1002, 1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000, 5500, 6000, 6500, 7000, 7500, 8000, 8500]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "import zipfile\n",
+    "from pathlib import Path\n",
+    "\n",
+    "import rddac\n",
+    "from rddac import RDDACDataset\n",
+    "from torch.utils.data import DataLoader\n",
+    "\n",
+    "print('rddac', rddac.__version__)\n",
+    "\n",
+    "DATA_DIR = Path('../data')\n",
+    "# DATA_DIR = Path('./data')   # uncomment instead when running from the repository root\n",
+    "assert (DATA_DIR / 'metadata.json').is_file(), f'{DATA_DIR} does not contain the dataset'\n",
+    "\n",
+    "# The 18 experiments bundled in sample.zip (one per category) - a cheap allowlist for the demos below.\n",
+    "with zipfile.ZipFile(DATA_DIR / 'h5' / 'sample.zip') as zf:\n",
+    "    SAMPLE_IDS = sorted(int(Path(n).stem) for n in zf.namelist() if n.endswith('.h5'))\n",
+    "print('sample experiments:', SAMPLE_IDS)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "59de6163",
+   "metadata": {},
+   "source": [
+    "## 1. Construct an `RDDACDataset`\n",
+    "\n",
+    "`RDDACDataset(view, data_dir, ...)` is a `torch.utils.data.IterableDataset` that streams records of a Croissant view. At construction time it:\n",
+    "\n",
+    "1. loads the manifest (same code path as `rddac.load`),\n",
+    "2. resolves the view's fields to HDF5 paths and JSONPath transforms,\n",
+    "3. scans `data_dir` for zip files and builds an index `experiment id -> local zip path`,\n",
+    "4. reads `process_parameters.csv` and applies the optional `sim_ids` allowlist and `where` predicate.\n",
+    "\n",
+    "(The `sim_ids` argument name is kept for drop-in DDACS compatibility — for RDDAC the ids are experiment ids.) After construction it knows exactly which experiments are locally available; iteration silently skips ones whose zip is missing, so a partial download still streams whatever is on disk."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "b8ffffe3",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-07T09:02:03.722209Z",
+     "iopub.status.busy": "2026-07-07T09:02:03.721996Z",
+     "iopub.status.idle": "2026-07-07T09:02:03.857389Z",
+     "shell.execute_reply": "2026-07-07T09:02:03.856753Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "view:            force-curve\n",
+      "field specs:     {'force_data': ('force/data', None)}\n",
+      "total sim_ids:   9000 (every experiment in process_parameters.csv)\n",
+      "locally indexed: 18 (only these will actually stream)\n"
+     ]
+    }
+   ],
+   "source": [
+    "ds_force = RDDACDataset(view='force-curve', data_dir=DATA_DIR)\n",
+    "print('view:           ', ds_force.view)\n",
+    "print('field specs:    ', ds_force._field_specs)\n",
+    "print('total sim_ids:  ', len(ds_force._sim_ids), '(every experiment in process_parameters.csv)')\n",
+    "print('locally indexed:', len(ds_force._h5_index), '(only these will actually stream)')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4c9af18c",
+   "metadata": {},
+   "source": [
+    "## 2. Single records through a `DataLoader`\n",
+    "\n",
+    "`RDDACDataset` plugs straight into a `DataLoader` with no extra glue. One thing is specific to the *raw* experimental data though: the press was sampled until the operator stopped the recording, so `force/data` has a **per-experiment row count** (`n` differs). The default `collate_fn` stacks each field along a new batch axis and therefore needs equal shapes — with a ragged field that only works at `batch_size=1`.\n",
+    "\n",
+    "The two experiments below make the raggedness visible: `(1, 1140, 8)` vs `(1, 1141, 8)`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "f193d080",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-07T09:02:03.859125Z",
+     "iopub.status.busy": "2026-07-07T09:02:03.859018Z",
+     "iopub.status.idle": "2026-07-07T09:02:04.018796Z",
+     "shell.execute_reply": "2026-07-07T09:02:04.018185Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  force_data   shape=(1, 1140, 8) dtype=torch.float32\n",
+      "  force_data   shape=(1, 720, 8) dtype=torch.float32\n"
+     ]
+    }
+   ],
+   "source": [
+    "loader = DataLoader(RDDACDataset(view='force-curve', data_dir=DATA_DIR, sim_ids=[0, 4500]),\n",
+    "                    batch_size=1, num_workers=0)\n",
+    "for batch in loader:\n",
+    "    for k, v in batch.items():\n",
+    "        print(f'  {k:12s} shape={tuple(v.shape)} dtype={v.dtype}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0582de03",
+   "metadata": {},
+   "source": [
+    "## 3. Fixed-shape batching via a custom view\n",
+    "\n",
+    "For real batches, give every record the same shape. The cleanest lever is a custom view that slices a **fixed window** out of the ragged table — here the first 512 rows of `force/data`, so every record is `(512, 8)`.\n",
+    "\n",
+    "To stream a view built with `rddac.add_view` through `RDDACDataset`, pass the same loaded object via the `dataset=` kwarg. Without it, `RDDACDataset.__init__` would re-parse `metadata.json` from disk and the in-memory mutation would be invisible (it would raise `ValueError: view 'force-window' not found`). With it, the constructor uses the caller's object as-is.\n",
+    "\n",
+    "`num_workers=2` demonstrates the automatic sharding: each worker gets a disjoint slice of the id list (`sim_ids[worker_id::num_workers]`), so no experiment is produced twice."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "bc2a6bdd",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-07T09:02:04.020718Z",
+     "iopub.status.busy": "2026-07-07T09:02:04.020611Z",
+     "iopub.status.idle": "2026-07-07T09:02:05.323248Z",
+     "shell.execute_reply": "2026-07-07T09:02:05.322415Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  batch 0: window shape=(4, 512, 8) dtype=torch.float32\n",
+      "  batch 1: window shape=(4, 512, 8) dtype=torch.float32\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  batch 2: window shape=(4, 512, 8) dtype=torch.float32\n"
+     ]
+    }
+   ],
+   "source": [
+    "ds_manifest = rddac.load(data_dir=DATA_DIR)\n",
+    "rddac.add_view(\n",
+    "    ds_manifest,\n",
+    "    'force-window',\n",
+    "    fields={\n",
+    "        'window': ('force_data', list(range(512))),   # first 512 samples -> (512, 8) for every experiment\n",
+    "    },\n",
+    ")\n",
+    "\n",
+    "windowed = RDDACDataset(view='force-window', data_dir=DATA_DIR, dataset=ds_manifest, sim_ids=SAMPLE_IDS)\n",
+    "loader = DataLoader(windowed, batch_size=4, num_workers=2)\n",
+    "for i, batch in enumerate(loader):\n",
+    "    print(f'  batch {i}: window shape={tuple(batch[\"window\"].shape)} dtype={batch[\"window\"].dtype}')\n",
+    "    if i >= 2:\n",
+    "        break"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a5bfde27",
+   "metadata": {},
+   "source": [
+    "## 4. Filter via the Croissant manifest\n",
+    "\n",
+    "Both filters run against `process_parameters.csv` rows **before** any zip is opened, so the IO scales with the surviving experiments rather than with the full 9 000.\n",
+    "\n",
+    "The row keys are not magic: they come straight from the Croissant manifest. `metadata.json` declares `process_parameters.csv` as a `FileObject` and exposes its columns as the `process-parameters` RecordSet. `RDDACDataset` simply consumes those rows at construction time and applies the predicate before any zip is touched.\n",
+    "\n",
+    "### What `where` receives\n",
+    "\n",
+    "`RDDACDataset` reads `process_parameters.csv` with `pandas` and runs `where` once per row via `df.apply(where, axis=1)`. The `row` argument is a `pandas.Series` whose index is the CSV column names, so you can read columns with either `row['split']` or `row.split`. Values come back as native Python types (strings are `str` here, not the `bytes` that `mlcroissant` yields):\n",
+    "\n",
+    "| Column | Type | Example |\n",
+    "|--------|------|---------|\n",
+    "| `index` | `int` | `42` (the experiment id, matches the h5 filename) |\n",
+    "| `experiment_id` | `int` | `43` (1-based repetition counter within the category) |\n",
+    "| `category` | `int` | `0` ... `17` |\n",
+    "| `geometry` | `str` | `'concave'`, `'convex'` |\n",
+    "| `blankholder_force` | `int` | `100`, `300`, `500` (kN) |\n",
+    "| `mean_punch_temp` | `float` | `20.2` (degC) |\n",
+    "| `oil_type` | `str` | `'coarse'`, `'medium'`, `'fine'` |\n",
+    "| `has_pointcloud`, `has_oil` | `bool` | `True` |\n",
+    "| `split` | `str` | `'train'`, `'val'`, `'test'` |\n",
+    "\n",
+    "Any predicate returning truthy keeps the row.\n",
+    "\n",
+    "- `where=<callable>`: any function `pd.Series -> bool`.\n",
+    "- `sim_ids=[...]`: explicit allowlist of integers, applied before `where`.\n",
+    "\n",
+    "Both can be combined; the predicate is applied after the allowlist."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "1be58721",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-07T09:02:05.325652Z",
+     "iopub.status.busy": "2026-07-07T09:02:05.325449Z",
+     "iopub.status.idle": "2026-07-07T09:02:05.771103Z",
+     "shell.execute_reply": "2026-07-07T09:02:05.770465Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "convex-only sim_ids:         4500 (of 9000)\n",
+      "500 kN + oiled sim_ids:      2988\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sim_ids=SAMPLE_IDS:            18\n"
+     ]
+    }
+   ],
+   "source": [
+    "convex = RDDACDataset(\n",
+    "    view='force-curve',\n",
+    "    data_dir=DATA_DIR,\n",
+    "    where=lambda row: row['geometry'] == 'convex',\n",
+    ")\n",
+    "print(f'convex-only sim_ids:        {len(convex._sim_ids):>5d} (of 9000)')\n",
+    "\n",
+    "heavy_oiled = RDDACDataset(\n",
+    "    view='force-curve',\n",
+    "    data_dir=DATA_DIR,\n",
+    "    where=lambda row: row['blankholder_force'] == 500 and row['has_oil'],\n",
+    ")\n",
+    "print(f'500 kN + oiled sim_ids:     {len(heavy_oiled._sim_ids):>5d}')\n",
+    "\n",
+    "ids_only = RDDACDataset(\n",
+    "    view='force-curve',\n",
+    "    data_dir=DATA_DIR,\n",
+    "    sim_ids=SAMPLE_IDS,\n",
+    ")\n",
+    "print(f'sim_ids=SAMPLE_IDS:         {len(ids_only._sim_ids):>5d}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dd491320",
+   "metadata": {},
+   "source": [
+    "## 5. Train / val / test splits\n",
+    "\n",
+    "`process_parameters.csv` ships with a `split` column whose canonical values are `'train'`, `'val'`, and `'test'`. Because the column is part of the Croissant manifest, the same `where=` predicate that filtered by geometry above works on it. Three `RDDACDataset` instances, one per split, is the fastest way to wire up a training loop without writing any custom partitioning code.\n",
+    "\n",
+    "Shuffle the train split for SGD; leave `val`/`test` deterministic for reproducible evaluation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "3ffc77e6",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-07T09:02:05.773003Z",
+     "iopub.status.busy": "2026-07-07T09:02:05.772892Z",
+     "iopub.status.idle": "2026-07-07T09:02:06.312332Z",
+     "shell.execute_reply": "2026-07-07T09:02:06.311363Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train:  7200 sim_ids (of 9000),    14 streamable now (zip on disk)\n",
+      "  val:   900 sim_ids (of 9000),     2 streamable now (zip on disk)\n",
+      " test:   900 sim_ids (of 9000),     2 streamable now (zip on disk)\n"
+     ]
+    }
+   ],
+   "source": [
+    "splits = {}\n",
+    "for name in ('train', 'val', 'test'):\n",
+    "    splits[name] = RDDACDataset(\n",
+    "        view='force-curve',\n",
+    "        data_dir=DATA_DIR,\n",
+    "        where=lambda row, n=name: row['split'] == n,\n",
+    "        shuffle=(name == 'train'),\n",
+    "        seed=42,\n",
+    "    )\n",
+    "\n",
+    "for name, split_ds in splits.items():\n",
+    "    streamable = sum(1 for sid in split_ds._sim_ids if sid in split_ds._h5_index)\n",
+    "    print(f'{name:>5s}: {len(split_ds._sim_ids):>5d} sim_ids (of 9000), {streamable:>5d} streamable now (zip on disk)')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "05a3b1d8",
+   "metadata": {},
+   "source": [
+    "## 6. Shuffle + `set_epoch`\n",
+    "\n",
+    "`shuffle=True` permutes each shard with a seed derived from `seed + epoch + shard_id`. Worker shards stay disjoint, so two workers do not produce the same experiment. Call `set_epoch(n)` once per epoch to get a different permutation each time. Without it, every epoch sees the same order, which biases optimisation.\n",
+    "\n",
+    "Records do not carry the experiment id (that is `iter_view`'s `_sim_id` extra), so the cell below fingerprints the first record of each epoch by its data sum — the changing fingerprint shows the permutation changing."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "d441bdec",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-07T09:02:06.314064Z",
+     "iopub.status.busy": "2026-07-07T09:02:06.313885Z",
+     "iopub.status.idle": "2026-07-07T09:02:06.401700Z",
+     "shell.execute_reply": "2026-07-07T09:02:06.400895Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 0: first record fingerprint sum=    240630.2\n",
+      "epoch 1: first record fingerprint sum=    232123.9\n",
+      "epoch 2: first record fingerprint sum=    258301.7\n"
+     ]
+    }
+   ],
+   "source": [
+    "ds_shuf = RDDACDataset(\n",
+    "    view='force-window',\n",
+    "    data_dir=DATA_DIR,\n",
+    "    dataset=ds_manifest,\n",
+    "    sim_ids=SAMPLE_IDS,\n",
+    "    shuffle=True,\n",
+    "    seed=42,\n",
+    ")\n",
+    "for epoch in range(3):\n",
+    "    ds_shuf.set_epoch(epoch)\n",
+    "    first = next(iter(ds_shuf))\n",
+    "    print(f'epoch {epoch}: first record fingerprint sum={float(first[\"window\"].sum()):>12.1f}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7856bb22",
+   "metadata": {},
+   "source": [
+    "## 7. Metadata columns: the `RDDACDataset` limitation\n",
+    "\n",
+    "Views that mix in `process-parameters` CSV columns (qualified `\"process-parameters/<col>\"` entries) **cannot** be streamed through `RDDACDataset`: the adapter only resolves field-map sources and raises `ValueError` at construction. Three workarounds, in order of preference:\n",
+    "\n",
+    "1. **Keep the view pure h5** — the training-relevant metadata is usually better expressed as a `where=` filter or a label lookup anyway.\n",
+    "2. **Join the metadata yourself** — `pandas.read_csv(DATA_DIR / 'process_parameters.csv')` indexed by `index` gives you labels per experiment id; combine with `sim_ids=`.\n",
+    "3. **`rddac.streaming.iter_view`** — handles mixed views (it joins the CSV internally), at the cost of doing your own batching.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "1749cae0",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-07T09:02:06.403443Z",
+     "iopub.status.busy": "2026-07-07T09:02:06.403248Z",
+     "iopub.status.idle": "2026-07-07T09:02:06.786369Z",
+     "shell.execute_reply": "2026-07-07T09:02:06.785616Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "RDDACDataset: ValueError: view field 'geometry' sources RecordSet 'process-parameters', but this dataset only streams 'field-map' (HDF5) fields. For views that include process-parameters metadata columns use streaming.iter_view, or build the view from field-map fields only.\n",
+      "iter_view:    force.shape=(1140, 8)  geometry='concave'  blankholder_force=100 kN  split='val'\n"
+     ]
+    }
+   ],
+   "source": [
+    "mixed = rddac.load(data_dir=DATA_DIR)\n",
+    "rddac.add_view(mixed, 'force-signals', fields={\n",
+    "    'force': 'force_data',\n",
+    "    'geometry': 'process-parameters/geometry',     # CSV columns -> not RDDACDataset-compatible\n",
+    "    'blankholder_force': 'process-parameters/blankholder_force',\n",
+    "    'split': 'process-parameters/split',\n",
+    "})\n",
+    "\n",
+    "try:\n",
+    "    RDDACDataset(view='force-signals', data_dir=DATA_DIR, dataset=mixed)\n",
+    "except ValueError as e:\n",
+    "    print(f'RDDACDataset: ValueError: {e}')\n",
+    "\n",
+    "# Workaround 3: iter_view streams the mixed view without complaint.\n",
+    "for rec in rddac.streaming.iter_view('force-signals', data_dir=DATA_DIR, dataset=mixed, sim_ids=[0]):\n",
+    "    print(f\"iter_view:    force.shape={rec['force'].shape}  geometry={rec['geometry']!r}  \"\n",
+    "          f\"blankholder_force={rec['blankholder_force']} kN  split={rec['split']!r}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "694b20ad",
+   "metadata": {},
+   "source": [
+    "## 8. Training-loop skeleton\n",
+    "\n",
+    "Everything above composes into the usual PyTorch loop. The toy task: predict the **peak total press force** from the first 512 samples of the four load cells — input `(512, 4)`, target a scalar, both cut from the same `force-window` view so no metadata join is needed. This is a skeleton, not an experiment: 18 experiments, no validation, three epochs, and the raw kN scale is left unnormalised — expect the loss to be large and noisy. The point is the wiring:\n",
+    "\n",
+    "- `set_epoch(epoch)` before each pass so the shuffle reseeds,\n",
+    "- fields arrive as a dict of tensors; slice columns inside the step,\n",
+    "- swap `SAMPLE_IDS` for `where=lambda r: r['split'] == 'train'` to scale the same loop to the full release."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "fb9b87ba",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-07T09:02:06.788006Z",
+     "iopub.status.busy": "2026-07-07T09:02:06.787832Z",
+     "iopub.status.idle": "2026-07-07T09:02:11.576439Z",
+     "shell.execute_reply": "2026-07-07T09:02:11.575328Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 0: mean MSE loss = 103331.1 (raw kN^2 scale, illustrative only)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 1: mean MSE loss = 33068.9 (raw kN^2 scale, illustrative only)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "epoch 2: mean MSE loss = 11153.1 (raw kN^2 scale, illustrative only)\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "\n",
+    "train_ds = RDDACDataset(view='force-window', data_dir=DATA_DIR, dataset=ds_manifest,\n",
+    "                        sim_ids=SAMPLE_IDS, shuffle=True, seed=0)\n",
+    "train_loader = DataLoader(train_ds, batch_size=4, num_workers=0)\n",
+    "\n",
+    "model = nn.Sequential(nn.Flatten(), nn.Linear(512 * 4, 64), nn.ReLU(), nn.Linear(64, 1))\n",
+    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n",
+    "loss_fn = nn.MSELoss()\n",
+    "\n",
+    "for epoch in range(3):\n",
+    "    train_ds.set_epoch(epoch)\n",
+    "    total, batches = 0.0, 0\n",
+    "    for batch in train_loader:\n",
+    "        window = batch['window']                      # (B, 512, 8) float32\n",
+    "        x = window[:, :, 1:5]                         # the four load cells   -> (B, 512, 4)\n",
+    "        y = window[:, :, 7].amax(dim=1, keepdim=True) # peak total force [kN] -> (B, 1)\n",
+    "        optimizer.zero_grad()\n",
+    "        loss = loss_fn(model(x), y)\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        total, batches = total + loss.item(), batches + 1\n",
+    "    print(f'epoch {epoch}: mean MSE loss = {total / batches:.1f} (raw kN^2 scale, illustrative only)')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

notebooks/05_loose_h5.ipynb

@@ -0,0 +1,371 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9bbc94a2",
+   "metadata": {},
+   "source": [
+    "# Loose HDF5 recipe\n",
+    "\n",
+    "Companion notebook for the RDDAC [documentation](https://rddac.readthedocs.io). It is written to stand on its own: every step is annotated so the notebook reads top to bottom.\n",
+    "\n",
+    "## Walkthrough\n",
+    "\n",
+    "1. the `rddac download --extract --remove-zip` workflow that leaves loose `.h5` files on disk,\n",
+    "2. simulate it here by extracting three members of `sample.zip` into a throwaway directory,\n",
+    "3. inspect the loose layout,\n",
+    "4. read `process_parameters.csv` with pandas and filter the rows of interest,\n",
+    "5. open each loose `.h5` directly with `h5py`,\n",
+    "6. stream the loose layout with `rddac.streaming.iter_view` (this works — unlike the zip-only manifest path).\n",
+    "\n",
+    "## Assumptions\n",
+    "\n",
+    "- This notebook writes a throwaway copy into the system temp directory; the project-local `../data` stays untouched.\n",
+    "- `rddac.open_h5` and `RDDACDataset` walk the **zips** referenced by the manifest. Once `--remove-zip` deletes them, those two are gone for the extracted experiments — but `rddac.streaming.iter_view` recognises loose files natively (a deliberate difference from `ddacs`), so the view machinery keeps working."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "15a888aa",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-06T12:50:54.717372Z",
+     "iopub.status.busy": "2026-07-06T12:50:54.717230Z",
+     "iopub.status.idle": "2026-07-06T12:50:56.471033Z",
+     "shell.execute_reply": "2026-07-06T12:50:56.470389Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "rddac 0.1.0\n",
+      "loose layout goes to: /tmp/rddac_loose_w6y5flzl\n"
+     ]
+    }
+   ],
+   "source": [
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "import shutil\n",
+    "import tempfile\n",
+    "import zipfile\n",
+    "from pathlib import Path\n",
+    "\n",
+    "import h5py\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "\n",
+    "import rddac\n",
+    "print('rddac', rddac.__version__)\n",
+    "\n",
+    "DATA_DIR  = Path('../data')\n",
+    "# DATA_DIR = Path('./data')   # uncomment instead when running from the repository root\n",
+    "assert (DATA_DIR / 'metadata.json').is_file(), f'{DATA_DIR} does not contain the dataset'\n",
+    "LOOSE_DIR = Path(tempfile.mkdtemp(prefix='rddac_loose_'))\n",
+    "print('loose layout goes to:', LOOSE_DIR)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "94651cc5",
+   "metadata": {},
+   "source": [
+    "## 1. Download with extract + remove\n",
+    "\n",
+    "`rddac download --extract --remove-zip` fetches the bundle, unzips each archive next to the zip, and deletes the zip on success. The result is a directory of loose `NNNN.h5` files instead of `.zip` archives. Run this once from a shell:\n",
+    "\n",
+    "```bash\n",
+    "rddac download --small --extract --remove-zip --out ./data -y\n",
+    "```\n",
+    "\n",
+    "The zip members sit at the archive root, so extraction leaves the `.h5` files directly beside `metadata.json` and `process_parameters.csv`. (`rddac.streaming` also recognises an `h5/` subdirectory if you prefer to tidy them away.)\n",
+    "\n",
+    "The dataset is already on disk in this repository, so instead of re-downloading, the next cell **simulates** the workflow: it extracts three members of `sample.zip` into the throwaway directory and copies the two index files alongside — byte-for-byte the layout the CLI command produces."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "8eb7962d",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-06T12:50:56.473126Z",
+     "iopub.status.busy": "2026-07-06T12:50:56.472916Z",
+     "iopub.status.idle": "2026-07-06T12:50:56.511143Z",
+     "shell.execute_reply": "2026-07-06T12:50:56.510524Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "extracted ['0000.h5', '0500.h5', '1002.h5']\n"
+     ]
+    }
+   ],
+   "source": [
+    "members = ['0000.h5', '0500.h5', '1002.h5']\n",
+    "with zipfile.ZipFile(DATA_DIR / 'h5' / 'sample.zip') as zf:\n",
+    "    for name in members:\n",
+    "        zf.extract(name, LOOSE_DIR)\n",
+    "\n",
+    "shutil.copy(DATA_DIR / 'process_parameters.csv', LOOSE_DIR)\n",
+    "shutil.copy(DATA_DIR / 'metadata.json', LOOSE_DIR)\n",
+    "print('extracted', members)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2bd1d7f9",
+   "metadata": {},
+   "source": [
+    "## 2. Inspect the loose layout\n",
+    "\n",
+    "After extraction, `metadata.json` and `process_parameters.csv` sit at the root next to the loose experiment files."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "dc1a4129",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-06T12:50:56.512984Z",
+     "iopub.status.busy": "2026-07-06T12:50:56.512881Z",
+     "iopub.status.idle": "2026-07-06T12:50:56.515733Z",
+     "shell.execute_reply": "2026-07-06T12:50:56.515155Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  0000.h5                          10.0 MB\n",
+      "  0500.h5                          10.0 MB\n",
+      "  1002.h5                          10.0 MB\n",
+      "  metadata.json                     0.0 MB\n",
+      "  process_parameters.csv            0.4 MB\n"
+     ]
+    }
+   ],
+   "source": [
+    "for entry in sorted(LOOSE_DIR.iterdir()):\n",
+    "    size_mb = entry.stat().st_size / 1e6\n",
+    "    print(f'  {entry.name:28s} {size_mb:8.1f} MB')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9951a844",
+   "metadata": {},
+   "source": [
+    "## 3. Read `process_parameters.csv` with pandas\n",
+    "\n",
+    "The CSV is the experiment index: one row per experiment id, with every process parameter exposed as a named column. Filter it in pandas before touching any HDF5 file."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "2eb84796",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-06T12:50:56.517430Z",
+     "iopub.status.busy": "2026-07-06T12:50:56.517334Z",
+     "iopub.status.idle": "2026-07-06T12:50:56.529868Z",
+     "shell.execute_reply": "2026-07-06T12:50:56.529240Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "rows: 9000, columns: ['index', 'experiment_id', 'category', 'geometry', 'blankholder_force', 'mean_punch_temp', 'oil_type', 'has_pointcloud', 'has_oil', 'split']\n",
+      "\n",
+      "   index  experiment_id  category geometry  blankholder_force  mean_punch_temp oil_type  has_pointcloud  has_oil  split\n",
+      "0      0              1         0  concave                100             20.2   coarse            True     True    val\n",
+      "1      1              2         0  concave                100             20.3   coarse            True     True  train\n",
+      "2      2              3         0  concave                100             20.4   coarse            True     True    val\n"
+     ]
+    }
+   ],
+   "source": [
+    "params = pd.read_csv(LOOSE_DIR / 'process_parameters.csv')\n",
+    "print(f'rows: {len(params)}, columns: {list(params.columns)}')\n",
+    "print()\n",
+    "print(params.head(3).to_string())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "637767a7",
+   "metadata": {},
+   "source": [
+    "## 4. Iterate the loose files with `h5py`\n",
+    "\n",
+    "Walk the (filtered) rows, build the zero-padded path, skip experiments whose `.h5` is missing locally, and open each one with `h5py.File`. Below: take the concave subset, then read the sheet-thickness traverse from every loose file that landed on disk. The raw traverse contains negative sensor-error spikes, so the summary masks `value <= 0` first (see the visualization notebook). With three extracted files the loop yields three lines."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "040f1a48",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-06T12:50:56.531678Z",
+     "iopub.status.busy": "2026-07-06T12:50:56.531577Z",
+     "iopub.status.idle": "2026-07-06T12:50:56.698366Z",
+     "shell.execute_reply": "2026-07-06T12:50:56.697749Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "concave experiments in CSV:  4500 of 9000\n",
+      "  experiment    0  oil_type=coarse  sheet thickness   985.9 -  1000.4 um  (206 valid samples)\n",
+      "  experiment  500  oil_type=fine    sheet thickness   950.1 -   988.7 um  (206 valid samples)\n",
+      "  experiment 1002  oil_type=medium  sheet thickness   983.2 -   998.4 um  (206 valid samples)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "opened 3 loose h5 file(s)\n"
+     ]
+    }
+   ],
+   "source": [
+    "concave = params.query(\"geometry == 'concave'\")\n",
+    "print(f'concave experiments in CSV: {len(concave):>5d} of {len(params)}')\n",
+    "\n",
+    "found = 0\n",
+    "for _, row in concave.iterrows():\n",
+    "    h5_path = LOOSE_DIR / f\"{row['index']:04d}.h5\"\n",
+    "    if not h5_path.is_file():\n",
+    "        continue\n",
+    "    with h5py.File(h5_path, 'r') as f:\n",
+    "        thickness = f['sheet_thickness/data'][:]\n",
+    "    valid = thickness[thickness[:, 1] > 0, 1]\n",
+    "    print(f\"  experiment {row['index']:>4d}  oil_type={row['oil_type']:<7s} \"\n",
+    "          f\"sheet thickness {valid.min():7.1f} - {valid.max():7.1f} um  ({len(valid)} valid samples)\")\n",
+    "    found += 1\n",
+    "print(f'\\nopened {found} loose h5 file(s)')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c86a5447",
+   "metadata": {},
+   "source": [
+    "## 5. Stream the loose layout with `iter_view`\n",
+    "\n",
+    "`rddac.streaming.iter_view` builds a unified index at startup that recognises **both** loose `NNNN.h5` files (at the data-dir root or under `h5/`) and zipped archives — preferring loose files when both exist, because direct `h5py` reads skip the per-record `BytesIO` round trip. Pointing `data_dir` at the loose directory is therefore all it takes; views, slicing, `where=` filters, and the numpy export from the streaming notebook keep working unchanged.\n",
+    "\n",
+    "The zip-backed single-file helper does *not* survive the transition: `rddac.open_h5` walks the manifest-mapped zips only, so on this directory it raises `FileNotFoundError` — reach for `h5py.File(path)` directly instead (step 4), the file name is just the zero-padded experiment id."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "d8443bbf",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-06T12:50:56.700220Z",
+     "iopub.status.busy": "2026-07-06T12:50:56.700118Z",
+     "iopub.status.idle": "2026-07-06T12:50:56.947223Z",
+     "shell.execute_reply": "2026-07-06T12:50:56.946651Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  experiment    0: force_data shape=(1140, 8)\n",
+      "  experiment  500: force_data shape=(1140, 8)\n",
+      "  experiment 1002: force_data shape=(1140, 8)\n",
+      "\n",
+      "open_h5 on the loose layout: FileNotFoundError: 0000.h5 not found in any locally mapped zip under PosixPath('/tmp/rddac_loose_w6...\n"
+     ]
+    }
+   ],
+   "source": [
+    "for rec in rddac.streaming.iter_view('force-curve', data_dir=LOOSE_DIR):\n",
+    "    print(f\"  experiment {rec['_sim_id']:>4d}: force_data shape={rec['force_data'].shape}\")\n",
+    "\n",
+    "try:\n",
+    "    rddac.open_h5(0, data_dir=LOOSE_DIR)\n",
+    "except FileNotFoundError as e:\n",
+    "    print(f'\\nopen_h5 on the loose layout: FileNotFoundError: {str(e)[:80]}...')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bc5a3c38",
+   "metadata": {},
+   "source": [
+    "## 6. Clean up\n",
+    "\n",
+    "The loose copy was a demonstration artifact; remove it so repeated runs start fresh."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "5a1801f1",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-07-06T12:50:56.949016Z",
+     "iopub.status.busy": "2026-07-06T12:50:56.948915Z",
+     "iopub.status.idle": "2026-07-06T12:50:56.955859Z",
+     "shell.execute_reply": "2026-07-06T12:50:56.955169Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "removed /tmp/rddac_loose_w6y5flzl\n"
+     ]
+    }
+   ],
+   "source": [
+    "shutil.rmtree(LOOSE_DIR)\n",
+    "print('removed', LOOSE_DIR)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

notebooks/README.md

@@ -0,0 +1,42 @@
+# RDDAC notebooks
+
+Six end-to-end Jupyter notebooks that companion the [online documentation](https://rddac.readthedocs.io). Each notebook is self-contained: it opens with a Walkthrough list and the Assumptions it relies on, then walks through the topic step by step. Reading top to bottom is the intended flow.
+
+RDDAC is the experimental counterpart to the [DDACS](https://ddacs.readthedocs.io) simulation dataset, and the `rddac` package mirrors the `ddacs` API 1:1 — these notebooks mirror the DDACS notebook series the same way.
+
+## Prerequisites
+
+```bash
+# Install the package + the PyTorch extra (needed for 03_pytorch.ipynb).
+pip install 'rddac[torch]'
+
+# Fetch the small sample bundle once. Writes metadata.json,
+# process_parameters.csv, and one sample zip with 18 experiments
+# (one per category) into ./data.
+rddac download --small -y
+```
+
+The full release (`rddac download`, ~87 GB) additionally fetches the matching DDACS simulations into `./data/simulation/`; the notebooks only need the small bundle. Notebooks 05 and 06 write throwaway artifacts into the system temp directory and clean up after themselves, so the data directory stays untouched.
+
+## Run
+
+From the repository root:
+
+```bash
+jupyter lab notebooks/
+```
+
+Inside each notebook the data directory is hard-coded as `DATA_DIR = '../data'` because the notebooks live in `notebooks/` while the data sits at the repo root (adjust to `'../data'` if you downloaded with the default `rddac download` output directory).
+
+## Index
+
+| Notebook | What it covers |
+|----------|----------------|
+| [`01_getting_started.ipynb`](01_getting_started.ipynb) | Install, download, `rddac.load`, iterate one record of the experiment index, open one HDF5 file with `rddac.open_h5` + `inspect_h5`, render the OP10 laser scan as a height image. |
+| [`02_views.ipynb`](02_views.ipynb) | The `field-map` lookup table, appending a custom `RecordSet` with `rddac.add_view` (whole fields, index slicing, `process-parameters` CSV columns), inspecting the resolved transforms, streaming with `rddac.streaming.iter_view`. |
+| [`03_pytorch.ipynb`](03_pytorch.ipynb) | Build an `RDDACDataset`, stream ragged records at `batch_size=1`, batch properly via a fixed-shape custom view + `dataset=`, filter by manifest columns and `sim_ids`, canonical train/val/test splits, shuffle with `set_epoch`, the metadata-column limitation and its workarounds, and a minimal training-loop skeleton. |
+| [`04_visualization.ipynb`](04_visualization.ipynb) | OP10 vs OP20 height scans with `plot_scan`, the luminescence channel, `scan_to_pointcloud` + `plot_point_cloud`, press signals with `plot_force`, and the sheet-thickness / oil-film traverses with `plot_traverse` (including masking the raw sensor spikes). |
+| [`05_loose_h5.ipynb`](05_loose_h5.ipynb) | The post-`--extract --remove-zip` workflow: inspect the loose layout, filter `process_parameters.csv` with pandas, open loose `.h5` files directly with `h5py`, and stream the loose layout with `rddac.streaming.iter_view`. |
+| [`06_streaming.ipynb`](06_streaming.ipynb) | `rddac.streaming.iter_view` in depth (`where=`, `sim_ids=`, `dataset=`), `export_to_numpy` with `transforms` + `record_transform` on a fixed-shape scan-profile view, `load_export` + `by_sim_id`, back-to-back timing of the streaming vs memmap paths, and `export_to_numpy_per_sim` for ragged fields. |
+
+If any of these fail to run end to end after `rddac download --small`, please open an [issue](https://github.com/BaumSebastian/RDDAC/issues) so we can fix the discrepancy with the docs.

rddac_documentation.pdf

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