README.md

---
license: cc-by-4.0
pretty_name: Wave1D-Propagation (StructBench)
tags:
- structural-engineering
- physics
- simulation
- lsdyna
- sph
- benchmark
size_categories:
- n<1K
configs:
- config_name: manifest
  data_files:
  - split: cases
    path: cases.csv
---
# Wave1D-Propagation — StructBench canonical dataset

## Download

One case, one file — fetch exactly what you need (`pip install huggingface_hub`):

```python
from huggingface_hub import hf_hub_download, snapshot_download

# one case
path = hf_hub_download("StructBench/wave-propagation-1d",
                       filename="<case_id>.h5", repo_type="dataset")

# the full archive (resumable; cached under HF_HOME)
root = snapshot_download("StructBench/wave-propagation-1d", repo_type="dataset")
```

`cases.csv` lists every case with its split and loading/geometry
parameters plus a SHA-256 manifest; pin the dataset repo's `v0.1.0`
tag (`revision="v0.1.0"` — a data release, independent of the code
version) for reproducible pipelines. Point
`structbench-train --data-root` at the snapshot directory.
Code, benchmark protocol, and leaderboards:
<https://github.com/qilinli/StructBench>.

Autoregressive next-step surrogate of an elastic stress wave in a 2D SPH bar strip under initial-velocity excitation (ADR-0025). Entry tier: onboarding, tutorial, and fast CI.

## Dataset summary

- Solver: LS-DYNA (SPH; erosion: no)
- Loading: initial velocity 1-8 m/s; elastic wave propagation; wave speed ~70.7 m/s (4-11 traversals per trajectory, by bar length)
- Geometry: 2D strip, 5 particle rows, {200, 300, 400, 500} mm x 8 mm
- Materials: *MAT_ELASTIC (scaled toy constants: E=0.01 GPa, rho=2e-6 kg/mm3)
- Source units: kg-mm-ms (files are strict SI, ADR-0012)
- Cases: 16 (train 12, val 2, test_interp 2)
- Particles per case: 500-1250; 302 frames at 0.1 ms; 0.23 GB on disk
- Fields: node/displacement, node/velocity, node/acceleration, sph/stress, sph/strain, sph/strain_rate, sph/effective_plastic_strain, sph/pressure, sph/density, sph/internal_energy, sph/mass, sph/radius, sph/n_neighbors, sph/deletion, global/kinetic_energy, global/internal_energy, global/total_energy
- Provenance: LS-DYNA parametric sweep (4 bar lengths x 4 initial velocities) produced by Curtin collaborators; benchmark protocol per ADR-0025.
- License: CC BY 4.0

## Files

- `<case_id>.h5` — one HDF5 file per case; the file name is the case id (layout below).
- `card.json` — machine-readable card metadata (ADR-0027): the facts above plus the split sizes.
- `README.md` — this file; `LICENSE-*.txt` — the data licence (CC BY 4.0).

## Manifest and input decks (Hugging Face mirror)

