Datasets:

StructBench
/

taylor-impact-2d

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

Taylor2D-Impact — 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/taylor-impact-2d",
                       filename="<case_id>.h5", repo_type="dataset")

# the full archive (resumable; cached under HF_HOME)
root = snapshot_download("StructBench/taylor-impact-2d", 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 a 2D SPH copper bar under Taylor impact against a rigid wall (ADR-0019).

Dataset summary

Solver: LS-DYNA (SPH; erosion: no)
Loading: rigid-wall impact; initial velocity 100-200 m/s
Geometry: 2D bar, 20 mm x {60, 80, 100} mm
Materials: *MAT_ELASTIC_PLASTIC_HYDRO; *EOS_GRUNEISEN
Source units: g-mm-ms (files are strict SI, ADR-0012)
Cases: 33 (train 21, val 3, test_interp 6, test_extrap 3)
Particles per case: 4800-8000; 152 frames at 0.002 ms; 2.4 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 (3 bar lengths x 11 impact velocities) produced by Curtin collaborators; benchmark protocol per ADR-0019. One extra Convergence run is held aside for a mesh-resolution check.
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: T-20-<L>-<V> — 20 mm bar width, bar length L mm, impact speed V m/s (T-20-80-Convergence is the held-aside mesh-convergence run).

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 g-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.002 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; von_mises_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="von_mises_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 Taylor2D-Impact benchmark in StructBench. Task: autoregressive transition (ADR-0019); auxiliary target von_mises_stress (MPa); 6 input frames, horizon full, scored at native output times; quantities of interest: final_length, mushroom_width, peak_von_mises, t_peak_von_mises. 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/taylor_impact_2d.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/taylor_impact_2d/cgn.toml \
    --data-root /path/to/this/folder --out runs/taylor_impact_2d-cgn

References

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
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
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
Transolver++ — Luo, H., Wu, H., Zhou, H., Wang, J., & Long, M. (2025). Transolver++: An Accurate Neural Solver for PDEs on Million-Scale Geometries. https://arxiv.org/abs/2502.02414. Adapted per ADR-0057 (thuml reference implementation github.com/thuml/Transolver_plus).
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.