Real Deep Drawing and Cutting (RDDAC) Dataset

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 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 · 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

• Installation
• Download the dataset
• Preprocess the dataset
• Basic usage
• PyTorch integration
• Tutorials
• Version compatibility
• Citation
• Development
• License

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: each package line defaults to the matching dataset version. The dataset versions share the same file layout, so every view and the preprocessing work on either, and earlier versions stay reachable via rddac download <version>. Pin the package major to the dataset line you target, and see the changelog for what changed in each release.

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).