Initial dataset release

Anonymous review release with data, metadata, fixed splits, validation scripts, and checksums.

.gitignore

@@ -0,0 +1,5 @@
+derived_peak/
+visualizations/
+__pycache__/
+*.pyc
+

BUILD_AUDIT.json

@@ -0,0 +1,28 @@
+{
+  "dataset": "Automotive Impact Dataset",
+  "version": "1.0.0",
+  "audit_date": "2026-08-26",
+  "case_byte_preservation": {
+    "status": "passed",
+    "cases": 1500,
+    "method": "SHA-256 of each source .pt file recorded in manifest.csv and rechecked from the ZIP member"
+  },
+  "peak_derivation_reference_match": {
+    "status": "passed",
+    "cases": 1500,
+    "floorfrontdriver": "500/500 exact",
+    "floorfrontR": "500/500 exact",
+    "trunkfloor": "500/500 exact",
+    "method": "build_peak_targets.select_peak was applied to each released ZIP member and compared with the pre-existing validated peak-case tensors; selected time index, selected node index, displacement tensor, and max-IP von Mises effective-stress tensor were exactly equal"
+  },
+  "normalization_reproduction": {
+    "status": "passed",
+    "split": "400 training cases only",
+    "outputs": [
+      "metadata/floorfrontdriver_peak_normalization.json",
+      "metadata/floorfrontR_peak_normalization.json",
+      "metadata/trunkfloor_peak_normalization.json"
+    ]
+  },
+  "scope_note": "This is a technical build audit; provenance and unit limitations are documented separately."
+}

CITATION.cff

@@ -0,0 +1,18 @@
+cff-version: 1.2.0
+message: "If you use this dataset, please cite the versioned Hugging Face repository for release v1.0.0."
+title: "Automotive Impact Dataset: Multi-Geometry Full-Field Transient Simulation Data"
+type: dataset
+version: 1.0.0
+date-released: 2026-09-08
+authors:
+  - family-names: "Authors"
+    given-names: "Anonymous"
+repository-artifact: "https://huggingface.co/datasets/structmeshdata/automotive-impact-data"
+keywords:
+  - finite element simulation
+  - impact mechanics
+  - graph neural operator
+  - displacement field
+  - von Mises effective stress
+  - LS-DYNA
+license: MIT

DATASHEET.md

@@ -0,0 +1,114 @@
+# Datasheet for the Automotive Impact Dataset
+
+## Motivation
+
+The dataset supports research on mesh-based surrogate modeling of transient
+impact response. It was created to evaluate whether neural operators can map a
+finite-element mesh and impact/material conditions to spatially distributed
+displacement and shell von Mises effective-stress trajectories.
+
+## Composition
+
+- 3 fixed automotive floor-panel geometries.
+- 500 independent LHS cases per geometry; 1,500 cases total.
+- 17 aligned states per case.
+- Nodal displacement: three Cartesian components.
+- Shell-element von Mises effective stress: one scalar per element and state,
+  taken as the maximum over all through-thickness integration points.
+- Impact position, three-dimensional velocity, mass ratio, and material
+  parameters are stored per case.
+- Static graph topology and shell element-to-node connectivity are provided per
+  geometry.
+- One fixed 400/50/50 train/validation/test partition with seed 12345.
+
+Exact tensor shapes are specified in `schema.json` and geometry metadata files.
+
+## Stress definition
+
+The `effective_stress` target is exported from LS-PrePost using `etime 9`,
+labeled `Effective Stress (v-m), ip#max`. For each shell element and retained
+state, it stores the maximum von Mises equivalent stress across all
+through-thickness integration points. The integration-point index producing
+the maximum is not retained. Values are reported in MPa.
+
+## Collection and simulation process
+
+Conditions were sampled using Latin hypercube sampling over predefined impact
+and material parameter spaces. The simulations were executed with LS-DYNA on
+subsets of a 2020 Nissan Rogue finite-element model. Raw solver databases and
+curve text are not included. The released compact tensors retain 17 selected
+simulation states of nodal displacement and shell von Mises effective stress.
+
+The exact LS-DYNA version, source-model version, boundary/contact setup, state
+sampling rule, and consistent unit system are not specified in this release.
+
+## Preprocessing
+
+The released case tensors are the compact 17-state inputs to downstream data
+preparation. They have not been reduced to a single peak state. The accompanying
+`build_peak_targets.py` derives the paper task by selecting the state containing
+the largest valid nodal displacement magnitude and using stress from the same
+state.
+
+Some source nodes may require filled values; each case retains
+`raw_valid_node_mask`, `filled_node_mask`, `filled_node_count`, and
+`valid_node_mask` to make that processing explicit.
+
+## Data quality
+
+The release validator checks:
+
+- exactly 500 cases per geometry;
+- geometry-specific displacement and stress shapes;
+- 17 states in each field;
+- finite displacement and stress values;
+- monotonic displacement and element time arrays;
+- exact alignment of displacement and stress time arrays;
+- valid static graph and shell-element connectivity;
+- complete and disjoint split coverage;
+- archive membership and SHA-256 case digests.
+
+The `floorfrontR` revision additionally requires the source stress quality
+audit described in `metadata/floorfrontR_DATA_NOTE.md`.
+
+## Recommended uses
+
+- full-field transient surrogate modeling;
+- graph neural operators and mesh-based learning;
+- peak-event displacement/stress prediction;
+- temporal interpolation or sequence modeling within the released protocol;
+- controlled comparisons on fixed meshes;
+- simulation-based screening research.
+
+## Out-of-scope or unsupported uses
+
+- safety certification or replacement of final CAE/physical testing;
+- claims of arbitrary-geometry generalization;
+- treating same-numbered cases across geometries as physical pairs;
+- claims about real-world crash response without external validation;
+- mixing earlier internal `floorfrontR` artifacts with this release;
+- interpreting the public test labels as a permanently hidden benchmark.
+
+## Splits and benchmark integrity
+
+The full v1.0 release includes labels for train, validation, and test cases.
+Consequently, the test split reproduces the paper protocol but is not a hidden
+benchmark after publication. New benchmark work should define a separate
+private evaluation set or use an evaluation server.
+
+## Personal and sensitive information
+
+The data contain no human participants, personal data, or user-generated
+content. The main reuse consideration is the documented provenance of the
+underlying vehicle mesh.
+
+## Distribution and maintenance
+
+The archival host is the Hugging Face Hub, with a version tag. Changes to data
+files require a new dataset version. Metadata changes should be documented
+without silently replacing data.
+
+## Licensing
+
+The repository is released under the MIT License. Third-party provenance and
+attribution are documented in `THIRD_PARTY_NOTICES.md`.

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anonymous Dataset Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSE-CODE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anonymous Dataset Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,151 @@
+---
+pretty_name: "Automotive Impact Dataset: Multi-Geometry Full-Field Transient Simulation Data"
+license: mit
+tags:
+  - 3d
+  - timeseries
+  - finite-element-analysis
+  - impact-mechanics
+  - graph-neural-networks
+viewer: false
+---
+
+# Automotive Impact Dataset
+
+**Version:** 1.0.0  
+**Data type:** finite-element simulation trajectories  
+**Task:** impact-conditioned displacement and shell von Mises effective-stress field prediction
+
+The Automotive Impact Dataset contains independent impact simulations
+on three automotive structural geometries. Each geometry has 500
+Latin-hypercube-sampled impact conditions. Every case stores 17 aligned states
+of the full three-dimensional nodal displacement field and shell-element
+von Mises effective stress.
+
+The dataset supports research on graph neural operators, mesh-based surrogate
+models, spatiotemporal field prediction, peak-event prediction, and
+simulation-based design screening.
+
+## Dataset summary
+
+| Geometry | Cases | Nodes | Directed graph edges | Shell elements | Displacement | von Mises effective stress |
+|---|---:|---:|---:|---:|---|---|
+| `floorfrontdriver` | 500 | 7,408 | 29,572 | 7,374 | `[7408,17,3]` | `[7374,17]` |
+| `floorfrontR` | 500 | 12,011 | 48,138 | 12,055 | `[12011,17,3]` | `[12055,17]` |
+| `trunkfloor` | 500 | 14,440 | 58,074 | 14,589 | `[14440,17,3]` | `[14589,17]` |
+
+The three geometries are independent datasets. Equal case identifiers across
+geometries do **not** denote paired physical simulations.
+
+## Stress definition
+
+The `effective_stress` field is the shell-element von Mises equivalent stress
+exported from LS-PrePost. The LS-PrePost `etime 9` component corresponds to
+`Effective Stress (v-m), ip#max`: for each shell element and retained state,
+the stored scalar is the maximum von Mises stress over all through-thickness
+integration points. The maximizing integration-point index is not retained.
+Stress values are in MPa, and the tensor shape is `[Ne, 17]`.
+
+## Repository structure
+
+```text
+automotive-impact-data/
+├── data/
+│   ├── floorfrontdriver/cases_001_100.zip ... cases_401_500.zip
+│   ├── floorfrontR/cases_001_100.zip ... cases_401_500.zip
+│   └── trunkfloor/cases_001_100.zip ... cases_401_500.zip
+├── meshes/
+├── metadata/
+├── scripts/
+├── manifest.csv
+├── checksums.sha256
+├── DATASHEET.md
+└── schema.json
+```
+
+Each ZIP member is stored as `cases/caseNNN.pt`. The files are PyTorch-serialized
+plain dictionaries. `manifest.csv` records the byte size and SHA-256 digest of
+every case.
+
+## Download
+
+```python
+from huggingface_hub import snapshot_download
+
+dataset_root = snapshot_download(
+    repo_id="structmeshdata/automotive-impact-data",
+    repo_type="dataset",
+    revision="v1.0.0",
+)
+```
+
+## Loading a case
+
+PyTorch 2.6 or newer is recommended. The loader uses `weights_only=True` and
+reads cases directly from ZIP shards:
+
+```bash
+python scripts/load_case.py \
+  --dataset-root . \
+  --geometry floorfrontdriver \
+  --case case001
+```
+
+```python
+from pathlib import Path
+import sys
+
+sys.path.insert(0, str(Path("scripts").resolve()))
+from load_case import load_case, load_mesh
+
+case = load_case(Path("."), "floorfrontdriver", "case001")
+mesh = load_mesh(Path("."), "floorfrontdriver")
+print(case["disp"].shape)
+print(case["effective_stress"].shape)
+```
+
+## Validation
+
+```bash
+python scripts/validate_dataset.py --dataset-root . --verify-checksums
+```
+
+The validator checks the case schema, tensor shapes, finite values, aligned
+time arrays, split coverage, mesh connectivity, archive membership, and
+SHA-256 digests.
+
+## Fixed split and peak-event task
+
+The fixed split is 400 train / 50 validation / 50 test cases per geometry with
+seed 12345. Normalization statistics must be computed from the training cases
+only.
+
+For peak-event prediction, the supplied script selects the state containing the
+global maximum valid nodal displacement magnitude and uses the von Mises
+effective-stress field from that same state.
+
+## Data-version note
+
+The included `floorfrontR` data passed the release quality audit. Files from
+earlier internal builds must not be mixed with this release; see
+`metadata/floorfrontR_DATA_NOTE.md`.
+
+## Limitations
+
+- The fields are numerical simulation results, not physical crash-test measurements.
+- The dataset covers three fixed meshes and their documented sampled conditions.
+- It does not establish generalization to arbitrary vehicle geometries or real tests.
+- Public test labels reproduce the fixed paper protocol but are not a hidden benchmark.
+- The consistent unit system is not specified for fields without an explicit
+  unit in the schema. The `effective_stress` field is explicitly reported in MPa.
+
+## License
+
+This repository is released under the MIT License. Third-party names and source
+model provenance are documented in `THIRD_PARTY_NOTICES.md`.
+
+## Citation
+
+Please cite the versioned Hugging Face repository for release `v1.0.0`:
+https://huggingface.co/datasets/structmeshdata/automotive-impact-data/tree/v1.0.0.
+Citation metadata is also provided in `CITATION.cff`.

