--- 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`): ```python from huggingface_hub import hf_hub_download, snapshot_download # one case path = hf_hub_download("StructBench/taylor-impact-2d", filename=".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: . 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 - `.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/.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--` — 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//…` | (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//…` | (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(".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): ```python from structbench.datasets import load_case_trajectory traj = load_case_trajectory(".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 — — 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/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): ```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.