rddac 1.0.0__tar.gz

rddac-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Sebastian Baum
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rddac-1.0.0/PKG-INFO

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: rddac
+Version: 1.0.0
+Summary: Python package for the Real Deep Drawing and Cutting (RDDAC) Dataset
+Author: Sebastian Baum, Pascal Heinzelmann
+License: MIT
+Project-URL: Homepage, https://github.com/BaumSebastian/RDDAC
+Project-URL: Documentation, https://rddac.readthedocs.io
+Project-URL: Repository, https://github.com/BaumSebastian/RDDAC
+Keywords: deep-drawing,sheet-metal,forming,dataset,experimental,measurement
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: h5py>=3.8.0
+Requires-Dist: matplotlib>=3.7.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: humanfriendly>=10.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: mlcroissant>=1.1.0
+Requires-Dist: ddacs<4,>=3.2.1
+Provides-Extra: torch
+Requires-Dist: torch>=2.0; extra == "torch"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=24.0.0; extra == "dev"
+Requires-Dist: ruff>=0.3.0; extra == "dev"
+Requires-Dist: bumpver>=2023.1129; extra == "dev"
+Requires-Dist: pre-commit>=3.6.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.5.0; extra == "docs"
+Requires-Dist: mkdocs-material>=9.5.0; extra == "docs"
+Requires-Dist: mkdocstrings[python]>=0.24.0; extra == "docs"
+Requires-Dist: mkdocs-macros-plugin>=1.0.0; extra == "docs"
+Dynamic: license-file
+
+<div align="center">
+  <img src="https://raw.githubusercontent.com/BaumSebastian/RDDAC/main/docs/images/icon/icon.png" width="150"/>
+  <h1>Real Deep Drawing and Cutting (RDDAC) Dataset</h1>
+</div>
+
+[![Code License: MIT](https://img.shields.io/badge/Code-MIT-yellow.svg)](LICENSE)
+[![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://readthedocs.org/projects/rddac/badge/?version=latest)](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)
+
+<div align="center">
+
+![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.*
+
+</div>
+
+**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)**
+
+The `rddac` package ships with the dataset and provides a Croissant native interface: one CLI for the download, one Python module for access, and an optional PyTorch `IterableDataset` for training.
+
+## Installation
+
+```bash
+pip install rddac
+```
+
+The PyTorch adapter is an optional extra. For hardware specific PyTorch builds (CUDA, ROCm, MPS), install PyTorch first from [pytorch.org](https://pytorch.org/get-started/locally/), then install the extra:
+
+```bash
+pip install 'rddac[torch]'
+```
+
+## Download the dataset
+
+```bash
+# 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
+```
+
+## Basic usage
+
+```python
+import rddac
+
+with rddac.open_h5(0) as f:                    # one experiment by id
+    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 public surface mirrors the [`ddacs`](https://ddacs.readthedocs.io) package one to one — `load`, `add_view`, `open_h5`, `inspect_h5`, `streaming.iter_view` / `export_to_numpy` / `load_export`, and the PyTorch `IterableDataset` share names, signatures, and semantics. Code written against DDACS ports by swapping the import:
+
+```python
+# import ddacs as dataset_pkg                  # simulations
+import rddac as dataset_pkg                    # real experiments
+
+ds = dataset_pkg.load(data_dir="./data")
+for record in dataset_pkg.streaming.iter_view("force-curve", data_dir="./data", dataset=ds):
+    ...
+```
+
+See the [documentation](https://rddac.readthedocs.io) for the dataset reference (parameter space, HDF5 structure, Croissant manifest) and step-by-step tutorials from a first plot to PyTorch training.
+
+## Citation
+
+```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
+
+The dataset on DaRUS is licensed under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). The `rddac` software is licensed under the MIT License — see [LICENSE](LICENSE).

rddac-1.0.0/README.md

@@ -0,0 +1,110 @@
+<div align="center">
+  <img src="https://raw.githubusercontent.com/BaumSebastian/RDDAC/main/docs/images/icon/icon.png" width="150"/>
+  <h1>Real Deep Drawing and Cutting (RDDAC) Dataset</h1>
+</div>
+
+[![Code License: MIT](https://img.shields.io/badge/Code-MIT-yellow.svg)](LICENSE)
+[![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://readthedocs.org/projects/rddac/badge/?version=latest)](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)
+
+<div align="center">
+
+![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.*
+
+</div>
+
+**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)**
+
+The `rddac` package ships with the dataset and provides a Croissant native interface: one CLI for the download, one Python module for access, and an optional PyTorch `IterableDataset` for training.
+
+## Installation
+
+```bash
+pip install rddac
+```
+
+The PyTorch adapter is an optional extra. For hardware specific PyTorch builds (CUDA, ROCm, MPS), install PyTorch first from [pytorch.org](https://pytorch.org/get-started/locally/), then install the extra:
+
+```bash
+pip install 'rddac[torch]'
+```
+
+## Download the dataset
+
+```bash
+# 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
+```
+
+## Basic usage
+
+```python
+import rddac
+
+with rddac.open_h5(0) as f:                    # one experiment by id
+    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 public surface mirrors the [`ddacs`](https://ddacs.readthedocs.io) package one to one — `load`, `add_view`, `open_h5`, `inspect_h5`, `streaming.iter_view` / `export_to_numpy` / `load_export`, and the PyTorch `IterableDataset` share names, signatures, and semantics. Code written against DDACS ports by swapping the import:
+
+```python
+# import ddacs as dataset_pkg                  # simulations
+import rddac as dataset_pkg                    # real experiments
+
+ds = dataset_pkg.load(data_dir="./data")
+for record in dataset_pkg.streaming.iter_view("force-curve", data_dir="./data", dataset=ds):
+    ...
+```
+
+See the [documentation](https://rddac.readthedocs.io) for the dataset reference (parameter space, HDF5 structure, Croissant manifest) and step-by-step tutorials from a first plot to PyTorch training.
+
+## Citation
+
+```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
+
+The dataset on DaRUS is licensed under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). The `rddac` software is licensed under the MIT License — see [LICENSE](LICENSE).

rddac-1.0.0/pyproject.toml

@@ -0,0 +1,98 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rddac"
+version = "1.0.0"
+description = "Python package for the Real Deep Drawing and Cutting (RDDAC) Dataset"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+authors = [
+    {name = "Sebastian Baum"},
+    {name = "Pascal Heinzelmann"},
+]
+keywords = ["deep-drawing", "sheet-metal", "forming", "dataset", "experimental", "measurement"]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering",
+]
+dependencies = [
+    "numpy>=1.24.0",
+    "pandas>=2.0.0",
+    "h5py>=3.8.0",
+    "matplotlib>=3.7.0",
+    # CLI dependencies
+    "requests>=2.28.0",
+    "humanfriendly>=10.0",
+    "rich>=13.0.0",
+    # Croissant manifest access
+    "mlcroissant>=1.1.0",
+    # Shared dataset machinery (DatasetSpec, streaming, h5 access, spec-aware
+    # CLI) + the matching FEM simulations. <4: major bumps may remove API.
+    "ddacs>=3.2.1,<4",
+]
+
+[project.optional-dependencies]
+torch = ["torch>=2.0"]
+dev = [
+    "pytest>=7.0.0",
+    "black>=24.0.0",
+    "ruff>=0.3.0",
+    "bumpver>=2023.1129",
+    "pre-commit>=3.6.0",
+]
+docs = [
+    "mkdocs>=1.5.0",
+    "mkdocs-material>=9.5.0",
+    "mkdocstrings[python]>=0.24.0",
+    "mkdocs-macros-plugin>=1.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/BaumSebastian/RDDAC"
+Documentation = "https://rddac.readthedocs.io"
+Repository = "https://github.com/BaumSebastian/RDDAC"
+
+[project.scripts]
+rddac = "rddac.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["rddac*"]
+
+[tool.black]
+line-length = 120
+target-version = ["py310", "py311", "py312"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W"]
+ignore = ["E501"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]
+
+[tool.bumpver]
+current_version = "1.0.0"
+version_pattern = "MAJOR.MINOR.PATCH"
+commit_message = "Bump version {old_version} -> {new_version}"
+commit = true
+tag = true
+push = false
+
+[tool.bumpver.file_patterns]
+"pyproject.toml" = ['version = "{version}"']
+"rddac/__init__.py" = ['__version__ = "{version}"']

rddac-1.0.0/rddac/__init__.py

@@ -0,0 +1,66 @@
+"""RDDAC — Real Deep Drawing and Cutting Dataset.
+
+Python interface for the RDDAC dataset (experimental measurements of sheet
+metal forming; the physical counterpart to the DDACS simulations). Built on a
+Croissant 1.1 manifest: `rddac.load()` returns an `mlcroissant.Dataset` whose
+`records(view)` streams the data; `add_view`, `open_h5`, `inspect_h5` are
+convenience helpers around the same manifest.
+
+The public surface mirrors the `ddacs` package, so DDACS code ports by
+swapping the import.
+
+Examples:
+    >>> import rddac
+    >>> ds = rddac.load(data_dir="./data")
+    >>> for record in rddac.streaming.iter_view("force-curve", data_dir="./data"):
+    ...     ...
+
+    >>> with rddac.open_h5(42, data_dir="./data") as f:
+    ...     rddac.inspect_h5(f)
+
+Note: prefer ``rddac.streaming.iter_view`` (or ``RDDACDataset``) over
+``ds.records(view)`` for the h5-backed views — mlcroissant's own records()
+walks the full multi-GB zips per view and is impractically slow there.
+"""
+
+__version__ = "1.0.0"
+
+from . import streaming
+from .croissant import add_view, load
+from .h5_tools import inspect_h5, open_h5
+from .spec import RDDAC_SPEC, DatasetSpec
+from .visualization import (
+    plot_force,
+    plot_point_cloud,
+    plot_scan,
+    plot_traverse,
+    scan_to_pointcloud,
+)
+
+try:
+    from .pytorch import RDDACDataset
+except ImportError:
+    pass
+
+__all__ = [
+    "__version__",
+    # Dataset identity (consumed by the ddacs machinery via spec=)
+    "RDDAC_SPEC",
+    "DatasetSpec",
+    # Croissant entry point + helpers
+    "load",
+    "add_view",
+    # HDF5 helpers
+    "open_h5",
+    "inspect_h5",
+    # Streaming pipeline (offline iteration + numpy export)
+    "streaming",
+    # PyTorch (optional — only available if torch is installed)
+    "RDDACDataset",
+    # Visualization
+    "plot_scan",
+    "plot_point_cloud",
+    "plot_force",
+    "plot_traverse",
+    "scan_to_pointcloud",
+]

rddac-1.0.0/rddac/cli.py

@@ -0,0 +1,166 @@
+"""RDDAC dataset CLI — a thin front-end over the ``ddacs`` CLI machinery.
+
+Provides commands to view dataset information and download files from the RDDAC
+(Real Deep Drawing and Cutting) dataset hosted on DaRUS. Because RDDAC is the
+experimental counterpart to DDACS, the full download also fetches the matching
+DDACS simulations (skip with --no-sim).
+
+The info/download implementation is `ddacs.cli`'s, called with
+``spec=RDDAC_SPEC`` (requires ddacs >= 3.2.1). Only the parser (prog,
+--no-sim) and the simulation leg live here.
+
+Usage:
+    rddac info                         # Show dataset info and versions
+    rddac download                     # Real measurements + DDACS simulations
+    rddac download --no-sim            # Real measurements only (skip simulations)
+    rddac download --small             # Small sample bundle (quick start)
+    rddac download --files a.zip       # Download specific files
+    rddac download --extract           # Also extract zips next to the zip
+    rddac download --extract --remove-zip
+    rddac download --quiet             # No output/progress; implies --yes
+
+Zip files are kept by default so they remain readable in place via mlcroissant
+(the Croissant manifest references zip members directly).
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import os
+import subprocess
+import sys
+
+from ddacs import cli as _ddacs_cli
+from ddacs.cli import _dataset_title  # noqa: F401  — identical helper, re-exported for tests
+from rich.panel import Panel
+
+from . import __version__
+from .spec import (
+    DDACS_DATASET_DOI,
+    DDACS_SIM_FILE,
+    RDDAC_SPEC,
+    SIM_SUBDIR,
+)
+
+DEFAULT_VERSION = RDDAC_SPEC.default_version
+DEFAULT_DATA_DIR = RDDAC_SPEC.default_data_dir
+SMALL_TEST_FILES = list(RDDAC_SPEC.small_test_files)
+
+console = _ddacs_cli.console  # shared console: ddacs's --quiet handling applies
+
+
+# ── small helpers kept for tests / tooling (dataset-agnostic) ─────────────────
+def _file_info(file_meta: dict) -> tuple[str, int]:
+    """Original filename + size from a DaRUS file metadata entry."""
+    df = file_meta["dataFile"]
+    if "originalFileName" in df:
+        return df["originalFileName"], df.get("originalFileSize", df["filesize"])
+    return df["filename"], df["filesize"]
+
+
+def _matches(file_meta: dict, names: list[str]) -> bool:
+    return _file_info(file_meta)[0] in names or file_meta["dataFile"]["filename"] in names
+
+
+# ── commands ──────────────────────────────────────────────────────────────────
+def cmd_info(args: argparse.Namespace) -> None:
+    """Display dataset information and available versions (via ddacs.cli)."""
+    _ddacs_cli.cmd_info(args, spec=RDDAC_SPEC)
+
+
+def cmd_download(args: argparse.Namespace) -> None:
+    """Download RDDAC measurements (and, by default, the DDACS simulations)."""
+    _ddacs_cli.cmd_download(args, spec=RDDAC_SPEC)
+
+    # The DDACS simulations come along only on a full download (not --small /
+    # --files), unless explicitly skipped.
+    if not args.small and not args.files and not args.no_sim:
+        _download_simulations(args)
+
+
+def _download_simulations(args: argparse.Namespace) -> int:
+    """Fetch the matching DDACS simulations by delegating to the `ddacs` CLI.
+
+    The download machinery is not duplicated here: if the `ddacs` package is
+    installed, its own CLI downloads `rddac.zip` into ``<out>/simulation``;
+    otherwise the user gets the exact command to run after installing it.
+
+    Returns the number of files fetched (0 when skipped or delegated-and-failed).
+    """
+    sim_dir = os.path.join(args.out, SIM_SUBDIR)
+    console.print()
+    console.print(Panel(
+        f"[bold]Source:[/bold] DDACS {DDACS_DATASET_DOI}\n[bold]File:[/bold] {DDACS_SIM_FILE}\n"
+        f"[bold]Destination:[/bold] {os.path.abspath(sim_dir)}\n"
+        "[dim]The matching FEM simulations. Skip with --no-sim.[/dim]",
+        title="DDACS simulation reference data", border_style="cyan"))
+
+    if importlib.util.find_spec("ddacs") is None:
+        console.print(
+            "[yellow]The `ddacs` package is not installed — skipping the simulations.[/yellow]\n"
+            "To fetch them later:\n"
+            "  [bold]pip install ddacs[/bold]\n"
+            f"  [bold]ddacs download --files {DDACS_SIM_FILE} metadata.json process_parameters.csv --out {sim_dir} -y[/bold]"
+        )
+        return 0
+
+    # Also fetch DDACS's manifest + parameter table so <out>/simulation is a
+    # self-contained DDACS data dir: ddacs.load(data_dir="<out>/simulation")
+    # resolves the DDACS manifest locally and cannot pick up RDDAC's
+    # metadata.json from the parent directory.
+    cmd = [sys.executable, "-m", "ddacs.cli", "download",
+           "--files", DDACS_SIM_FILE, "metadata.json", "process_parameters.csv",
+           "--out", sim_dir]
+    if args.yes:
+        cmd.append("-y")
+    if getattr(args, "quiet", False):
+        cmd.append("--quiet")
+    if args.extract:
+        cmd.append("--extract")
+    if args.remove_zip:
+        cmd.append("--remove-zip")
+    console.print(f"[dim]delegating to: {' '.join(cmd[2:])}[/dim]")
+    result = subprocess.run(cmd)
+    if result.returncode != 0:
+        console.print("[red]ddacs download failed.[/red]")
+        return 0
+    return 1
+
+
+def main() -> None:
+    """CLI entry point for RDDAC dataset commands."""
+    parser = argparse.ArgumentParser(
+        prog="rddac", description="RDDAC Dataset CLI - Download experimental data from DaRUS")
+    parser.add_argument("-V", "--version", action="version", version=f"%(prog)s {__version__}")
+    parser.add_argument("--token", help="DaRUS API token (for draft access)")
+    sub = parser.add_subparsers(dest="command", help="Command")
+
+    sub.add_parser("info", help="Show dataset info and versions")
+
+    dl = sub.add_parser("download", help="Download dataset files")
+    dl.add_argument("version", nargs="?", default=DEFAULT_VERSION,
+                    help=f"Dataset version (default: {DEFAULT_VERSION})")
+    dl.add_argument("--files", nargs="+", help="Specific filenames to download")
+    dl.add_argument("--small", action="store_true", help="Download the small sample bundle")
+    dl.add_argument("--no-sim", action="store_true",
+                    help="Download only the real measurements (skip the DDACS simulations)")
+    dl.add_argument("--out", default=DEFAULT_DATA_DIR,
+                    help=f"Output directory (default: {DEFAULT_DATA_DIR})")
+    dl.add_argument("-y", "--yes", action="store_true", help="Skip confirmation prompt")
+    dl.add_argument("-q", "--quiet", action="store_true",
+                    help="No output or progress bars; implies --yes")
+    dl.add_argument("--extract", action="store_true", help="Extract downloaded zips into their directory")
+    dl.add_argument("--remove-zip", action="store_true", help="Delete zips after extraction (with --extract)")
+
+    args = parser.parse_args()
+    if args.command == "info":
+        cmd_info(args)
+    elif args.command == "download":
+        cmd_download(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()