README_zh.md

@@ -0,0 +1,43 @@
+# 汽车结构冲击数据集中文说明
+
+本汽车结构冲击数据集包含三种汽车
+结构几何上的独立冲击有限元仿真。每种几何包含 500 个 LHS 工况，
+每个工况保存 17 个对齐时刻的完整节点三维位移场和壳单元
+von Mises 等效应力场。
+
+## 数据规模
+
+| 几何 | case数 | 节点数 | 壳单元数 | 位移张量 | 应力张量 |
+|---|---:|---:|---:|---|---|
+| `floorfrontdriver` | 500 | 7,408 | 7,374 | `[7408,17,3]` | `[7374,17]` |
+| `floorfrontR` | 500 | 12,011 | 12,055 | `[12011,17,3]` | `[12055,17]` |
+| `trunkfloor` | 500 | 14,440 | 14,589 | `[14440,17,3]` | `[14589,17]` |
+
+三种几何是彼此独立的数据。相同 case ID 不代表同一次物理仿真，
+不能作为跨几何物理配对样本。
+
+## 应力定义
+
+`effective_stress` 是通过 LS-PrePost 导出的壳单元 von Mises 等效应力。
+LS-PrePost 的 `etime 9` 对应 `Effective Stress (v-m), ip#max`：对每个壳单元
+和每个保留时刻，在全部厚度积分点的 von Mises 应力中取最大值。数据不保留
+取得最大值的积分点编号。应力单位为 MPa，张量形状为 `[Ne,17]`。
+
+## 使用方法
+
+无需预先解压 ZIP 即可读取：
+
+```bash
+python scripts/load_case.py --dataset-root . \
+  --geometry floorfrontdriver --case case001
+```
+
+全量验证：
+
+```bash
+python scripts/validate_dataset.py --dataset-root . --verify-checksums
+```
+
+本发布包中的 `floorfrontR` 数据经过完整质量核查；不要与更早的内部构建
+混用。本仓库采用 MIT License，详细来源、字段和局限请参阅英文
+`README.md`、`DATASHEET.md` 和 `THIRD_PARTY_NOTICES.md`。

THIRD_PARTY_NOTICES.md

@@ -0,0 +1,32 @@
+# Third-party notices and provenance
+
+## 2020 Nissan Rogue finite-element model
+
+The three released floor-panel meshes originate from a 2020 Nissan Rogue
+finite-element model developed by the Center for Collision Safety and Analysis
+(CCSA), George Mason University, under a contract with the U.S. National
+Highway Traffic Safety Administration (NHTSA).
+
+Official model page:
+
+https://www.ccsa.gmu.edu/models/2020-nissan-rogue/
+
+The official page currently describes Version 3 (released August 2024) and
+references DOI `10.13021/xb7g-8z06` for its presentation. The exact upstream
+model version used to create this dataset is not specified in this release.
+
+Users should consult the upstream model terms and attribution requirements when
+redistributing or adapting extracted geometry.
+
+## LS-DYNA
+
+LS-DYNA is third-party commercial software. No LS-DYNA executable, library,
+license file, solver database, or proprietary program component is included.
+This dataset contains compact numerical outputs generated by simulations.
+Users remain responsible for complying with applicable LS-DYNA terms.
+
+## Trademarks and endorsement
+
+Nissan, LS-DYNA, CCSA, GMU, NHTSA, and other names may be trademarks or names
+of their respective owners. Their mention documents provenance and does not
+imply endorsement of this dataset or its authors.

VALIDATION_REPORT.json

@@ -0,0 +1,59 @@
+{
+  "dataset": "Automotive Impact Dataset",
+  "version": "1.0.0",
+  "status": "passed",
+  "cases_validated": 1500,
+  "split_sizes": {
+    "train": 400,
+    "val": 50,
+    "test": 50
+  },
+  "archives": {
+    "archives": 15,
+    "archive_bytes": 5032143218
+  },
+  "geometries": {
+    "floorfrontdriver": {
+      "nodes": 7408,
+      "edges": 29572,
+      "elements": 7374,
+      "cases": 500,
+      "source_case_bytes": 1099705500,
+      "materials": {
+        "aluminum_rigid": 167,
+        "steel_rigid": 166,
+        "titanium_rigid": 167
+      }
+    },
+    "floorfrontR": {
+      "nodes": 12011,
+      "edges": 48138,
+      "elements": 12055,
+      "cases": 500,
+      "source_case_bytes": 1783897500,
+      "materials": {
+        "aluminum_rigid": 166,
+        "steel_rigid": 167,
+        "titanium_rigid": 167
+      }
+    },
+    "trunkfloor": {
+      "nodes": 14440,
+      "edges": 58074,
+      "elements": 14589,
+      "cases": 500,
+      "source_case_bytes": 2148377888,
+      "materials": {
+        "aluminum_rigid": 166,
+        "steel_rigid": 167,
+        "titanium_rigid": 167
+      }
+    }
+  },
+  "checksums": {
+    "checked_files": 48
+  },
+  "elapsed_seconds": 35.055318117141724,
+  "errors": [],
+  "scope_note": "Technical package validation only; provenance and unit limitations are documented in the release metadata."
+}

checksums.sha256

