case_id stringlengths 9 9 | split stringclasses 3
values | bar_length_mm int64 200 500 | initial_speed_ms int64 1 8 | n_nodes int64 504 1.25k | n_frames int64 302 302 | file_bytes int64 9.04M 21.9M | sha256 stringlengths 64 64 |
|---|---|---|---|---|---|---|---|
W1D-200-1 | train | 200 | 1 | 504 | 302 | 9,042,036 | 4035258e4fc1799901b5a0ce03f0c00fbfc6343d22498a1dec9fbd159a1c01e9 |
W1D-200-2 | train | 200 | 2 | 504 | 302 | 9,086,927 | 5381af499f9a768e976a60aed5c4cf8ed3bbeaeb2a0de6240d18260333d0f0d0 |
W1D-200-4 | train | 200 | 4 | 504 | 302 | 9,128,137 | 36f779f7b0c17524381052cba6f1243a210f911e2f307caeedc7d89da97bcaea |
W1D-200-8 | train | 200 | 8 | 504 | 302 | 9,532,583 | 161ac76322c18b0738a9585a6a94771adeb482eed4046395cb4765f867736548 |
W1D-300-1 | train | 300 | 1 | 754 | 302 | 13,788,983 | cf849d6e4e415e40886aa2c33890001dba7a1e18f6009207f9d024c5be45f2ad |
W1D-300-8 | train | 300 | 8 | 754 | 302 | 14,092,913 | 2a9f4ec18b2640732ca95bd1e301eebc82de2416bf7a18818cec97a2378b99f4 |
W1D-400-1 | train | 400 | 1 | 1,004 | 302 | 18,346,798 | 21fe2da3e4a6843d472820ae55dbaeaf216ebeb5d6abe62a30d43e02fb319921 |
W1D-400-8 | train | 400 | 8 | 1,004 | 302 | 18,235,038 | 6dfa77358759158554422af609a08009d72810cf9d672a958a51bd41700f9421 |
W1D-500-1 | train | 500 | 1 | 1,254 | 302 | 21,851,631 | e4bd3dc3b087eb309770361ef20967c3131cb93d18be2013cc7a4a0a2ebe4fb0 |
W1D-500-2 | train | 500 | 2 | 1,254 | 302 | 21,484,681 | 733242b7e8934b90f786358c10fa931a4724521b8e27b94d4844b3df57841c62 |
W1D-500-4 | train | 500 | 4 | 1,254 | 302 | 21,576,959 | c4fb6cb6e29493126887f77858ee617b09f351da369e452fe37a146f26bdf852 |
W1D-500-8 | train | 500 | 8 | 1,254 | 302 | 21,923,097 | 55d6558dbd647fee9253da44370ae5739aea9bd7fad6d02dcd127056820ac928 |
W1D-300-2 | val | 300 | 2 | 754 | 302 | 13,900,379 | 2c4f765e6f284a1cd719a5eb54927726d3f73d516f15dc231615c86e7638eb24 |
W1D-400-4 | val | 400 | 4 | 1,004 | 302 | 17,526,766 | 2e333aee240612d7c1bf6bbf28552613e0f101dca3028d35932c8816d2a2342e |
W1D-300-4 | test_interp | 300 | 4 | 754 | 302 | 13,962,839 | d47a8c66993e4a0b52bb51f6abed5ac99fad94e3137c981d7f72a4372031a40a |
W1D-400-2 | test_interp | 400 | 2 | 1,004 | 302 | 18,425,904 | 08b30692e4834bd0089ae9d906d79871a267866b96265afaacd158de80502cbd |
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.1
tag (revision="v0.1.1" β a data release, independent of the code
version) for reproducible pipelines. Point
structbench-train --data-root at the snapshot directory.
Code, benchmark protocol, and results registries:
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
- Structural scale: specimen
- Load type: stress wave: an elastic bar arrested from an initial axial velocity
- Autonomy: autonomous: after the 6 seed frames the model receives nothing; the arrested end is a fixed boundary
- Parameter space: full factor grid, 4 bar lengths x 4 initial velocities; val and test_interp are interior grid points, every level is in training (ADR-0025). training box: bar_length_mm 200β500; initial_velocity_m_s 1β8. margin: none declared.
- Ground truth: explicit dynamic SPH in LS-DYNA with scaled toy elastic constants, one run per case, no repeats; no verification record is published for this archive. Uncertainty: not measured: no convergence case, no repeat run, no smoothing-floor analysis.
- 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_asidefor files shipped outside the protocol splits), the loading/geometry parameters parsed from the id,n_nodes(rows ofnodes/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'smetadata/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 docs/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], as the solver's state output writes them. total_energy is kinetic + internal, to float32; it is NOT the run's total energy, because it excludes dissipation terms the solver's own energy ledger carries (rigid-wall work, contact, hourglass, damping). Which of those a given run had is a property of that run: on the Taylor sweep, the only one of these archives whose runs kept an energy ledger, the omission is the rigid-wall work and reaches 0.6-1.2 % of the peak, growing through the run. Do not read this channel as an energy balance; no verification record is published for this archive yet |
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, C) float32, MPa (C = 1 here; ADR-0059)
traj.time # (Tβ²,) float64, s
Scored sets
Every split but train and val is scored, and a scored case is read by its coverage, not its split's name (ADR-0074): within the training design's declared box or beyond it, and its distance to the nearest training point in units of the training set's median nearest-neighbour spacing (one grid step on a grid), binned β€ 1, 1β2, > 2; a case with an unseen categorical level or a changed constant is novel and shown apart. The box is the card's parameter space.
| Set | Cases | Coverage |
|---|---|---|
test_interp |
2 | within, 1β2 (1); within, β€ 1 (1) |
Data standard
Where this benchmark's reference data stands against the platform's data standard. A benchmark admitted after 2026-10-01 must have a convergence run, measured noise floor, survivor log of discarded cases, constitutive sensitivity study (ADR-0073 D14); a physical-test anchor and a second-solver reproduction are recorded where they exist and not required; the blind evaluation set is ADR-0074's. The benchmarks shipped before that date are grandfathered (ADR-0065): their rows show what exists, and a missing row is a fact about the data, not a verdict on it. Status: pass β the item exists and is recorded; missing β it does not exist yet; not applicable β the item has no meaning for this data; never β it cannot be produced.
| Item | Status | Reason |
|---|---|---|
| Convergence run | missing | the sweep has no case re-run at a second resolution. |
| Measured noise floor | missing | no floor has been measured on the axial-stress field; one run per case, no smoothing-floor analysis. |
| Survivor log of discarded cases | missing | the sweep predates the platform; no record of discarded or failed runs was kept. |
| Constitutive sensitivity study | missing | no study of the response's sensitivity to the *MAT_ELASTIC constants exists (they are scaled toy values). |
| Physical-test anchor | missing | none exists; the toy constants correspond to no physical bar. |
| Second-solver reproduction | missing | no case has been reproduced in a second solver. |
| Blind evaluation set | missing | a blind set follows when LS-DYNA access allows (ADR-0074); until then every scored case is on the public grid. |
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 results registry 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: verification and validation benchmarks for learned surrogates of structural response},
year = {2026},
version = {0.5.0},
doi = {10.5281/zenodo.24214777},
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.
- Downloads last month
- 350