Real Deep Drawing and Cutting (RDDAC) Dataset

A large-scale experimental dataset of 9,000 physical deep-drawing and cutting experiments — the real-world counterpart to the DDACS 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.

Documentation · Dataset DOI · Paper

Try the ~174 MB teaser (18 experiments, manifest, parameter table, runnable tutorials): Kaggle · Hugging Face · Zenodo

A Croissant-native Python package for accessing the RDDAC Dataset ships with this repo: one CLI for the download and the reference preprocessing, one Python module for access, torch-free streaming and numpy export, plotting helpers, and an optional PyTorch IterableDataset for training. Its public surface mirrors the ddacs package one to one, so code written for the simulations ports by swapping the import.

Table of Contents

• What's new in 1.1
• Installation
• Download the dataset
• Preprocess the dataset
• Basic usage
• PyTorch integration
• Tutorials
• Version compatibility
• Citation
• Development
• License

What's new in 1.1

1.1 adds the reference preprocessing. The published files stay raw by design; rddac preprocess derives an ML-ready layer next to them:

• force, sheet, oil: fixed-shape, cleaned tables (forming-window force curves, error-masked thickness and dropout-free oil-film profiles).
• pointcloud: calibrated scans, cleaned of fins by a random-forest classifier, aligned to the matching DDACS simulation (needs the [preprocessing] extra and the simulations).
• Every parameter is adjustable via TOML and stamped into the output; the same Croissant views stream both layers.

See Preprocessing for what each stage does and the changelog for the details.

Installation

pip install rddac

The PyTorch adapter is an optional extra. For hardware-specific PyTorch builds (CUDA, ROCm, MPS), install PyTorch first from pytorch.org, then install the extra:

pip install 'rddac[torch]'

The pointcloud stage of rddac preprocess needs scipy and scikit-learn:

pip install 'rddac[preprocessing]'

Download the dataset

# Small sample bundle (~174 MB): manifest, CSV, and one experiment per category.
rddac download --small -y

# Full release (~87 GB), including the matching DDACS simulations (~9 GB).
rddac download

# Real measurements only (skip the simulations).
rddac download --no-sim

# Show available versions on DaRUS.
rddac info

Files land in ./data by default. The same path is the default for rddac.load(data_dir=...), rddac preprocess --data-dir and RDDACDataset(data_dir=...), so no further configuration is needed.

All options (--files, --out, --extract, --remove-zip, --quiet, the global --token) are documented in the CLI reference.

By default zip files are kept on disk and are not extracted; mlcroissant reads HDF5 members in place. Pass --extract --remove-zip to switch to a loose-HDF5 layout instead; see the Loose HDF5 recipe.

Preprocess the dataset

rddac preprocess                   # all modalities (pointcloud needs the simulations)
rddac preprocess oil force sheet   # a subset, e.g. on the small bundle

Output lands in ./data/processed, raw files are never modified, and re-runs only fill in what is missing. All options (--ids, --split, --workers, --overwrite, --config) are documented in the CLI reference; what each stage does and how to replace one with your own algorithm is in the preprocessing documentation.

Basic usage

rddac.load parses the Croissant manifest; rddac.open_h5 opens a single experiment in memory and returns an h5py.File.

import rddac

# Load the dataset manifest. Lists every published RecordSet.
ds = rddac.load(data_dir="./data")
print([rs.id for rs in ds.metadata.record_sets])

# Open one experiment by id.
with rddac.open_h5(0, data_dir="./data") as f:
    force = f["force/data"][:]                 # (n, 8): time, load cells, temp, position, total force
    sheet = f["sheet_thickness/data"][:]       # (n, 2): sensor position, thickness
    z10 = f["pointcloud/op10/z"][:]            # (6400000,) flat scan buffer

The same views stream the processed layer: pass data_dir="./data/processed" and source="./data/metadata.json" to rddac.streaming.iter_view. For custom RecordSets see Build your own view; for scans, point clouds, force curves and traverses see Visualization.

PyTorch integration

RDDACDataset is a torch.utils.data.IterableDataset over a Croissant view. It builds an id -> local zip index at construction time and silently skips experiments whose zip is missing, so partial downloads stream fine. Raw tables vary in length per experiment, so batch the processed layer, where every record has a fixed shape:

from rddac.pytorch import RDDACDataset
from torch.utils.data import DataLoader

ds = RDDACDataset(view="force-curve", data_dir="./data/processed", source="./data/metadata.json")
loader = DataLoader(ds, batch_size=16, num_workers=0)

for batch in loader:
    force = batch["force_data"]                # (16, 600, 8) after `rddac preprocess force`
    # ... training step ...
    break

For filtering, train / val / test splits, shuffling, and the partial-download story, see PyTorch training.

Tutorials

The tutorials walk through the package end to end. Each one is published on Read the Docs as a tutorial page and shipped as an executable notebook under notebooks/. See notebooks/README.md for prerequisites and run instructions.

Version compatibility

The rddac package major version tracks the DaRUS dataset major version. The pairing is enforced by the Croissant manifest bundled with each release: a mismatched package version will fail to resolve the field map.

Pin the package major to the dataset major you target, for example pip install 'rddac~=1.0' to stay on the v1 line.

Citation

@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}
}

Development

git clone https://github.com/BaumSebastian/RDDAC.git
cd RDDAC
pip install -e ".[dev,torch]"
pre-commit install   # set up code formatting hooks
pytest               # run the full test suite (PyTorch tests skip without the torch extra)

License

The dataset on DaRUS is licensed under CC BY 4.0. The rddac software is licensed under the MIT License, see LICENSE.

Data files bundled with the package are not MIT: the fin labels (rddac/_preprocess/labels/, human annotations of the dataset), the scanner calibration (calibration.json) and the simulation parameter table (sim_params.csv) are data derived from RDDAC/DDACS and are licensed CC BY 4.0 like the dataset (see rddac/_preprocess/labels/LICENSE).