@@ -0,0 +1,48 @@
+1390fe35fb4bf7ae3b664798735e5e6e90421a14ee41717029b704d8189571e4  .gitignore
+86c650d36a0e7a29ed044ce5fdc82252f1a23ed8d2a7f5115682071d18c4c7fb  BUILD_AUDIT.json
+5c0a42fb6c26561ab533201ad032a6d9b9e85e827c9a335aeb793ffe907d20e8  CITATION.cff
+f32d7e8db854f624a0c7120491083d281bbc3adca0314f6eb59cd23aa780bd72  DATASHEET.md
+0566a01e7392327b540b35810be439b9f5f1e0ff330c2d2c9e5cc72ccc319363  LICENSE
+0566a01e7392327b540b35810be439b9f5f1e0ff330c2d2c9e5cc72ccc319363  LICENSE-CODE
+0fdee0293d7c742a9b6d9db59f0220b3d3dffe0cfd47a5fc1b5da4916d606631  README.md
+542ff825ded829acc9c4ef327f940c9cb9d3fbcd133b3e785b9d796a03876f52  README_zh.md
+36078792dcb193b3e0fa4db0d777c225ab5b8f0c4c8a9e53eee6e605c275596f  THIRD_PARTY_NOTICES.md
+b86c173e169a1f0fd8c298b86f155d4c2e4d909e225c467600558c3b01d41ec5  data/floorfrontR/cases_001_100.zip
+b06750609d7da3579f4e83a973255be17288ff75643add7a85a7764a5e93dcd7  data/floorfrontR/cases_101_200.zip
+2ebee491189083a7f33aeb11999cfc04ce77fd4bed57745f9b5202d1951a6a58  data/floorfrontR/cases_201_300.zip
+113c5ef39dea2fe7ed8ae308caacf5d645cdf47decd6617f2016c50940fe4268  data/floorfrontR/cases_301_400.zip
+aacfa537964d66afbfb016e574a2b65b0090e45efedc9f6927588e8c25a5ead3  data/floorfrontR/cases_401_500.zip
+3830ce1d63bad9ac462b3d698d3c32d40048ad3abce2684557cda4ef3a25b83b  data/floorfrontdriver/cases_001_100.zip
+d79ee669ab96f3ced5b6732f69d8a5f31e438ca90d794e3473f69aedb72dba47  data/floorfrontdriver/cases_101_200.zip
+e657c51c967e8bd5622ec1c03421b6db513ef3f78dff77cd295f2089565177de  data/floorfrontdriver/cases_201_300.zip
+e9e2d02fd1c2231300713ae47b85762f3e9c5c087572df45f2ee2e2032f536e2  data/floorfrontdriver/cases_301_400.zip
+36d4b2f7158dbaff0aafbffc5249d9506e85ce1257bfe8d4e3a29b83c6135f52  data/floorfrontdriver/cases_401_500.zip
+c5a938dea14657df147648795247a415d8ec31a3ca68c989a69ed62e154e5749  data/trunkfloor/cases_001_100.zip
+1df0154c07e734a1bb67243eb236abc16c5bc7b09e526bf6ed99a900e27fb3d0  data/trunkfloor/cases_101_200.zip
+745ab8ad15ed3a40466f4b1c2e539cac3981cf3442da5d267150356e6c923f8b  data/trunkfloor/cases_201_300.zip
+f7c0ebbd8bf53079bb7fbf856286c8df2a5652184ecf3884398c190530019dd7  data/trunkfloor/cases_301_400.zip
+98487b9085eb8d715ae81d3466befec53fb8468ff1286a357c5380f91de02dfd  data/trunkfloor/cases_401_500.zip
+02f7ac3d93d902eab35e4235d94ee70a7b3a3b75387053a3351c6a5bb977d503  manifest.csv
+7c63c99afe297f995c18a801159573f4b5a86bc25031743fd5168da77a47385d  meshes/floorfrontR_mesh.npz
+f3493dbed1517d74b34cc6a801238735e3c570f63234566d6f4f8dede51788ba  meshes/floorfrontdriver_mesh.npz
+9cbb3476bed490746ef6e01f0049ec1573746a2c68ca5537364e66311a29ce9b  meshes/trunkfloor_mesh.npz
+3f1e4cf04904aeb1fc07d793a258e2517cf9f5e9b8331619e4e50c1452961fd0  metadata/dataset.json
+5827784a6b36fb7df800dcad4c2e2cb1ef69b69770ed16a74fd273bb660d6817  metadata/floorfrontR_DATA_NOTE.md
+decbe458d0572178fa502b35329460bd758884f06fc72f2e095a8e99185b0080  metadata/floorfrontR_conditions.csv
+2ff08ba7c53b96f23c064f1ca3be61e304334e9bb171b0b7c5f7ff0847956b67  metadata/floorfrontR_geometry.json
+4f4c3db379540ac3aa5d27ca4ed96095324d43a47b93ecbd1c321d54700cf8ef  metadata/floorfrontR_peak_normalization.json
+5576a6401c58a83c856b5b5d350f04fe7d4f98417db2d34848ffd8f91290157d  metadata/floorfrontdriver_conditions.csv
+20af0abfb6c792abbacfa60e62e95559441d0499f4a88223f0c3bc007ba9d351  metadata/floorfrontdriver_geometry.json
+0ad2af354f04891d1768c3d6bb6d7a9eb925935ea411f163107bd9bf2d747780  metadata/floorfrontdriver_peak_normalization.json
+cd89eadfc5b9c1b69832a24d0c00617d2fdf2e983fe3bfd1d3a8ac15166c9ab9  metadata/split_400_50_50_seed12345.json
+f64c3d94411da71e7ef5ec1bac9ce5d6c2305189bd6469a3c34c75a0b42d8bd8  metadata/trunkfloor_conditions.csv
+4da2240fbd33e8a3d850f534fb655949b74af1839b88cdaccf11ead81a7eb505  metadata/trunkfloor_geometry.json
+37e1726395b3960f1d549f360c6428c47cda21bf4fc4a92783de2b163b7f3fb1  metadata/trunkfloor_peak_normalization.json
+0cce019ecf8bfd4633d965659c4d9032b62d21cd31532eb96fecc0627a26b2fd  release_inventory.json
+c0801d2e3f5249c34a251979aecaa32b046deabb5cb627f0592866e4dee5f376  requirements.txt
+39dab43c60a84f6080f00da3b881e336e7c2e93b62675747f26f42691dde27df  schema.json
+3008c2139a8d7ee556222e964c5e5e638828683e4bd38003098cdd2df0b413d0  scripts/build_peak_targets.py
+683dc2d9c9bf93d47e5edf253045e8a19e0bf1dccdd5784c52570b72c3c840dc  scripts/compute_train_normalization.py
+6781f7623d8c7f9bca4798f94bf0cd4bd272cd4ef29c7bdeda1a287c0aa14ec1  scripts/load_case.py
+b680b796dd1990d30abf3cc7ed7c862eef8128b9167057f4f25229eb91059e43  scripts/validate_dataset.py
+7afa09ebeda88f8afed693540899f1d3a1ded9ab0bb2c6d67bab1b6ba99d55f0  scripts/visualize_trajectory.py

data/floorfrontR/cases_001_100.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b86c173e169a1f0fd8c298b86f155d4c2e4d909e225c467600558c3b01d41ec5
+size 356790322

data/floorfrontR/cases_101_200.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b06750609d7da3579f4e83a973255be17288ff75643add7a85a7764a5e93dcd7
+size 356790322

data/floorfrontR/cases_201_300.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ebee491189083a7f33aeb11999cfc04ce77fd4bed57745f9b5202d1951a6a58
+size 356790322

data/floorfrontR/cases_301_400.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:113c5ef39dea2fe7ed8ae308caacf5d645cdf47decd6617f2016c50940fe4268
+size 356790322

data/floorfrontR/cases_401_500.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aacfa537964d66afbfb016e574a2b65b0090e45efedc9f6927588e8c25a5ead3
+size 356790322

data/floorfrontdriver/cases_001_100.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3830ce1d63bad9ac462b3d698d3c32d40048ad3abce2684557cda4ef3a25b83b
+size 219951922

data/floorfrontdriver/cases_101_200.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d79ee669ab96f3ced5b6732f69d8a5f31e438ca90d794e3473f69aedb72dba47
+size 219951922

data/floorfrontdriver/cases_201_300.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e657c51c967e8bd5622ec1c03421b6db513ef3f78dff77cd295f2089565177de
+size 219951922

data/floorfrontdriver/cases_301_400.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e9e2d02fd1c2231300713ae47b85762f3e9c5c087572df45f2ee2e2032f536e2
+size 219951922

data/floorfrontdriver/cases_401_500.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36d4b2f7158dbaff0aafbffc5249d9506e85ce1257bfe8d4e3a29b83c6135f52
+size 219951922

data/trunkfloor/cases_001_100.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c5a938dea14657df147648795247a415d8ec31a3ca68c989a69ed62e154e5749
+size 429487922

data/trunkfloor/cases_101_200.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1df0154c07e734a1bb67243eb236abc16c5bc7b09e526bf6ed99a900e27fb3d0
+size 429487922

data/trunkfloor/cases_201_300.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:745ab8ad15ed3a40466f4b1c2e539cac3981cf3442da5d267150356e6c923f8b
+size 429487922

data/trunkfloor/cases_301_400.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f7c0ebbd8bf53079bb7fbf856286c8df2a5652184ecf3884398c190530019dd7
+size 430480310

data/trunkfloor/cases_401_500.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:98487b9085eb8d715ae81d3466befec53fb8468ff1286a357c5380f91de02dfd
+size 429487922

meshes/floorfrontR_mesh.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c63c99afe297f995c18a801159573f4b5a86bc25031743fd5168da77a47385d
+size 318519

meshes/floorfrontdriver_mesh.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f3493dbed1517d74b34cc6a801238735e3c570f63234566d6f4f8dede51788ba
+size 197309

meshes/trunkfloor_mesh.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9cbb3476bed490746ef6e01f0049ec1573746a2c68ca5537364e66311a29ce9b
+size 381880

metadata/dataset.json

@@ -0,0 +1,65 @@
+{
+  "title": "Automotive Impact Dataset",
+  "version": "1.0.0",
+  "release_status": "public-release",
+  "resource_type": "dataset",
+  "total_cases": 1500,
+  "geometries": [
+    "floorfrontdriver",
+    "floorfrontR",
+    "trunkfloor"
+  ],
+  "cases_per_geometry": 500,
+  "states_per_case": 17,
+  "split": {
+    "seed": 12345,
+    "train": 400,
+    "validation": 50,
+    "test": 50,
+    "note": "same case-ID lists, independent simulations per geometry"
+  },
+  "fields": {
+    "inputs": [
+      "fixed finite-element mesh",
+      "impact_xyz",
+      "velocity_xyz",
+      "mass_ratio",
+      "material_young_mpa",
+      "material_poisson"
+    ],
+    "outputs": [
+      "17-state nodal 3D displacement",
+      "17-state shell von Mises effective stress, maximized over through-thickness integration points"
+    ]
+  },
+  "units": {
+    "status": "NOT_SPECIFIED_IN_RELEASE",
+    "coordinate": null,
+    "displacement": null,
+    "time": null,
+    "velocity": null,
+    "effective_stress": "MPa",
+    "young_modulus": "field name states MPa; verify against solver unit system",
+    "impactor_mass": null,
+    "impactor_density": null,
+    "mass_ratio": "dimensionless",
+    "theta_phi": "degree"
+  },
+  "license": "MIT",
+  "doi": null,
+  "creators": [
+    "Anonymous Authors"
+  ],
+  "source_model": {
+    "name": "2020 Nissan Rogue finite-element model",
+    "developer": "CCSA, George Mason University",
+    "sponsor": "NHTSA",
+    "exact_version": "not specified in release",
+    "official_page": "https://www.ccsa.gmu.edu/models/2020-nissan-rogue/"
+  },
+  "geometry_metadata": {
+    "floorfrontdriver": "floorfrontdriver_geometry.json",
+    "floorfrontR": "floorfrontR_geometry.json",
+    "trunkfloor": "trunkfloor_geometry.json"
+  }
+}

metadata/floorfrontR_DATA_NOTE.md

@@ -0,0 +1,24 @@
+# floorfrontR data-quality note
+
+The only valid floorfrontR revision in this release is:
+
+```text
+review_release_v1
+```
+
+Fifty-eight source cases in an earlier internal build exhibited degenerate
+von Mises effective-stress frames. Those cases were rebuilt from the solver
+outputs, after which all 500 compact 17-state cases were audited.
+
+Release requirements:
+
+- all 500 source and released cases must be finite and match the fixed mesh;
+- displacement and von Mises effective-stress tensors must each contain 17 aligned states;
+- every non-initial source stress frame must satisfy dominant-value fraction
+  at most `0.01` and unique-value fraction at least `0.9`;
+- earlier internal `floorfrontR` cases, normalization, checkpoints, and metrics
+  are obsolete and are not part of this release.
+
+The internal final source audit contained no invalid case rows. The public
+release validator independently checks the released compact tensors but cannot
+recreate a solver-source semantic audit without the omitted solver databases.

metadata/floorfrontR_geometry.json