- `cases.csv` — one row per `.h5`: `case_id`, `split` (`held_aside` for files shipped outside the protocol splits), the loading/geometry parameters parsed from the id, `n_nodes` (rows of `nodes/coords`, so including any boundary-shell nodes), `n_frames` (stored frames), `file_bytes`, `sha256` (integrity manifest; also what the Dataset Viewer shows).
- `decks/<case_id>.k` — the LS-DYNA input deck of every case (also embedded verbatim in each file's `metadata/source_deck`); re-running a deck regenerates the raw output the adapter converts to canonical HDF5.
- Case ids: `W1D-<L>-<V>` — bar length L mm, initial speed V m/s.

## HDF5 layout

One HDF5 file per case, readable with `h5py` or any HDF5 tool. Every quantity is stored in strict SI (m, s, kg, Pa, J) regardless of the solver's `kg-mm-ms` source convention. Small scalars are HDF5 attributes; arrays are datasets (float64 geometry and time, float32 response, int64 ids, variable-length UTF-8 strings — h5py returns those as `bytes`); response arrays are gzip-compressed and chunked in blocks of frames, so slicing along the frame axis reads only the chunks it touches. Shapes below use N nodes, P SPH particles, E elements, T stored frames and d = `metadata.dimension`; the exact schema version is the `schema_version` attribute (ADR-0013 — 0.2.0 readers read 0.1.0 files unchanged, ADR-0042). `ADR-NNNN` refers to the decision records under `decisions/` in the code repository.

| Path | Shape | Dtype | Content |
|---|---|---|---|
| `metadata` (attrs) | — | — | `case_id`, `dataset_id`, `dimension`, `schema_version`, `source_units`, `units_convention` (= `SI`) |
| `metadata/provenance` (attrs) | — | — | `solver_name`, `solver_version`, `generation_date` |
| `metadata/source_deck` | scalar | str | the complete solver input deck, verbatim (solver-ingested cases) |
| `nodes/coords` | (N, d) | f64 | initial node coordinates [m] |
| `nodes/node_id` | (N,) | i64 | solver node ids |
| `materials/{canonical_model, source_model, source_params, material_id}` | (M,) | str / i64 | material models; `source_params` is the solver's material card as JSON; `canonical_model` is empty when the source model has no canonical mapping |
| `response/time/t` | (T,) | f64 | the solver's actual output times [s], nominally every 0.1 ms; frame 0 is the initial state; the last stored frame is a terminal solver-output artifact that the loader drops (ADR-0028) |
| `elements/sph/connectivity` | (P, 1) | i64 | particle → node index (0-based) |
| `elements/sph/{element_id, part_id}` | (P,) | i64 | solver element id, part id |
| `elements/<other>/…` | (E, n), (E,) | i64 | any further element group (e.g. a single rigid-wall / boundary `shell`, whose nodes are counted in N but are not particles) follows the same connectivity, element_id, part_id pattern |
| `response/node/{displacement, velocity, acceleration}` | (T, N, d) | f32 | [m], [m/s], [m/s²] |
| `response/element/sph/{stress, strain, strain_rate}` | (T, P, 6) | f32 | Voigt (xx, yy, zz, xy, yz, zx): [Pa], [–], [1/s] — six components even for 2D cases |
| `response/element/sph/{pressure, density, mass, internal_energy}` | (T, P) | f32 | [Pa] (positive in compression, = −tr σ / 3), [kg/m³], [kg], [J] |
| `response/element/sph/effective_plastic_strain` | (T, P) | f32 | whatever the material model writes to LS-DYNA's plastic-strain history slot: equivalent plastic strain [–] for elastoplastic models, the K&C concrete model's scaled damage measure (0–2) for `*MAT_CONCRETE_DAMAGE_REL3`, and an unrelated history variable for purely elastic materials (treat as unused) |
| `response/element/sph/{radius, n_neighbors, deletion}` | (T, P) | f32 | smoothing length [m], neighbour count, 0/1 deletion flag |
| `response/element/<other>/…` | (T, E, …) | f32 | per-element response of any further element group |
| `response/global/{kinetic_energy, internal_energy, total_energy}` | (T,) | f32 | [J] |

`sph/stress` and `sph/strain` are 6-component Voigt tensors; scalar targets are loader-derived (see the card's aux field).

## Loading

Plain HDF5 — nothing beyond `h5py` is needed:

```python
import h5py

with h5py.File("<case_id>.h5") as f:
    t = f["response/time/t"][:]                # (T,) s
    x0 = f["nodes/coords"][:]                  # (N, d) m
    u = f["response/node/displacement"]        # (T, N, d) m, chunked along T
    u_last = u[-1]                             # one frame, no full read
    sig = f["response/element/sph/stress"][:]  # (T, P, 6) Pa, Voigt
```

Or through StructBench's loader, which returns the ML working frame (positions in mm; `axial_stress` in MPa) with the auxiliary target derived on the fly — P SPH particles only (boundary-shell nodes are dropped); T′ = T − 1: the terminal solver-output frame is dropped (ADR-0028):

```python
from structbench.datasets import load_case_trajectory

traj = load_case_trajectory("<case_id>.h5", aux_field="axial_stress")
traj.positions   # (T′, P, d) float32, mm
traj.aux         # (T′, P) float32, MPa
traj.time        # (T′,) float64, s
```

## Benchmark protocol

This archive backs the **Wave1D-Propagation** benchmark in StructBench. Task: autoregressive transition (ADR-0025); auxiliary target `axial_stress` (MPa); 6 input frames, horizon full, scored at native output times; quantities of interest: arrival_time_25, arrival_time_50, arrival_time_75, peak_stress. The full evaluation protocol and its rationale, the baseline recipes and checkpoints, and the current leaderboard live on the benchmark page in the code repository — <https://github.com/qilinli/StructBench/blob/main/docs/benchmarks/wave_propagation_1d.md> — so the numbers have a single home. To train a baseline on this archive:

```bash
pip install git+https://github.com/qilinli/StructBench # or: pip install -e .
structbench-train --mode train --config configs/wave_propagation_1d/cgn.toml \
    --data-root /path/to/this/folder --out runs/wave_propagation_1d-cgn
```

## References

- **CGN** — Li, Q., Wang, Z., Li, L., Hao, H., Chen, W., & Shao, Y. (2023). Machine learning prediction of structural dynamic responses using graph neural networks. *Computers & Structures*, 289, 107188. https://doi.org/10.1016/j.compstruc.2023.107188
- **MGN** — Pfaff, T., Fortunato, M., Sanchez-Gonzalez, A., & Battaglia, P. W. (2021). Learning Mesh-Based Simulation with Graph Networks. *ICLR*. https://arxiv.org/abs/2010.03409
- **Transolver** — Wu, H., Luo, H., Wang, H., Wang, J., & Long, M. (2024). Transolver: A Fast Transformer Solver for PDEs on General Geometries. *ICML*. https://arxiv.org/abs/2402.02366
- **GeoFLARE** — Adams, R., et al. (NVIDIA). GeoTransolver. arXiv:2512.20399; with Puri, R., et al. FLARE: Fast Low-rank Attention Routing Engine. arXiv:2508.12594. GeoFLARE is GeoTransolver with the FLARE attention backend (attention_type GALE_FA; ADR-0045).

## Citation

The data and the code are released together — cite the software
(`CITATION.cff` in the code repository):

```bibtex
@software{structbench,
  author  = {Li, Qilin},
  title   = {StructBench: standardized benchmarks for machine learning on structural simulation},
  year    = {2026},
  version = {0.3.0},
  url     = {https://github.com/qilinli/StructBench},
}
```

Licence: CC BY 4.0 — when redistributing or building on the data, credit Qilin Li (Curtin University) / StructBench and link this dataset repository.