StructBench/wave-propagation-1d

Wave1D-Propagation — StructBench canonical dataset

Download

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

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:

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

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:

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

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