@@ -0,0 +1,111 @@
+{
+  "geometry": "floorfrontR",
+  "data_revision": "review_release_v1",
+  "cases": 500,
+  "states_per_case": 17,
+  "displacement_shape_per_case": [
+    12011,
+    17,
+    3
+  ],
+  "effective_stress_shape_per_case": [
+    12055,
+    17
+  ],
+  "effective_stress_definition": {
+    "quantity": "von_mises_effective_stress",
+    "entity": "shell_element",
+    "through_thickness_reduction": "max_integration_point",
+    "ls_prepost_component": "etime 9",
+    "ls_prepost_label": "Effective Stress (v-m), ip#max",
+    "integration_point_index_retained": false,
+    "units": "MPa"
+  },
+  "mesh": {
+    "file": "meshes/floorfrontR_mesh.npz",
+    "nodes": 12011,
+    "directed_graph_edges": 48138,
+    "shell_elements": 12055,
+    "shell_triangles": 576,
+    "shell_quads": 11479,
+    "boundary_nodes": 494
+  },
+  "time_value_range": [
+    0.0,
+    0.03000050224363804
+  ],
+  "condition_ranges": {
+    "impact_x": [
+      -2723.712646484375,
+      -1657.7757568359375
+    ],
+    "impact_y": [
+      -614.1250610351562,
+      -202.4583740234375
+    ],
+    "impact_z": [
+      285.6304931640625,
+      320.30462646484375
+    ],
+    "velocity_x": [
+      -1103.33740234375,
+      1124.4693603515625
+    ],
+    "velocity_y": [
+      -1064.432373046875,
+      1170.837890625
+    ],
+    "velocity_z": [
+      1696.9781494140625,
+      5178.09375
+    ],
+    "impact_speed": [
+      1736.44091796875,
+      5193.4033203125
+    ],
+    "mass_ratio": [
+      0.7503408193588257,
+      1.2490949630737305
+    ],
+    "impactor_mass": [
+      0.007503408472985029,
+      0.012490949593484402
+    ],
+    "impactor_density": [
+      3.905524135916494e-05,
+      6.50153961032629e-05
+    ],
+    "theta_deg": [
+      0.0070020100101828575,
+      14.971134185791016
+    ],
+    "phi_deg": [
+      0.1686650961637497,
+      359.6947326660156
+    ],
+    "material_young_mpa": [
+      70000.0,
+      210000.0
+    ],
+    "material_poisson": [
+      0.30000001192092896,
+      0.3400000035762787
+    ],
+    "material_index": [
+      0,
+      2
+    ]
+  },
+  "material_counts": {
+    "aluminum_rigid": 166,
+    "steel_rigid": 167,
+    "titanium_rigid": 167
+  },
+  "units": {
+    "status": "NOT_SPECIFIED_IN_RELEASE",
+    "effective_stress": "MPa",
+    "material_young_field_name": "material_young_mpa",
+    "angles": "degrees"
+  },
+  "case_file_policy": "original compact 17-state .pt bytes preserved"
+}

metadata/floorfrontR_peak_normalization.json

@@ -0,0 +1,42 @@
+{
+  "geometry": "floorfrontR",
+  "split": "train",
+  "train_cases": 400,
+  "target_scale_definition": "training-split RMS of peak-state x/y/z displacement and same-state max-IP von Mises effective stress",
+  "target_feature_names": [
+    "disp_x",
+    "disp_y",
+    "disp_z",
+    "effective_stress"
+  ],
+  "target_scale": [
+    0.15814628202903228,
+    0.43806964477173826,
+    7.464683794852748,
+    148.31607344636922
+  ],
+  "condition_feature_names": [
+    "velocity_x",
+    "velocity_y",
+    "velocity_z",
+    "mass_ratio",
+    "material_young_mpa",
+    "material_poisson"
+  ],
+  "condition_mean": [
+    0.10280021738260985,
+    8.576476227547973,
+    3401.6078103637697,
+    1.0001993896067143,
+    128400.0,
+    0.32380000948905946
+  ],
+  "condition_std_sample": [
+    385.1982072101155,
+    383.60519572238866,
+    986.7598245734322,
+    0.14554607292369684,
+    58429.230162165906,
+    0.01686032590358658
+  ]
+}

metadata/floorfrontdriver_geometry.json

@@ -0,0 +1,111 @@
+{
+  "geometry": "floorfrontdriver",
+  "data_revision": "review_release_v1",
+  "cases": 500,
+  "states_per_case": 17,
+  "displacement_shape_per_case": [
+    7408,
+    17,
+    3
+  ],
+  "effective_stress_shape_per_case": [
+    7374,
+    17
+  ],
+  "effective_stress_definition": {
+    "quantity": "von_mises_effective_stress",
+    "entity": "shell_element",
+    "through_thickness_reduction": "max_integration_point",
+    "ls_prepost_component": "etime 9",
+    "ls_prepost_label": "Effective Stress (v-m), ip#max",
+    "integration_point_index_retained": false,
+    "units": "MPa"
+  },
+  "mesh": {
+    "file": "meshes/floorfrontdriver_mesh.npz",
+    "nodes": 7408,
+    "directed_graph_edges": 29572,
+    "shell_elements": 7374,
+    "shell_triangles": 341,
+    "shell_quads": 7033,
+    "boundary_nodes": 416
+  },
+  "time_value_range": [
+    0.0,
+    0.030000703409314156
+  ],
+  "condition_ranges": {
+    "impact_x": [
+      -2724.6455078125,
+      -1656.1412353515625
+    ],
+    "impact_y": [
+      224.04954528808594,
+      612.4707641601562
+    ],
+    "impact_z": [
+      284.037841796875,
+      321.5826110839844
+    ],
+    "velocity_x": [
+      -1207.6029052734375,
+      1239.7603759765625
+    ],
+    "velocity_y": [
+      -1189.7738037109375,
+      1136.3560791015625
+    ],
+    "velocity_z": [
+      1718.663818359375,
+      5186.32568359375
+    ],
+    "impact_speed": [
+      1741.2091064453125,
+      5195.2529296875
+    ],
+    "mass_ratio": [
+      0.7512320280075073,
+      1.2494629621505737
+    ],
+    "impactor_mass": [
+      0.007512320298701525,
+      0.012494630180299282
+    ],
+    "impactor_density": [
+      3.910162558895536e-05,
+      6.503454642370343e-05
+    ],
+    "theta_deg": [
+      7.669999831705354e-06,
+      14.99563217163086
+    ],
+    "phi_deg": [
+      0.1986832469701767,
+      359.6679382324219
+    ],
+    "material_young_mpa": [
+      70000.0,
+      210000.0
+    ],
+    "material_poisson": [
+      0.30000001192092896,
+      0.3400000035762787
+    ],
+    "material_index": [
+      0,
+      2
+    ]
+  },
+  "material_counts": {
+    "aluminum_rigid": 167,
+    "steel_rigid": 166,
+    "titanium_rigid": 167
+  },
+  "units": {
+    "status": "NOT_SPECIFIED_IN_RELEASE",
+    "effective_stress": "MPa",
+    "material_young_field_name": "material_young_mpa",
+    "angles": "degrees"
+  },
+  "case_file_policy": "original compact 17-state .pt bytes preserved"
+}

metadata/floorfrontdriver_peak_normalization.json

@@ -0,0 +1,42 @@
+{
+  "geometry": "floorfrontdriver",
+  "split": "train",
+  "train_cases": 400,
+  "target_scale_definition": "training-split RMS of peak-state x/y/z displacement and same-state max-IP von Mises effective stress",
+  "target_feature_names": [
+    "disp_x",
+    "disp_y",
+    "disp_z",
+    "effective_stress"
+  ],
+  "target_scale": [
+    0.13040709647874055,
+    0.4080695564143727,
+    5.966413782889742,
+    146.48513834118916
+  ],
+  "condition_feature_names": [
+    "velocity_x",
+    "velocity_y",
+    "velocity_z",
+    "mass_ratio",
+    "material_young_mpa",
+    "material_poisson"
+  ],
+  "condition_mean": [
+    -7.210305147669278,
+    1.9799741742014885,
+    3442.1292193603517,
+    1.0024085031449794,
+    128350.0,
+    0.32362500958144663
+  ],
+  "condition_std_sample": [
+    387.55994778420586,
+    389.0490350166509,
+    998.7367338294406,
+    0.14457798511892794,
+    58761.465046713114,
+    0.016832040400886327
+  ]
+}

metadata/split_400_50_50_seed12345.json

