dataset page: fact-check corrections

README.md

@@ -64,30 +64,31 @@ Autoregressive next-step surrogate of a 2D SPH copper bar under Taylor impact ag
 
 ## 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`, `n_frames`, `file_bytes`, `sha256` (integrity manifest; also what the Dataset Viewer shows).
+- `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); response arrays are gzip-compressed and chunked along the frame axis, so one frame or transition can be read without loading the whole trajectory. Shapes below use N nodes, P SPH particles, E elements, T 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).
+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 |
+| `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 |
-| `response/time/t` | (T,) | f64 | output times [s]; frame 0 is the initial state |
+| `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`) follows the same connectivity, element_id, part_id pattern |
+| `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], [kg/m³], [kg], [J] |
-| `response/element/sph/{effective_plastic_strain, radius, n_neighbors, deletion}` | (T, P) | f32 | [–], smoothing length [m], neighbour count, 0/1 deletion flag |
+| `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] |
 
@@ -108,20 +109,20 @@ with h5py.File("<case_id>.h5") as f:
     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:
+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("<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
+traj.positions   # (T′, P, d) float32, mm
+traj.aux         # (T′, P) float32, MPa
+traj.time        # (T′,) float64, s
 ```
 
 ## Splits
 
-The benchmark's fixed split assignment, by case id (the file name without `.h5`):
+The benchmark's fixed split assignment, by case id (the file name without `.h5`). `train` fits the model and `val` selects it; every other split is held out for reporting — `test_interp` sits inside the training parameter range, `test_extrap` beyond it, `probe` cases are off-grid stress tests. Files shipped outside these splits (`held_aside` in the manifest) are not part of the protocol.
 
 - **train** (21): `T-20-60-100`, `T-20-80-100`, `T-20-100-100`, `T-20-60-110`, `T-20-80-110`, `T-20-100-110`, `T-20-60-120`, `T-20-80-120`, `T-20-100-120`, `T-20-60-140`, `T-20-80-140`, `T-20-100-140`, `T-20-60-160`, `T-20-80-160`, `T-20-100-160`, `T-20-60-180`, `T-20-80-180`, `T-20-100-180`, `T-20-60-190`, `T-20-80-190`, `T-20-100-190`
 - **val** (3): `T-20-60-150`, `T-20-80-150`, `T-20-100-150`
@@ -133,7 +134,7 @@ The benchmark's fixed split assignment, by case id (the file name without `.h5`)
 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:
 
 ```bash
-pip install structbench  # or: pip install -e . from the repo
+pip install git+https://github.com/qilinli/StructBench  # or: pip install -e . from a clone
 structbench-train --mode train --config configs/taylor_impact_2d/cgn.toml \
     --data-root /path/to/this/folder --out runs/taylor_impact_2d-cgn
 ```
@@ -159,3 +160,5 @@ The data and the code are released together — cite the software
   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.

decks/README.md

@@ -1,5 +1,5 @@
 LS-DYNA input decks, one per case (`<case_id>.k`), in the deck's
-native kg-mm-ms unit system — the provenance root: re-running a
+native g-mm-ms unit system — the provenance root: re-running a
 deck in LS-DYNA regenerates the case's raw output, which the
 repository's adapter converts to the canonical HDF5 shipped here
 (strict SI, ADR-0012/0016).