@@ -0,0 +1,508 @@
+{
+  "train": [
+    "case237",
+    "case059",
+    "case126",
+    "case017",
+    "case401",
+    "case459",
+    "case326",
+    "case194",
+    "case112",
+    "case402",
+    "case197",
+    "case239",
+    "case209",
+    "case270",
+    "case069",
+    "case435",
+    "case116",
+    "case127",
+    "case456",
+    "case046",
+    "case315",
+    "case241",
+    "case323",
+    "case221",
+    "case350",
+    "case249",
+    "case156",
+    "case493",
+    "case417",
+    "case347",
+    "case458",
+    "case485",
+    "case373",
+    "case301",
+    "case049",
+    "case491",
+    "case289",
+    "case087",
+    "case450",
+    "case361",
+    "case144",
+    "case469",
+    "case164",
+    "case044",
+    "case078",
+    "case129",
+    "case163",
+    "case299",
+    "case138",
+    "case486",
+    "case463",
+    "case287",
+    "case461",
+    "case103",
+    "case360",
+    "case115",
+    "case093",
+    "case397",
+    "case133",
+    "case102",
+    "case075",
+    "case038",
+    "case476",
+    "case020",
+    "case003",
+    "case345",
+    "case071",
+    "case027",
+    "case183",
+    "case244",
+    "case178",
+    "case122",
+    "case226",
+    "case441",
+    "case440",
+    "case124",
+    "case271",
+    "case234",
+    "case274",
+    "case231",
+    "case184",
+    "case036",
+    "case114",
+    "case001",
+    "case181",
+    "case495",
+    "case474",
+    "case074",
+    "case462",
+    "case487",
+    "case251",
+    "case028",
+    "case408",
+    "case157",
+    "case418",
+    "case243",
+    "case341",
+    "case264",
+    "case356",
+    "case152",
+    "case454",
+    "case250",
+    "case443",
+    "case318",
+    "case110",
+    "case484",
+    "case123",
+    "case195",
+    "case048",
+    "case240",
+    "case307",
+    "case066",
+    "case309",
+    "case280",
+    "case457",
+    "case308",
+    "case108",
+    "case385",
+    "case171",
+    "case205",
+    "case218",
+    "case131",
+    "case381",
+    "case188",
+    "case257",
+    "case089",
+    "case268",
+    "case439",
+    "case159",
+    "case058",
+    "case072",
+    "case143",
+    "case061",
+    "case068",
+    "case161",
+    "case379",
+    "case018",
+    "case316",
+    "case344",
+    "case211",
+    "case117",
+    "case225",
+    "case437",
+    "case400",
+    "case142",
+    "case217",
+    "case353",
+    "case168",
+    "case455",
+    "case352",
+    "case099",
+    "case202",
+    "case362",
+    "case260",
+    "case374",
+    "case248",
+    "case273",
+    "case185",
+    "case325",
+    "case430",
+    "case342",
+    "case324",
+    "case297",
+    "case295",
+    "case334",
+    "case242",
+    "case045",
+    "case480",
+    "case303",
+    "case305",
+    "case233",
+    "case029",
+    "case310",
+    "case015",
+    "case366",
+    "case145",
+    "case421",
+    "case033",
+    "case355",
+    "case432",
+    "case399",
+    "case186",
+    "case012",
+    "case398",
+    "case121",
+    "case238",
+    "case405",
+    "case494",
+    "case479",
+    "case489",
+    "case173",
+    "case331",
+    "case317",
+    "case419",
+    "case311",
+    "case425",
+    "case396",
+    "case278",
+    "case467",
+    "case403",
+    "case255",
+    "case201",
+    "case196",
+    "case207",
+    "case357",
+    "case227",
+    "case151",
+    "case232",
+    "case304",
+    "case200",
+    "case283",
+    "case135",
+    "case359",
+    "case426",
+    "case130",
+    "case292",
+    "case054",
+    "case281",
+    "case025",
+    "case024",
+    "case220",
+    "case010",
+    "case073",
+    "case190",
+    "case428",
+    "case328",
+    "case137",
+    "case146",
+    "case409",
+    "case053",
+    "case149",
+    "case245",
+    "case336",
+    "case372",
+    "case320",
+    "case011",
+    "case482",
+    "case082",
+    "case101",
+    "case088",
+    "case330",
+    "case009",
+    "case413",
+    "case030",
+    "case261",
+    "case447",
+    "case052",
+    "case109",
+    "case465",
+    "case060",
+    "case079",
+    "case210",
+    "case037",
+    "case258",
+    "case042",
+    "case460",
+    "case215",
+    "case424",
+    "case488",
+    "case406",
+    "case039",
+    "case390",
+    "case162",
+    "case154",
+    "case107",
+    "case179",
+    "case140",
+    "case384",
+    "case472",
+    "case204",
+    "case097",
+    "case057",
+    "case279",
+    "case043",
+    "case436",
+    "case477",
+    "case177",
+    "case113",
+    "case016",
+    "case229",
+    "case286",
+    "case444",
+    "case246",
+    "case253",
+    "case160",
+    "case415",
+    "case230",
+    "case158",
+    "case206",
+    "case386",
+    "case392",
+    "case141",
+    "case019",
+    "case333",
+    "case080",
+    "case380",
+    "case056",
+    "case294",
+    "case275",
+    "case265",
+    "case370",
+    "case023",
+    "case219",
+    "case481",
+    "case031",
+    "case452",
+    "case451",
+    "case065",
+    "case150",
+    "case291",
+    "case332",
+    "case431",
+    "case470",
+    "case070",
+    "case371",
+    "case327",
+    "case490",
+    "case339",
+    "case035",
+    "case367",
+    "case375",
+    "case338",
+    "case383",
+    "case468",
+    "case128",
+    "case410",
+    "case293",
+    "case329",
+    "case389",
+    "case203",
+    "case091",
+    "case170",
+    "case191",
+    "case453",
+    "case346",
+    "case125",
+    "case434",
+    "case500",
+    "case236",
+    "case034",
+    "case208",
+    "case466",
+    "case136",
+    "case050",
+    "case312",
+    "case095",
+    "case363",
+    "case337",
+    "case351",
+    "case464",
+    "case483",
+    "case267",
+    "case471",
+    "case276",
+    "case387",
+    "case148",
+    "case368",
+    "case445",
+    "case105",
+    "case427",
+    "case172",
+    "case407",
+    "case254",
+    "case391",
+    "case404",
+    "case416",
+    "case422",
+    "case358",
+    "case446",
+    "case187",
+    "case104",
+    "case282",
+    "case216",
+    "case313",
+    "case167",
+    "case252",
+    "case321",
+    "case008",
+    "case394",
+    "case319",
+    "case247",
+    "case063",
+    "case263",
+    "case348",
+    "case497",
+    "case492",
+    "case393",
+    "case498",
+    "case442",
+    "case199",
+    "case041",
+    "case228",
+    "case365",
+    "case032",
+    "case026",
+    "case007",
+    "case166",
+    "case198",
+    "case081",
+    "case176"
+  ],
+  "val": [
+    "case277",
+    "case180",
+    "case118",
+    "case077",
+    "case005",
+    "case155",
+    "case085",
+    "case022",
+    "case067",
+    "case266",
+    "case223",
+    "case302",
+    "case132",
+    "case475",
+    "case343",
+    "case285",
+    "case388",
+    "case411",
+    "case433",
+    "case111",
+    "case256",
+    "case062",
+    "case119",
+    "case021",
+    "case414",
+    "case169",
+    "case496",
+    "case364",
+    "case306",
+    "case269",
+    "case120",
+    "case193",
+    "case473",
+    "case094",
+    "case296",
+    "case349",
+    "case055",
+    "case449",
+    "case335",
+    "case051",
+    "case147",
+    "case092",
+    "case298",
+    "case395",
+    "case084",
+    "case340",
+    "case004",
+    "case002",
+    "case213",
+    "case382"
+  ],
+  "test": [
+    "case354",
+    "case262",
+    "case014",
+    "case174",
+    "case235",
+    "case013",
+    "case165",
+    "case175",
+    "case429",
+    "case098",
+    "case040",
+    "case369",
+    "case106",
+    "case076",
+    "case086",
+    "case259",
+    "case300",
+    "case212",
+    "case377",
+    "case272",
+    "case047",
+    "case499",
+    "case378",
+    "case182",
+    "case096",
+    "case284",
+    "case314",
+    "case090",
+    "case322",
+    "case288",
+    "case134",
+    "case222",
+    "case448",
+    "case064",
+    "case192",
+    "case083",
+    "case224",
+    "case290",
+    "case139",
+    "case100",
+    "case478",
+    "case189",
+    "case438",
+    "case153",
+    "case412",
+    "case423",
+    "case420",
+    "case006",
+    "case376",
+    "case214"
+  ]
+}

metadata/trunkfloor_geometry.json

@@ -0,0 +1,111 @@
+{
+  "geometry": "trunkfloor",
+  "data_revision": "review_release_v1",
+  "cases": 500,
+  "states_per_case": 17,
+  "displacement_shape_per_case": [
+    14440,
+    17,
+    3
+  ],
+  "effective_stress_shape_per_case": [
+    14589,
+    17
+  ],
+  "effective_stress_definition": {
+    "quantity": "von_mises_effective_stress",
+    "entity": "shell_element",
+    "through_thickness_reduction": "max_integration_point",
+    "ls_prepost_component": "etime 9",
+    "ls_prepost_label": "Effective Stress (v-m), ip#max",
+    "integration_point_index_retained": false,
+    "units": "MPa"
+  },
+  "mesh": {
+    "file": "meshes/trunkfloor_mesh.npz",
+    "nodes": 14440,
+    "directed_graph_edges": 58074,
+    "shell_elements": 14589,
+    "shell_triangles": 817,
+    "shell_quads": 13772,
+    "boundary_nodes": 535
+  },
+  "time_value_range": [
+    0.0,
+    0.030000614002346992
+  ],
+  "condition_ranges": {
+    "impact_x": [
+      -4327.884765625,
+      -3648.72900390625
+    ],
+    "impact_y": [
+      -406.519287109375,
+      430.65777587890625
+    ],
+    "impact_z": [
+      486.412841796875,
+      649.58642578125
+    ],
+    "velocity_x": [
+      -1266.122802734375,
+      1200.008056640625
+    ],
+    "velocity_y": [
+      -1262.4493408203125,
+      1177.8699951171875
+    ],
+    "velocity_z": [
+      1711.5562744140625,
+      5177.33935546875
+    ],
+    "impact_speed": [
+      1738.4505615234375,
+      5195.92578125
+    ],
+    "mass_ratio": [
+      0.7506378889083862,
+      1.2490675449371338
+    ],
+    "impactor_mass": [
+      0.007506378460675478,
+      0.012490675784647465
+    ],
+    "impactor_density": [
+      3.907069913111627e-05,
+      6.501397001557052e-05
+    ],
+    "theta_deg": [
+      0.0015588899841532111,
+      14.979633331298828
+    ],
+    "phi_deg": [
+      0.16448494791984558,
+      359.7947998046875
+    ],
+    "material_young_mpa": [
+      70000.0,
+      210000.0
+    ],
+    "material_poisson": [
+      0.30000001192092896,
+      0.3400000035762787
+    ],
+    "material_index": [
+      0,
+      2
+    ]
+  },
+  "material_counts": {
+    "aluminum_rigid": 166,
+    "steel_rigid": 167,
+    "titanium_rigid": 167
+  },
+  "units": {
+    "status": "NOT_SPECIFIED_IN_RELEASE",
+    "effective_stress": "MPa",
+    "material_young_field_name": "material_young_mpa",
+    "angles": "degrees"
+  },
+  "case_file_policy": "original compact 17-state .pt bytes preserved"
+}

metadata/trunkfloor_peak_normalization.json

@@ -0,0 +1,42 @@
+{
+  "geometry": "trunkfloor",
+  "split": "train",
+  "train_cases": 400,
+  "target_scale_definition": "training-split RMS of peak-state x/y/z displacement and same-state max-IP von Mises effective stress",
+  "target_feature_names": [
+    "disp_x",
+    "disp_y",
+    "disp_z",
+    "effective_stress"
+  ],
+  "target_scale": [
+    0.38916057493977263,
+    0.5722944758869976,
+    2.9555388177868207,
+    125.25171014391293
+  ],
+  "condition_feature_names": [
+    "velocity_x",
+    "velocity_y",
+    "velocity_z",
+    "mass_ratio",
+    "material_young_mpa",
+    "material_poisson"
+  ],
+  "condition_mean": [
+    16.704457361306996,
+    -16.622224624343218,
+    3432.0224798583986,
+    1.0026446332037449,
+    131650.0,
+    0.322825009599328
+  ],
+  "condition_std_sample": [
+    390.0118052305684,
+    387.24305428075985,
+    994.8323301706797,
+    0.14387643358676566,
+    59490.5481003765,
+    0.01716116404336039
+  ]
+}

release_inventory.json

@@ -0,0 +1,69 @@
+{
+  "dataset": "Automotive Impact Dataset",
+  "version": "1.0.0",
+  "case_files": 1500,
+  "archive_files": 15,
+  "archive_bytes": 5032143218,
+  "archives": [
+    {
+      "path": "data/floorfrontR/cases_001_100.zip",
+      "bytes": 356790322
+    },
+    {
+      "path": "data/floorfrontR/cases_101_200.zip",
+      "bytes": 356790322
+    },
+    {
+      "path": "data/floorfrontR/cases_201_300.zip",
+      "bytes": 356790322
+    },
+    {
+      "path": "data/floorfrontR/cases_301_400.zip",
+      "bytes": 356790322
+    },
+    {
+      "path": "data/floorfrontR/cases_401_500.zip",
+      "bytes": 356790322
+    },
+    {
+      "path": "data/floorfrontdriver/cases_001_100.zip",
+      "bytes": 219951922
+    },
+    {
+      "path": "data/floorfrontdriver/cases_101_200.zip",
+      "bytes": 219951922
+    },
+    {
+      "path": "data/floorfrontdriver/cases_201_300.zip",
+      "bytes": 219951922
+    },
+    {
+      "path": "data/floorfrontdriver/cases_301_400.zip",
+      "bytes": 219951922
+    },
+    {
+      "path": "data/floorfrontdriver/cases_401_500.zip",
+      "bytes": 219951922
+    },
+    {
+      "path": "data/trunkfloor/cases_001_100.zip",
+      "bytes": 429487922
+    },
+    {
+      "path": "data/trunkfloor/cases_101_200.zip",
+      "bytes": 429487922
+    },
+    {
+      "path": "data/trunkfloor/cases_201_300.zip",
+      "bytes": 429487922
+    },
+    {
+      "path": "data/trunkfloor/cases_301_400.zip",
+      "bytes": 430480310
+    },
+    {
+      "path": "data/trunkfloor/cases_401_500.zip",
+      "bytes": 429487922
+    }
+  ]
+}

requirements.txt

@@ -0,0 +1,4 @@
+numpy>=1.24
+torch>=2.6
+matplotlib>=3.7
+

schema.json

@@ -0,0 +1,70 @@
+{
+  "schema_version": "1.0.0",
+  "case_format": "PyTorch serialized plain dictionary",
+  "recommended_load": "torch.load(file, map_location='cpu', weights_only=True)",
+  "state_count": 17,
+  "case_fields": {
+    "case": {"type": "string", "description": "caseNNN identifier"},
+    "panel_pid": {"dtype": "int64", "shape": []},
+    "nid": {"dtype": "int64", "shape": ["N"]},
+    "boundary_mask": {"dtype": "bool", "shape": ["N"]},
+    "valid_node_mask": {"dtype": "bool", "shape": ["N"]},
+    "raw_valid_node_mask": {"dtype": "bool", "shape": ["N"]},
+    "filled_node_mask": {"dtype": "bool", "shape": ["N"]},
+    "filled_node_count": {"dtype": "int64", "shape": []},
+    "time": {"dtype": "float32", "shape": [17]},
+    "time_indices": {"dtype": "int64", "shape": [17]},
+    "disp": {"dtype": "float32", "shape": ["N", 17, 3]},
+    "element_time": {"dtype": "float32", "shape": [17]},
+    "element_time_indices": {"dtype": "int64", "shape": [17]},
+    "element_id": {"dtype": "int64", "shape": ["Ne"]},
+    "repaired_element_ids": {"dtype": "int64", "shape": "variable"},
+    "effective_stress": {
+      "dtype": "float32",
+      "shape": ["Ne", 17],
+      "quantity": "von_mises_effective_stress",
+      "entity": "shell_element",
+      "through_thickness_reduction": "max_integration_point",
+      "ls_prepost_component": "etime 9",
+      "ls_prepost_label": "Effective Stress (v-m), ip#max",
+      "integration_point_index_retained": false,
+      "units": "MPa"
+    },
+    "velocity_vz": {"dtype": "float32", "shape": []},
+    "velocity_xyz": {"dtype": "float32", "shape": [3]},
+    "impact_speed": {"dtype": "float32", "shape": []},
+    "impact_xyz": {"dtype": "float32", "shape": [3]},
+    "impact_node_distance": {"dtype": "float32", "shape": ["N"]},
+    "ball_center_xyz": {"dtype": "float32", "shape": [3]},
+    "impact_element_id": {"dtype": "int64", "shape": []},
+    "mass_ratio": {"dtype": "float32", "shape": []},
+    "impactor_mass": {"dtype": "float32", "shape": []},
+    "impactor_density": {"dtype": "float32", "shape": []},
+    "theta_deg": {"dtype": "float32", "shape": []},
+    "phi_deg": {"dtype": "float32", "shape": []},
+    "material_young_mpa": {"dtype": "float32", "shape": []},
+    "material_poisson": {"dtype": "float32", "shape": []},
+    "material_index": {"dtype": "int64", "shape": []},
+    "material_one_hot": {"dtype": "float32", "shape": [3]},
+    "material_name": {"type": "string"},
+    "condition_names": {"type": "list[string]", "length": 7},
+    "condition_vector": {"dtype": "float32", "shape": [7]}
+  },
+  "mesh_fields": {
+    "node_pos": {"dtype": "float32", "shape": ["N", 3]},
+    "edge_index": {"dtype": "int64", "shape": [2, "E"]},
+    "element_node_index": {"dtype": "int64", "shape": ["Ne", 4], "padding": "The third node index is repeated in column four for triangular shells"},
+    "element_node_count": {"dtype": "int64", "shape": ["Ne"], "values": [3, 4]},
+    "boundary_mask": {"dtype": "bool", "shape": ["N"]}
+  },
+  "geometry_shapes": {
+    "floorfrontdriver": {"N": 7408, "E": 29572, "Ne": 7374},
+    "floorfrontR": {"N": 12011, "E": 48138, "Ne": 12055},
+    "trunkfloor": {"N": 14440, "E": 58074, "Ne": 14589}
+  },
+  "units": {
+    "status": "NOT_SPECIFIED_IN_RELEASE",
+    "effective_stress": "MPa",
+    "warning": "Do not infer units from numeric magnitudes; only explicitly named units are defined."
+  }
+}

scripts/build_peak_targets.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""Derive displacement-peak snapshots from the released 17-state trajectories."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import shutil
+from pathlib import Path
+
+import torch
+
+from load_case import canonical_case_id, canonical_geometry, load_case, load_split
+
+
+def select_peak(data: dict) -> tuple[int, int, torch.Tensor, torch.Tensor]:
+    displacement = data["disp"].to(torch.float32)
+    stress = data["effective_stress"].to(torch.float32)
+    valid = data["valid_node_mask"].to(torch.bool)
+    if displacement.ndim != 3 or displacement.shape[1:] != (17, 3):
+        raise ValueError(f"invalid displacement shape: {tuple(displacement.shape)}")
+    if stress.ndim != 2 or stress.shape[1] != 17:
+        raise ValueError(f"invalid effective-stress shape: {tuple(stress.shape)}")
+    magnitude = torch.linalg.vector_norm(displacement, dim=-1)
+    magnitude = magnitude.masked_fill(~valid[:, None], float("-inf"))
+    flat_index = int(torch.argmax(magnitude).item())
+    time_index = flat_index % displacement.shape[1]
+    node_index = flat_index // displacement.shape[1]
+    return (
+        time_index,
+        node_index,
+        displacement[:, time_index, :].contiguous(),
+        stress[:, time_index].contiguous(),
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dataset-root", type=Path, default=Path("."))
+    parser.add_argument("--geometry", required=True)
+    parser.add_argument("--output-root", type=Path, required=True)
+    parser.add_argument(
+        "--cases",
+        nargs="*",
+        help="Optional case identifiers; default is all 500 cases.",
+    )
+    args = parser.parse_args()
+
+    geometry = canonical_geometry(args.geometry)
+    case_ids = (
+        [canonical_case_id(case) for case in args.cases]
+        if args.cases
+        else [f"case{index:03d}" for index in range(1, 501)]
+    )
+    output_cases = args.output_root / "cases"
+    output_cases.mkdir(parents=True, exist_ok=True)
+
+    rows = []
+    for offset, case_id in enumerate(case_ids, start=1):
+        data = load_case(args.dataset_root, geometry, case_id)
+        time_index, node_index, displacement, stress = select_peak(data)
+        peak = {
+            "case": case_id,
+            "selected_time_index": torch.tensor(time_index, dtype=torch.int64),
+            "selected_time": data["time"][time_index].to(torch.float32),
+            "disp_peak_value": torch.linalg.vector_norm(
+                displacement[node_index]
+            ).to(torch.float32),
+            "disp_peak_node_index": torch.tensor(node_index, dtype=torch.int64),
+            "disp": displacement,
+            "element_results": {"effective_stress": stress},
+        }
+        for key in (
+            "impact_xyz",
+            "velocity_xyz",
+            "mass_ratio",
+            "material_young_mpa",
+            "material_poisson",
+            "boundary_mask",
+            "valid_node_mask",
+        ):
+            peak[key] = data[key]
+        torch.save(peak, output_cases / f"{case_id}.pt")
+        rows.append(
+            {
+                "case": case_id,
+                "selected_time_index": time_index,
+                "selected_time": float(data["time"][time_index]),
+                "disp_peak_node_index": node_index,
+                "disp_peak_value": float(peak["disp_peak_value"]),
+            }
+        )
+        if offset % 50 == 0 or offset == len(case_ids):
+            print(f"[{geometry}] derived {offset}/{len(case_ids)}")
+
+    with (args.output_root / "disp_peak_summary.csv").open(
+        "w", encoding="utf-8", newline=""
+    ) as handle:
+        writer = csv.DictWriter(handle, fieldnames=list(rows[0]))
+        writer.writeheader()
+        writer.writerows(rows)
+
+    split = load_split(args.dataset_root)
+    (args.output_root / "split_400_50_50_seed12345.json").write_text(
+        json.dumps(split, indent=2) + "\n", encoding="utf-8"
+    )
+    source_mesh = (
+        args.dataset_root / "meshes" / f"{geometry}_mesh.npz"
+    )
+    shutil.copy2(source_mesh, args.output_root / "mesh.npz")
+
+
+if __name__ == "__main__":
+    main()
+

scripts/compute_train_normalization.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""Compute paper-protocol peak-field normalization from training cases only."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import torch
+
+from build_peak_targets import select_peak
+from load_case import canonical_geometry, load_case, load_split
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dataset-root", type=Path, default=Path("."))
+    parser.add_argument("--geometry", required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+
+    geometry = canonical_geometry(args.geometry)
+    train_cases = load_split(args.dataset_root)["train"]
+    target_sum_sq = torch.zeros(4, dtype=torch.float64)
+    target_count = torch.zeros(4, dtype=torch.int64)
+    condition_rows = []
+
+    for offset, case_id in enumerate(train_cases, start=1):
+        data = load_case(args.dataset_root, geometry, case_id)
+        _, _, displacement, stress = select_peak(data)
+        for component in range(3):
+            values = displacement[:, component].to(torch.float64)
+            target_sum_sq[component] += torch.sum(values.square())
+            target_count[component] += values.numel()
+        stress64 = stress.to(torch.float64)
+        target_sum_sq[3] += torch.sum(stress64.square())
+        target_count[3] += stress64.numel()
+        condition_rows.append(
+            torch.cat(
+                (
+                    data["velocity_xyz"].to(torch.float64).reshape(3),
+                    data["mass_ratio"].to(torch.float64).reshape(1),
+                    data["material_young_mpa"].to(torch.float64).reshape(1),
+                    data["material_poisson"].to(torch.float64).reshape(1),
+                )
+            )
+        )
+        if offset % 50 == 0:
+            print(f"[{geometry}] normalization {offset}/{len(train_cases)}")
+
+    scale = torch.sqrt(target_sum_sq / target_count)
+    conditions = torch.stack(condition_rows)
+    payload = {
+        "geometry": geometry,
+        "split": "train",
+        "train_cases": len(train_cases),
+        "target_scale_definition": (
+            "training-split RMS of peak-state x/y/z displacement and "
+            "same-state max-IP von Mises effective stress"
+        ),
+        "target_feature_names": ["disp_x", "disp_y", "disp_z", "effective_stress"],
+        "target_scale": scale.tolist(),
+        "condition_feature_names": [
+            "velocity_x",
+            "velocity_y",
+            "velocity_z",
+            "mass_ratio",
+            "material_young_mpa",
+            "material_poisson",
+        ],
+        "condition_mean": conditions.mean(dim=0).tolist(),
+        "condition_std_sample": conditions.std(dim=0, unbiased=True).tolist(),
+    }
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(payload, indent=2))
+
+
+if __name__ == "__main__":
+    main()

scripts/load_case.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""Load automotive-impact cases from extracted files or ZIP shards."""
+
+from __future__ import annotations
+
+import argparse
+import io
+import json
+import zipfile
+from pathlib import Path
+
+import numpy as np
+import torch
+
+
+GEOMETRY_ALIASES = {
+    "floorfrontdriver": "floorfrontdriver",
+    "driver": "floorfrontdriver",
+    "floorfrontr": "floorfrontR",
+    "floorfrontR": "floorfrontR",
+    "trunk": "trunkfloor",
+    "trunkfloor": "trunkfloor",
+}
+
+
+def canonical_geometry(name: str) -> str:
+    if name in GEOMETRY_ALIASES:
+        return GEOMETRY_ALIASES[name]
+    lowered = name.lower()
+    if lowered in GEOMETRY_ALIASES:
+        return GEOMETRY_ALIASES[lowered]
+    choices = ", ".join(sorted(set(GEOMETRY_ALIASES.values())))
+    raise ValueError(f"unknown geometry {name!r}; choose one of {choices}")
+
+
+def canonical_case_id(value: str | int) -> str:
+    if isinstance(value, int):
+        number = value
+    else:
+        text = str(value).strip()
+        if text.lower().endswith(".pt"):
+            text = text[:-3]
+        if text.lower().startswith("case"):
+            text = text[4:]
+        number = int(text)
+    if not 1 <= number <= 500:
+        raise ValueError(f"case number must be in [1,500], got {number}")
+    return f"case{number:03d}"
+
+
+def shard_name(case_id: str) -> str:
+    number = int(case_id[4:])
+    start = ((number - 1) // 100) * 100 + 1
+    end = start + 99
+    return f"cases_{start:03d}_{end:03d}.zip"
+
+
+def load_case_bytes(dataset_root: Path | str, geometry: str, case_id: str | int) -> bytes:
+    root = Path(dataset_root)
+    geometry = canonical_geometry(geometry)
+    case_id = canonical_case_id(case_id)
+
+    candidates = (
+        root / "data" / geometry / "cases" / f"{case_id}.pt",
+        root / "data" / geometry / f"{case_id}.pt",
+    )
+    for candidate in candidates:
+        if candidate.is_file():
+            return candidate.read_bytes()
+
+    archive = root / "data" / geometry / shard_name(case_id)
+    if not archive.is_file():
+        raise FileNotFoundError(
+            f"case not extracted and shard is missing: {archive}"
+        )
+    member = f"cases/{case_id}.pt"
+    with zipfile.ZipFile(archive) as handle:
+        try:
+            return handle.read(member)
+        except KeyError as exc:
+            raise FileNotFoundError(f"{member} is missing from {archive}") from exc
+
+
+def load_case(dataset_root: Path | str, geometry: str, case_id: str | int) -> dict:
+    payload = load_case_bytes(dataset_root, geometry, case_id)
+    return torch.load(io.BytesIO(payload), map_location="cpu", weights_only=True)
+
+
+def load_mesh(dataset_root: Path | str, geometry: str) -> dict[str, np.ndarray]:
+    root = Path(dataset_root)
+    geometry = canonical_geometry(geometry)
+    path = root / "meshes" / f"{geometry}_mesh.npz"
+    if not path.is_file():
+        raise FileNotFoundError(path)
+    with np.load(path, allow_pickle=False) as archive:
+        return {key: archive[key].copy() for key in archive.files}
+
+
+def load_split(dataset_root: Path | str) -> dict[str, list[str]]:
+    path = Path(dataset_root) / "metadata" / "split_400_50_50_seed12345.json"
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dataset-root", type=Path, default=Path("."))
+    parser.add_argument("--geometry", required=True)
+    parser.add_argument("--case", required=True)
+    args = parser.parse_args()
+
+    geometry = canonical_geometry(args.geometry)
+    case_id = canonical_case_id(args.case)
+    data = load_case(args.dataset_root, geometry, case_id)
+    mesh = load_mesh(args.dataset_root, geometry)
+
+    summary = {
+        "geometry": geometry,
+        "case": data["case"],
+        "disp_shape": list(data["disp"].shape),
+        "effective_stress_shape": list(data["effective_stress"].shape),
+        "time": data["time"].tolist(),
+        "impact_xyz": data["impact_xyz"].tolist(),
+        "velocity_xyz": data["velocity_xyz"].tolist(),
+        "mass_ratio": float(data["mass_ratio"]),
+        "material_young_mpa": float(data["material_young_mpa"]),
+        "material_poisson": float(data["material_poisson"]),
+        "mesh_node_count": int(mesh["node_pos"].shape[0]),
+        "mesh_element_count": int(mesh["element_node_index"].shape[0]),
+    }
+    print(json.dumps(summary, indent=2, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

scripts/validate_dataset.py

@@ -0,0 +1,299 @@
+#!/usr/bin/env python3
+"""Validate the complete automotive-impact release package."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import json
+import sys
+import time
+import zipfile
+from collections import Counter
+from pathlib import Path
+
+import numpy as np
+import torch
+
+from load_case import (
+    canonical_case_id,
+    load_case,
+    load_case_bytes,
+    load_mesh,
+    load_split,
+    shard_name,
+)
+
+
+SPECS = {
+    "floorfrontdriver": {"nodes": 7408, "edges": 29572, "elements": 7374},
+    "floorfrontR": {"nodes": 12011, "edges": 48138, "elements": 12055},
+    "trunkfloor": {"nodes": 14440, "edges": 58074, "elements": 14589},
+}
+
+
+def sha256_bytes(payload: bytes) -> str:
+    return hashlib.sha256(payload).hexdigest()
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(8 * 1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def fail(errors: list[str], message: str) -> None:
+    errors.append(message)
+    print(f"ERROR: {message}", file=sys.stderr)
+
+
+def validate_split(root: Path, errors: list[str]) -> dict:
+    split = load_split(root)
+    expected_sizes = {"train": 400, "val": 50, "test": 50}
+    for name, expected in expected_sizes.items():
+        values = split.get(name)
+        if not isinstance(values, list) or len(values) != expected:
+            fail(errors, f"split {name!r}: expected {expected} entries")
+            continue
+        canonical = [canonical_case_id(value) for value in values]
+        if canonical != values:
+            fail(errors, f"split {name!r} contains non-canonical case IDs")
+        if len(set(values)) != len(values):
+            fail(errors, f"split {name!r} contains duplicates")
+    union = set().union(*(set(split.get(key, [])) for key in expected_sizes))
+    if union != {f"case{index:03d}" for index in range(1, 501)}:
+        fail(errors, "split union is not exactly case001..case500")
+    names = list(expected_sizes)
+    for left_index, left in enumerate(names):
+        for right in names[left_index + 1 :]:
+            if set(split.get(left, [])) & set(split.get(right, [])):
+                fail(errors, f"split overlap: {left} and {right}")
+    return split
+
+
+def validate_mesh(root: Path, geometry: str, spec: dict, errors: list[str]) -> dict:
+    mesh = load_mesh(root, geometry)
+    expected = {
+        "node_pos": (spec["nodes"], 3),
+        "edge_index": (2, spec["edges"]),
+        "element_node_index": (spec["elements"], 4),
+        "element_node_count": (spec["elements"],),
+        "boundary_mask": (spec["nodes"],),
+    }
+    for key, shape in expected.items():
+        if key not in mesh:
+            fail(errors, f"{geometry} mesh missing {key}")
+        elif mesh[key].shape != shape:
+            fail(errors, f"{geometry} mesh {key}: {mesh[key].shape} != {shape}")
+    if "node_pos" in mesh and not np.isfinite(mesh["node_pos"]).all():
+        fail(errors, f"{geometry} mesh node_pos is non-finite")
+    if "edge_index" in mesh:
+        edges = mesh["edge_index"]
+        if edges.min() < 0 or edges.max() >= spec["nodes"]:
+            fail(errors, f"{geometry} edge_index is out of range")
+    if "element_node_index" in mesh:
+        connectivity = mesh["element_node_index"]
+        if connectivity.min() < 0 or connectivity.max() >= spec["nodes"]:
+            fail(errors, f"{geometry} element_node_index is out of range")
+    if "element_node_count" in mesh and not np.isin(
+        mesh["element_node_count"], [3, 4]
+    ).all():
+        fail(errors, f"{geometry} element_node_count contains values outside 3/4")
+    return {
+        "nodes": spec["nodes"],
+        "edges": spec["edges"],
+        "elements": spec["elements"],
+    }
+
+
+def validate_case(
+    root: Path,
+    geometry: str,
+    case_id: str,
+    spec: dict,
+    expected_digest: str | None,
+    errors: list[str],
+) -> dict:
+    payload = load_case_bytes(root, geometry, case_id)
+    digest = sha256_bytes(payload)
+    if expected_digest and digest != expected_digest:
+        fail(errors, f"{geometry}/{case_id}: SHA-256 mismatch")
+    data = torch.load(
+        __import__("io").BytesIO(payload), map_location="cpu", weights_only=True
+    )
+    if data.get("case") != case_id:
+        fail(errors, f"{geometry}/{case_id}: stored case identifier mismatch")
+    expected_shapes = {
+        "disp": (spec["nodes"], 17, 3),
+        "effective_stress": (spec["elements"], 17),
+        "time": (17,),
+        "element_time": (17,),
+        "valid_node_mask": (spec["nodes"],),
+        "boundary_mask": (spec["nodes"],),
+        "impact_xyz": (3,),
+        "velocity_xyz": (3,),
+    }
+    for key, shape in expected_shapes.items():
+        value = data.get(key)
+        if not torch.is_tensor(value) or tuple(value.shape) != shape:
+            actual = None if value is None else getattr(value, "shape", type(value))
+            fail(errors, f"{geometry}/{case_id} {key}: {actual} != {shape}")
+    for key in ("disp", "effective_stress", "time", "element_time"):
+        value = data.get(key)
+        if torch.is_tensor(value) and not torch.isfinite(value).all():
+            fail(errors, f"{geometry}/{case_id}: {key} is non-finite")
+    time_values = data.get("time")
+    element_time = data.get("element_time")
+    if torch.is_tensor(time_values) and time_values.numel() == 17:
+        if not torch.all(time_values[1:] >= time_values[:-1]):
+            fail(errors, f"{geometry}/{case_id}: time is not monotonic")
+    if torch.is_tensor(element_time) and element_time.numel() == 17:
+        if not torch.all(element_time[1:] >= element_time[:-1]):
+            fail(errors, f"{geometry}/{case_id}: element_time is not monotonic")
+    if (
+        torch.is_tensor(time_values)
+        and torch.is_tensor(element_time)
+        and tuple(time_values.shape) == (17,)
+        and tuple(element_time.shape) == (17,)
+        and not torch.allclose(time_values, element_time, rtol=0.0, atol=1.0e-8)
+    ):
+        fail(errors, f"{geometry}/{case_id}: displacement/stress time arrays differ")
+    return {
+        "bytes": len(payload),
+        "sha256": digest,
+        "material": str(data.get("material_name", "")),
+    }
+
+
+def load_manifest(root: Path, errors: list[str]) -> dict[tuple[str, str], dict]:
+    path = root / "manifest.csv"
+    rows = {}
+    with path.open(encoding="utf-8", newline="") as handle:
+        for row in csv.DictReader(handle):
+            key = (row["geometry"], row["case"])
+            if key in rows:
+                fail(errors, f"duplicate manifest row: {key}")
+            rows[key] = row
+    if len(rows) != 1500:
+        fail(errors, f"manifest has {len(rows)} rows, expected 1500")
+    return rows
+
+
+def validate_archives(root: Path, errors: list[str]) -> dict:
+    archive_count = 0
+    total_bytes = 0
+    for geometry in SPECS:
+        for start in range(1, 501, 100):
+            end = start + 99
+            path = root / "data" / geometry / f"cases_{start:03d}_{end:03d}.zip"
+            if not path.is_file():
+                fail(errors, f"missing archive: {path.relative_to(root)}")
+                continue
+            archive_count += 1
+            total_bytes += path.stat().st_size
+            with zipfile.ZipFile(path) as archive:
+                bad_member = archive.testzip()
+                if bad_member:
+                    fail(errors, f"CRC failure in {path.name}: {bad_member}")
+                expected = {
+                    f"cases/case{index:03d}.pt" for index in range(start, end + 1)
+                }
+                if set(archive.namelist()) != expected:
+                    fail(errors, f"unexpected members in {path.relative_to(root)}")
+    return {"archives": archive_count, "archive_bytes": total_bytes}
+
+
+def validate_checksums(root: Path, errors: list[str]) -> dict:
+    path = root / "checksums.sha256"
+    checked = 0
+    with path.open(encoding="utf-8") as handle:
+        for line_number, line in enumerate(handle, start=1):
+            line = line.rstrip("\n")
+            if not line:
+                continue
+            try:
+                expected, relative = line.split("  ", 1)
+            except ValueError:
+                fail(errors, f"invalid checksum line {line_number}")
+                continue
+            target = root / relative
+            if not target.is_file():
+                fail(errors, f"checksummed file missing: {relative}")
+                continue
+            if sha256_file(target) != expected:
+                fail(errors, f"file checksum mismatch: {relative}")
+            checked += 1
+            if target.suffix == ".zip":
+                print(f"[file checksum] {relative}")
+    return {"checked_files": checked}
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dataset-root", type=Path, default=Path("."))
+    parser.add_argument("--verify-checksums", action="store_true")
+    parser.add_argument("--report", type=Path)
+    args = parser.parse_args()
+
+    root = args.dataset_root.resolve()
+    started = time.time()
+    errors: list[str] = []
+    split = validate_split(root, errors)
+    archives = validate_archives(root, errors)
+    manifest = load_manifest(root, errors)
+    geometry_reports = {}
+
+    for geometry, spec in SPECS.items():
+        mesh_report = validate_mesh(root, geometry, spec, errors)
+        materials: Counter[str] = Counter()
+        total_bytes = 0
+        for index in range(1, 501):
+            case_id = f"case{index:03d}"
+            row = manifest.get((geometry, case_id))
+            expected_digest = row["source_sha256"] if row else None
+            case_report = validate_case(
+                root, geometry, case_id, spec, expected_digest, errors
+            )
+            total_bytes += case_report["bytes"]
+            materials[case_report["material"]] += 1
+            if index % 50 == 0:
+                print(f"[{geometry}] validated {index}/500")
+        geometry_reports[geometry] = {
+            **mesh_report,
+            "cases": 500,
+            "source_case_bytes": total_bytes,
+            "materials": dict(sorted(materials.items())),
+        }
+
+    checksum_report = (
+        validate_checksums(root, errors) if args.verify_checksums else {"skipped": True}
+    )
+    report = {
+        "dataset": "Automotive Impact Dataset",
+        "version": "1.0.0",
+        "status": "passed" if not errors else "failed",
+        "cases_validated": 1500,
+        "split_sizes": {key: len(value) for key, value in split.items()},
+        "archives": archives,
+        "geometries": geometry_reports,
+        "checksums": checksum_report,
+        "elapsed_seconds": time.time() - started,
+        "errors": errors,
+        "scope_note": (
+            "Technical package validation only; provenance and unit limitations "
+            "are documented in the release metadata."
+        ),
+    }
+    rendered = json.dumps(report, indent=2, ensure_ascii=False) + "\n"
+    print(rendered)
+    if args.report:
+        args.report.write_text(rendered, encoding="utf-8")
+    if errors:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

scripts/visualize_trajectory.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""Render nodal displacement magnitude and shell von Mises stress by state."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+
+from load_case import canonical_geometry, load_case, load_mesh
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dataset-root", type=Path, default=Path("."))
+    parser.add_argument("--geometry", required=True)
+    parser.add_argument("--case", required=True)
+    parser.add_argument("--state", type=int, default=0, choices=range(17))
+    parser.add_argument("--output", type=Path)
+    args = parser.parse_args()
+
+    geometry = canonical_geometry(args.geometry)
+    data = load_case(args.dataset_root, geometry, args.case)
+    mesh = load_mesh(args.dataset_root, geometry)
+    state = args.state
+
+    pos = mesh["node_pos"]
+    displacement = data["disp"][:, state].numpy()
+    deformed = pos + displacement
+    magnitude = torch.linalg.vector_norm(data["disp"][:, state], dim=-1).numpy()
+    connectivity = mesh["element_node_index"]
+    centers = deformed[connectivity].mean(axis=1)
+    stress = data["effective_stress"][:, state].numpy()
+
+    figure, axes = plt.subplots(1, 2, figsize=(14, 5), constrained_layout=True)
+    first = axes[0].scatter(
+        deformed[:, 0], deformed[:, 1], c=magnitude, s=1.2, cmap="viridis"
+    )
+    axes[0].set_title(f"Nodal displacement magnitude, state {state}")
+    figure.colorbar(first, ax=axes[0])
+    second = axes[1].scatter(
+        centers[:, 0], centers[:, 1], c=stress, s=1.2, cmap="turbo"
+    )
+    axes[1].set_title(f"Max-IP von Mises stress, state {state}")
+    figure.colorbar(second, ax=axes[1])
+    for axis in axes:
+        axis.set_aspect("equal", adjustable="box")
+        axis.set_xlabel("x (unit pending confirmation)")
+        axis.set_ylabel("y (unit pending confirmation)")
+    figure.suptitle(f"{geometry} / {data['case']} / t={float(data['time'][state]):.6g}")
+
+    if args.output:
+        args.output.parent.mkdir(parents=True, exist_ok=True)
+        figure.savefig(args.output, dpi=200)
+        print(args.output)
+    else:
+        plt.show()
+
+
+if __name__ == "__main__":
+    main()