Document simulation protocol and generation evidence for v1.1.0

Adds units, constrained-LHS definitions, impactor and boundary/contact settings, temporal sampling, discrete peak-time semantics, provenance updates, and anonymized generation evidence. Data archives and mesh bytes are unchanged.

BUILD_AUDIT.json

@@ -1,6 +1,6 @@
 {
   "dataset": "Automotive Impact Dataset",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "audit_date": "2026-08-26",
   "case_byte_preservation": {
     "status": "passed",
@@ -24,5 +24,5 @@
       "metadata/trunkfloor_peak_normalization.json"
     ]
   },
-  "scope_note": "This is a technical build audit; provenance and unit limitations are documented separately."
+  "scope_note": "This is a technical build audit; provenance, units, simulation settings, and remaining solver limitations are documented separately."
 }

CITATION.cff

@@ -1,9 +1,9 @@
 cff-version: 1.2.0
-message: "If you use this dataset, please cite the versioned Hugging Face repository for release v1.0.0."
+message: "If you use this dataset, please cite the versioned Hugging Face repository for release v1.1.0."
 title: "Automotive Impact Dataset: Multi-Geometry Full-Field Transient Simulation Data"
 type: dataset
-version: 1.0.0
-date-released: 2026-09-08
+version: 1.1.0
+date-released: 2026-09-10
 authors:
   - family-names: "Authors"
     given-names: "Anonymous"

DATASHEET.md

@@ -31,16 +31,56 @@ 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
+## Condition definitions and units
+
+The simulations use a tonne--mm--s--N consistent unit system. Coordinates and
+displacements are in mm, time is in s, velocity is in mm/s, mass is in tonne,
+density is in tonne/mm^3, and stress and Young's modulus are in MPa.
+
+The paper-level inputs map to released fields as follows:
 
-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.
+- p is `impact_xyz`, the centroid of a selected eligible panel shell;
+- v is `velocity_xyz`, the rigid impactor's initial translational velocity;
+- mu is `mass_ratio`, a dimensionless scale factor in [0.75, 1.25];
+- E is `material_young_mpa`, the rigid-impactor Young's modulus;
+- nu is `material_poisson`, the rigid-impactor Poisson ratio.
 
-The exact LS-DYNA version, source-model version, boundary/contact setup, state
-sampling rule, and consistent unit system are not specified in this release.
+The impact speed is sampled in [1732.05, 5196.15] mm/s. Theta is sampled in
+[0, 15] degrees from global +Z, and phi is sampled in [0, 360] degrees in
+global XY from +X toward +Y. Cartesian velocity is computed from speed and
+these two angles. The three material categories are discrete rigid-impactor
+E/nu pairs: (70000 MPa, 0.33), (110000 MPa, 0.34), and
+(210000 MPa, 0.30).
+
+Mass ratio scales the generator's reference impactor mass and density:
+`impactor_mass = 0.01 tonne * mu` and
+`impactor_density = 5.205e-5 tonne/mm^3 * mu`. The mass field is the nominal
+mass recorded by the generator.
+
+## Collection and simulation process
+
+Conditions were generated with a seven-dimensional constrained Latin hypercube
+over position X/Y, speed, mass ratio, theta, phi, and material class. Eligible
+impact positions are panel-shell centroids at least 80 mm from the topological
+outer boundary. Normalized LHS position coordinates are mapped to unused
+eligible centroids, so Z is inherited from the selected shell and is not an
+independent continuous coordinate. Among 128 trial designs, the normalized
+maximin design is retained. `metadata/LHS_DESIGN.md` records the exact
+geometry-specific batching and seeds.
+
+The simulations were executed with LS-DYNA SMP single precision R12 through
+ANSYS v221 `lsdyna_sp.exe`, using `ncpu=8` and `memory=400m`, on panel geometry
+derived from the 2020 Nissan Rogue finite-element model Version 3. The rigid
+spherical-shell impactor has radius 12.5 mm, thickness 0.1 mm, ELFORM 2,
+SHRF 0.833333, NIP 3, and a 5.0-mm initial gap. Panel outer-boundary nodes are
+fixed in all six degrees of freedom. Impactor--panel interaction uses automatic
+surface-to-surface contact with static and dynamic friction coefficients of
+0.15. A body acceleration of 9810 mm/s^2 acts in global +Z. Further details are
+given in `metadata/SIMULATION_PROTOCOL.md`.
+
+Raw solver databases and curve text are not included. Panel material and shell
+definitions remain those of the upstream Version 3 model. The exact LS-DYNA
+R12 sub-build is not retained for every released case.
 
 ## Preprocessing
 
@@ -50,6 +90,17 @@ preparation. They have not been reduced to a single peak state. The accompanying
 the largest valid nodal displacement magnitude and using stress from the same
 state.
 
+The solver requests D3PLOT output every 0.0002 s through 0.03 s. Compact
+conversion retains every tenth raw state and appends the final state. Both
+nodal and element fields use indices `[0, 10, 20, ..., 150, 151]` in every
+released case. The first 16 retained states have a nominal 0.002-s spacing;
+the appended terminal state can be much closer to index 150. Exact times are
+stored per case.
+
+Peak time `t*` is an argmax over valid nodes and these 17 retained states only.
+It is therefore a discrete, temporally quantized label rather than a
+continuous-time solver maximum. See `metadata/TEMPORAL_SAMPLING.md`.
+
 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.
@@ -91,7 +142,7 @@ audit described in `metadata/floorfrontR_DATA_NOTE.md`.
 
 ## Splits and benchmark integrity
 
-The full v1.0 release includes labels for train, validation, and test cases.
+The full v1.1 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.
@@ -110,5 +161,8 @@ 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`.
+Project-authored code, documentation, metadata, and derived numerical results
+are released under the MIT License. The panel meshes are derived from the cited
+CCSA/NHTSA vehicle model; upstream attribution is preserved and the upstream
+model is not represented as MIT-licensed project-authored content. Provenance
+and attribution are documented in `THIRD_PARTY_NOTICES.md`.

README.md

@@ -12,7 +12,7 @@ viewer: false
 
 # Automotive Impact Dataset
 
-**Version:** 1.0.0  
+**Version:** 1.1.0  
 **Data type:** finite-element simulation trajectories  
 **Task:** impact-conditioned displacement and shell von Mises effective-stress field prediction
 
@@ -26,6 +26,15 @@ The dataset supports research on graph neural operators, mesh-based surrogate
 models, spatiotemporal field prediction, peak-event prediction, and
 simulation-based design screening.
 
+Detailed generation documentation is provided in:
+
+- `metadata/SIMULATION_PROTOCOL.md` for units, the impactor, boundary/contact
+  conditions, and solver/output settings;
+- `metadata/LHS_DESIGN.md` for parameter definitions, design bounds, and the
+  geometry-specific constrained-LHS construction;
+- `metadata/TEMPORAL_SAMPLING.md` for the 17-state reduction and the discrete
+  peak-time definition.
+
 ## Dataset summary
 
 | Geometry | Cases | Nodes | Directed graph edges | Shell elements | Displacement | von Mises effective stress |
@@ -37,6 +46,70 @@ simulation-based design screening.
 The three geometries are independent datasets. Equal case identifiers across
 geometries do **not** denote paired physical simulations.
 
+## Conditions and units
+
+The simulations use the tonne--mm--s--N consistent unit system. Coordinates
+and displacements are in mm, time is in s, velocity is in mm/s, mass is in
+tonne, density is in tonne/mm^3, and stress and Young's modulus are in MPa.
+
+| Symbol | Released field | Definition | Design domain | Unit |
+|---|---|---|---|---|
+| p | `impact_xyz` | centroid of the selected eligible panel shell | geometry-dependent discrete candidate set | mm |
+| v | `velocity_xyz` | initial rigid-impactor translational velocity | derived from speed and angles | mm/s |
+| s | `impact_speed` | velocity magnitude | [1732.05, 5196.15] | mm/s |
+| mu | `mass_ratio` | common scale factor for reference impactor mass and density | [0.75, 1.25] | dimensionless |
+| theta | `theta_deg` | polar angle measured from global +Z | [0, 15] | degree |
+| phi | `phi_deg` | azimuth in global XY, from +X toward +Y | [0, 360] | degree |
+| E | `material_young_mpa` | rigid-impactor Young's modulus | {70000, 110000, 210000} | MPa |
+| nu | `material_poisson` | rigid-impactor Poisson ratio | {0.33, 0.34, 0.30} | dimensionless |
+
+The velocity is constructed as
+`v = s [sin(theta) cos(phi), sin(theta) sin(phi), cos(theta)]`.
+The mass-ratio convention is
+`impactor_mass = 0.01 tonne * mu` and
+`impactor_density = 5.205e-5 tonne/mm^3 * mu`.
+
+Impact positions are not sampled as three independent continuous coordinates.
+Eligible positions are shell-element centroids at least 80 mm from the
+topological outer boundary. Two LHS coordinates are mapped in normalized XY to
+the nearest unused eligible centroid; the released Z coordinate is the actual
+centroid height.
+
+## Constrained-LHS design
+
+Each design uses seven normalized coordinates: position X, position Y, speed,
+mass ratio, theta, phi, and material class. Candidate designs are generated by
+Latin hypercube sampling, and the design with the largest normalized minimum
+pairwise distance among 128 trials is retained. Material is a balanced
+three-level categorical coordinate.
+
+`floorfrontR` and `trunkfloor` use independent single-batch designs with seeds
+20260728 and 20260723, respectively. `floorfrontdriver` is a staged design:
+cases 001--100 use seed 20260721, cases 101--200 are a complementary nested
+extension using seed 20260722, and cases 201--500 form an independent
+augmentation using seed 20260722. The geometries share parameter bounds and
+simulation rules but do not share paired physical conditions.
+
+## Impactor and simulation setup
+
+The impactor is a rigid spherical shell with radius 12.5 mm and an initial
+5.0-mm gap from the target centroid along the direction opposite to travel. It
+uses shell ELFORM 2, shear factor 0.833333, three through-thickness integration
+points, thickness 0.1 mm, and `*MAT_RIGID`. The material class changes only the
+rigid impactor's E and nu; mass ratio changes only its density and nominal
+mass.
+
+All nodes on the panel's topological outer boundary are constrained in all six
+degrees of freedom. Impactor--panel interaction uses
+`*CONTACT_AUTOMATIC_SURFACE_TO_SURFACE_ID` with static and dynamic friction
+coefficients of 0.15. A body acceleration of 9810 mm/s^2 is applied in global
++Z. Simulations end at 0.03 s. They were run with LS-DYNA SMP single precision
+R12 through ANSYS v221 `lsdyna_sp.exe` using `ncpu=8` and `memory=400m`.
+
+The panel material definitions and shell sections remain those of the cited
+upstream Version 3 model; their full keyword cards are not redistributed in
+this compact release.
+
 ## Stress definition
 
 The `effective_stress` field is the shell-element von Mises equivalent stress
@@ -56,6 +129,7 @@ automotive-impact-data/
 │   └── trunkfloor/cases_001_100.zip ... cases_401_500.zip
 ├── meshes/
 ├── metadata/
+├── generation_evidence/
 ├── scripts/
 ├── manifest.csv
 ├── checksums.sha256
@@ -75,7 +149,7 @@ from huggingface_hub import snapshot_download
 dataset_root = snapshot_download(
     repo_id="structmeshdata/automotive-impact-data",
     repo_type="dataset",
-    revision="v1.0.0",
+    revision="v1.1.0",
 )
 ```
 
@@ -124,6 +198,21 @@ 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.
 
+## Temporal sampling
+
+The solver writes D3PLOT output at a nominal interval of 0.0002 s. Compact
+conversion retains every tenth raw state and appends the final state. Every
+released case therefore uses indices `[0, 10, 20, ..., 150, 151]`; the first
+16 retained states have a nominal 0.002-s spacing, while the appended terminal
+state can be very close to index 150. Exact floating-point times are stored in
+each case and should be used instead of reconstructing them from the nominal
+interval.
+
+The peak time `t*` is discrete: it is the argmax of nodal displacement magnitude
+over valid nodes and the 17 retained states only. It is not a continuous-time
+solver maximum. Stress at the same selected retained state is used as the
+paired peak-event stress target.
+
 ## Data-version note
 
 The included `floorfrontR` data passed the release quality audit. Files from
@@ -136,8 +225,11 @@ earlier internal builds must not be mixed with this release; see
 - 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.
+- The exact LS-DYNA R12 sub-build is not retained for every case.
+- The recorded `impactor_mass` is the generator-defined nominal mass; users
+  requiring an independently recomputed solver mass should inspect an original
+  solver `MATSUM` output.
+- Peak-event time is quantized to the released 17-state temporal grid.
 
 ## License
 
@@ -146,6 +238,6 @@ 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.
+Please cite the versioned Hugging Face repository for release `v1.1.0`:
+https://huggingface.co/datasets/structmeshdata/automotive-impact-data/tree/v1.1.0.
 Citation metadata is also provided in `CITATION.cff`.

README_zh.md

@@ -1,10 +1,58 @@
 # 汽车结构冲击数据集中文说明
 
 本汽车结构冲击数据集包含三种汽车
-结构几何上的独立冲击有限元仿真。每种几何包含 500 个 LHS 工况，
+结构几何上的独立冲击有限元仿真。每种几何包含 500 个约束 LHS 工况，
 每个工况保存 17 个对齐时刻的完整节点三维位移场和壳单元
 von Mises 等效应力场。
 
+## 参数与单位
+
+仿真采用 tonne--mm--s--N 一致单位制：坐标和位移为 mm，时间为 s，
+速度为 mm/s，质量为 tonne，密度为 tonne/mm^3，应力和弹性模量为 MPa。
+
+- 冲击速度范围为 1732.05--5196.15 mm/s。
+- 质量比 `mu` 范围为 0.75--1.25，并满足
+  `impactor_mass = 0.01 tonne * mu`、
+  `impactor_density = 5.205e-5 tonne/mm^3 * mu`。
+- `theta` 为相对全局 +Z 的极角，范围 0--15 度；`phi` 为全局 XY
+  平面内从 +X 指向 +Y 的方位角，范围 0--360 度。
+- 速度向量为
+  `v = s [sin(theta) cos(phi), sin(theta) sin(phi), cos(theta)]`。
+- E 和 nu 是刚性冲击球的材料参数，三个离散组合分别为
+  `(70000 MPa, 0.33)`、`(110000 MPa, 0.34)` 和
+  `(210000 MPa, 0.30)`。
+
+冲击位置不是三个连续坐标的独立采样。候选位置是距离面板拓扑外边界
+至少 80 mm 的壳单元质心；两个归一化 LHS 位置坐标映射到最近且未使用的
+候选质心，Z 坐标取该质心的实际高度。
+
+## 仿真设置
+
+冲击体是半径 12.5 mm 的刚性球壳，初始间隙 5.0 mm，采用 ELFORM=2、
+SHRF=0.833333、NIP=3、厚度 0.1 mm 和 `*MAT_RIGID`。面板拓扑外边界
+节点的六个自由度全部固定。冲击接触采用
+`*CONTACT_AUTOMATIC_SURFACE_TO_SURFACE_ID`，静、动摩擦系数均为 0.15；
+全局 +Z 方向施加 9810 mm/s^2 的体加速度。仿真终止时间为 0.03 s。
+
+求解使用 ANSYS v221 中的 `lsdyna_sp.exe`，对应 LS-DYNA SMP single
+precision R12，运行参数为 `ncpu=8`、`memory=400m`。面板材料和壳截面
+沿用上游 Version 3 模型；完整 keyword 卡不包含在本紧凑数据发布中。
+
+## LHS 与时间采样
+
+LHS 包含位置 X/Y、速度大小、质量比、theta、phi 和材料类别七个维度，
+并从 128 个候选设计中选择归一化最小样本间距最大的设计。三种几何共享
+参数范围和仿真规则，但使用不同的候选网格位置和随机种子；其中
+`floorfrontdriver` 是分阶段构建的设计，而不是一次生成的单批设计。
+
+D3PLOT 名义输出间隔为 0.0002 s。紧凑转换每十个原始状态保留一帧，
+并额外加入最终状态；全部公开工况的索引均为
+`[0,10,20,...,150,151]`。前 16 帧名义间隔为 0.002 s，最后一帧可能与
+前一帧非常接近，实际计算应使用每个样本保存的 `time`。
+
+峰值时间 `t*` 只在 17 个保留状态中对有效节点的位移模长取最大值，
+因此是离散时间，不是连续求解轨迹的精确峰值；应力标签取相同状态。
+
 ## 数据规模
 
 | 几何 | case数 | 节点数 | 壳单元数 | 位移张量 | 应力张量 |
@@ -40,4 +88,6 @@ python scripts/validate_dataset.py --dataset-root . --verify-checksums
 
 本发布包中的 `floorfrontR` 数据经过完整质量核查；不要与更早的内部构建
 混用。本仓库采用 MIT License，详细来源、字段和局限请参阅英文
-`README.md`、`DATASHEET.md` 和 `THIRD_PARTY_NOTICES.md`。
+`README.md`、`DATASHEET.md`、`metadata/SIMULATION_PROTOCOL.md`、
+`metadata/LHS_DESIGN.md`、`metadata/TEMPORAL_SAMPLING.md` 和
+`THIRD_PARTY_NOTICES.md`。

THIRD_PARTY_NOTICES.md

@@ -11,12 +11,16 @@ 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.
+The released panel geometries were derived from Version 3, released August
+2024. The official technical presentation is identified by DOI
+`10.13021/xb7g-8z06`.
+
+This repository includes three extracted panel meshes needed to interpret the
+released fields. Project-authored code, metadata, documentation, and derived
+numerical results are distributed under this repository's licenses. Reference
+to those licenses does not represent the upstream vehicle model as
+project-authored or relicense it. Publications using these assets should retain
+the CCSA and NHTSA acknowledgement and applicable disclaimer.
 
 ## LS-DYNA
 

VALIDATION_REPORT.json

@@ -1,6 +1,6 @@
 {
   "dataset": "Automotive Impact Dataset",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "status": "passed",
   "cases_validated": 1500,
   "split_sizes": {
@@ -51,9 +51,9 @@
     }
   },
   "checksums": {
-    "checked_files": 48
+    "checked_files": 77
   },
-  "elapsed_seconds": 35.055318117141724,
+  "elapsed_seconds": 32.78638792037964,
   "errors": [],
-  "scope_note": "Technical package validation only; provenance and unit limitations are documented in the release metadata."
+  "scope_note": "Technical package validation only; provenance and remaining configuration limitations are documented in the release metadata."
 }

checksums.sha256

@@ -1,12 +1,12 @@
 1390fe35fb4bf7ae3b664798735e5e6e90421a14ee41717029b704d8189571e4  .gitignore
-86c650d36a0e7a29ed044ce5fdc82252f1a23ed8d2a7f5115682071d18c4c7fb  BUILD_AUDIT.json
-5c0a42fb6c26561ab533201ad032a6d9b9e85e827c9a335aeb793ffe907d20e8  CITATION.cff
-f32d7e8db854f624a0c7120491083d281bbc3adca0314f6eb59cd23aa780bd72  DATASHEET.md
+1017ba775c18b5a9608826f5adcf13637453918bd93fd65b96cac3a2b1d1de25  BUILD_AUDIT.json
+9768a8cd9bca1793bb9898ccdf3beeead683a438d9bd6bd89c01856d3ac2cd6e  CITATION.cff
+0814fcd0e23c4c16c6cbb57ab7b119805553051cbd9d52916ada2940db3bbe78  DATASHEET.md
 0566a01e7392327b540b35810be439b9f5f1e0ff330c2d2c9e5cc72ccc319363  LICENSE
 0566a01e7392327b540b35810be439b9f5f1e0ff330c2d2c9e5cc72ccc319363  LICENSE-CODE
-0fdee0293d7c742a9b6d9db59f0220b3d3dffe0cfd47a5fc1b5da4916d606631  README.md
-542ff825ded829acc9c4ef327f940c9cb9d3fbcd133b3e785b9d796a03876f52  README_zh.md
-36078792dcb193b3e0fa4db0d777c225ab5b8f0c4c8a9e53eee6e605c275596f  THIRD_PARTY_NOTICES.md
+daec69f01d9b4ebd2854ea09c84a9013d91a5f9f1a9ecbe1e0d7ad895ddf9287  README.md
+5585747191fddc2b9ca23d09c7937039c040e130158c935c5143e5eb9ec1af03  README_zh.md
+8ac9c65332853b19a994459ee308fb6e06eeeb768b5768f38dda3ae55a377217  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
@@ -22,27 +22,56 @@ c5a938dea14657df147648795247a415d8ec31a3ca68c989a69ed62e154e5749  data/trunkfloo
 745ab8ad15ed3a40466f4b1c2e539cac3981cf3442da5d267150356e6c923f8b  data/trunkfloor/cases_201_300.zip
 f7c0ebbd8bf53079bb7fbf856286c8df2a5652184ecf3884398c190530019dd7  data/trunkfloor/cases_301_400.zip
 98487b9085eb8d715ae81d3466befec53fb8468ff1286a357c5380f91de02dfd  data/trunkfloor/cases_401_500.zip
+e58bd0c738111c43dd047fb39a98101ccdbb73325a4c10a664f77df35d7c0246  generation_evidence/README.md
+b3f9edbb791059879683a63184a7bc80fceaa41e3f5ab82e74113e96f07b2a31  generation_evidence/conversion/prepare_floorfrontR_compact_training_data.py
+22f8012bc90b34df68ca98c2eb0e99a3e6cc99a13dca88164763299820b16b69  generation_evidence/conversion/prepare_floorfrontR_training_data.py
+1b8ec53015b7e4e247e26c6960feabea243aee8313e2b3fada004f01f93b54c4  generation_evidence/conversion/prepare_floorfrontdriver_compact_training_data.py
+043ea47d7105de49229e418d2efefc876bbb8794871b4bcab0003fe4d42e6188  generation_evidence/conversion/prepare_trunkfloor_compact_training_data.py
+9d7a99e335ddfbe6a1247da5d41a752304ec92093baab601a030ac06806bea0e  generation_evidence/export/compact_floorfrontR.cfile
+827f5bc3c72d1fe041301068fb0ccd2823e1bbba85b50e34830e9013d94e53cf  generation_evidence/export/compact_floorfrontR_elements.cfile
+88fdef945708145979aba323ba3b06ce8e0024ab3c987125a0b047d13ce78222  generation_evidence/export/compact_floorfrontR_nodes.cfile
+5c754d447c73ab89532c633575bb4e2f7d6ce8907043c06e112adaba40b5b7ee  generation_evidence/export/compact_floorfrontdriver.cfile
+7f3fcf60de096e8bf47d95af680aba6902244c59f0373bba7d12faae9faa8ef7  generation_evidence/export/compact_trunkfloor.cfile
+cceb5c2e64710f0f65c6859c94fdd335de3fe80a8f963da0f92de0c539b74dc1  generation_evidence/impactor/add_impactor_to_floor_panels.py
+444f0a594e605de730b40220fc2f0fedfb92804bfd1c6ab19bbce39fbb4b9063  generation_evidence/lhs/extend_floorfrontdriver_lhs_cases_to_500.py
+c9ac4801795e71dc92ec3b3c26648b568f9b91972353727f8b35a354ab0a454a  generation_evidence/lhs/extend_floorfrontdriver_lhs_to_200.py
+ec54243c1fefb5e15ae002e21a516a29dd40d500bd7f0c09f5f345891bdadb8c  generation_evidence/lhs/floorfrontR/case_manifest.csv
+6e61656e954d248c69fa28acccb394b10fa169988ee6fd292a52c996f35ec9fa  generation_evidence/lhs/floorfrontR/lhs_design_summary.txt
+37b93f008da5de0b28d8ff3460593cfbf1f8a7bb3653eaaf174c5d63682f4774  generation_evidence/lhs/floorfrontdriver/case_manifest.csv
+51b893c674f320e29211ebc60ce2231fec5e301aec1f885c7bef316bd35de204  generation_evidence/lhs/floorfrontdriver/lhs_design_summary.txt
+8350dcccf37850573ff8ee1256c18f592f0785cd8aeb9b1f8e423ed03970cffd  generation_evidence/lhs/floorfrontdriver/lhs_design_summary_200.txt
+61043910819171bbbefe986ccc9b58c6b6c0950fbbe6760b3477b06366bbd3e7  generation_evidence/lhs/floorfrontdriver/lhs_extension_201_500_summary.txt
+2718e7e29da191ac44861c4e7abce0bcb8a0317fd8cf0bbe067d5c03ea8febf3  generation_evidence/lhs/generate_floorfrontR_lhs_cases.py
+ccf2b71c67f3a8237d5ed03e032274a6a86ac1ab339e2bc561d1e490152d1628  generation_evidence/lhs/generate_floorfrontdriver_lhs_cases.py
+cbc6e087de631ce33e23275b2530097a44a102fcf8909b6802f2014ae7d2e808  generation_evidence/lhs/generate_floorfrontdriver_random_cases.py
+a5782cc91c53f0118e0d0a9af400469bea1e003ebc200b2026176679bc4ca8f2  generation_evidence/lhs/generate_trunkfloor_lhs_cases.py
+b448fa87b80bdfc77cf6e563b84d9d03043f9199f48c3a5c905ce72d0c6cd2d9  generation_evidence/lhs/trunkfloor/case_manifest.csv
+4465bcaba14ebe817a15dcf76c49d7b18fd7a629c96549af9a10dfd8f090f5dc  generation_evidence/lhs/trunkfloor/lhs_design_summary.txt
+56b153459a23cbcc42ca0ea0a08d925112a74b47de4bf12a19d9fd90cc524ed3  generation_evidence/stress/effective_stress_definition.txt
 02f7ac3d93d902eab35e4235d94ee70a7b3a3b75387053a3351c6a5bb977d503  manifest.csv
 7c63c99afe297f995c18a801159573f4b5a86bc25031743fd5168da77a47385d  meshes/floorfrontR_mesh.npz
 f3493dbed1517d74b34cc6a801238735e3c570f63234566d6f4f8dede51788ba  meshes/floorfrontdriver_mesh.npz
 9cbb3476bed490746ef6e01f0049ec1573746a2c68ca5537364e66311a29ce9b  meshes/trunkfloor_mesh.npz
-3f1e4cf04904aeb1fc07d793a258e2517cf9f5e9b8331619e4e50c1452961fd0  metadata/dataset.json
+2dd66d5fb7b7aa68c72dde949bee1f06043922586d76e8aef7f5243eb2908f4f  metadata/LHS_DESIGN.md
+a17bfda7f8f4f5735f396fa732c1a78b9426710c4a803d242045978b7871f3a6  metadata/SIMULATION_PROTOCOL.md
+c55a3ffa95e7820251a7b89d2bda561c7aac323e14bb1c31a15c88e25d72de99  metadata/TEMPORAL_SAMPLING.md
+eb438607874f4165a63790ea0b247b0fa8308e9592eb4a2bd185c3347169543b  metadata/dataset.json
 5827784a6b36fb7df800dcad4c2e2cb1ef69b69770ed16a74fd273bb660d6817  metadata/floorfrontR_DATA_NOTE.md
 decbe458d0572178fa502b35329460bd758884f06fc72f2e095a8e99185b0080  metadata/floorfrontR_conditions.csv
-2ff08ba7c53b96f23c064f1ca3be61e304334e9bb171b0b7c5f7ff0847956b67  metadata/floorfrontR_geometry.json
+dab8c2346a8041c747e95375f09950453b30fd27623f9c8c935e2ebe3d70ae99  metadata/floorfrontR_geometry.json
 4f4c3db379540ac3aa5d27ca4ed96095324d43a47b93ecbd1c321d54700cf8ef  metadata/floorfrontR_peak_normalization.json
 5576a6401c58a83c856b5b5d350f04fe7d4f98417db2d34848ffd8f91290157d  metadata/floorfrontdriver_conditions.csv
-20af0abfb6c792abbacfa60e62e95559441d0499f4a88223f0c3bc007ba9d351  metadata/floorfrontdriver_geometry.json
+dc91d6e95f5dd55319c7d68bb0ec5720d25f7bc22418e2afb904017523761188  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
+b61c9645cb1a3396b3b19b4a65b5e97e7a0b6369a9cdd67b18627f0cbbef19f9  metadata/trunkfloor_geometry.json
 37e1726395b3960f1d549f360c6428c47cda21bf4fc4a92783de2b163b7f3fb1  metadata/trunkfloor_peak_normalization.json
-0cce019ecf8bfd4633d965659c4d9032b62d21cd31532eb96fecc0627a26b2fd  release_inventory.json
+c572e08b8eb73b546c57e7caa0ebee9cea34cfedd784ace455e06f4c6beae4b4  release_inventory.json
 c0801d2e3f5249c34a251979aecaa32b046deabb5cb627f0592866e4dee5f376  requirements.txt
-39dab43c60a84f6080f00da3b881e336e7c2e93b62675747f26f42691dde27df  schema.json
+854d76a81793f05abe7127bfb5823d7fa25d115f150161eba13f70aa5c078d6c  schema.json
 3008c2139a8d7ee556222e964c5e5e638828683e4bd38003098cdd2df0b413d0  scripts/build_peak_targets.py
 683dc2d9c9bf93d47e5edf253045e8a19e0bf1dccdd5784c52570b72c3c840dc  scripts/compute_train_normalization.py
 6781f7623d8c7f9bca4798f94bf0cd4bd272cd4ef29c7bdeda1a287c0aa14ec1  scripts/load_case.py
-b680b796dd1990d30abf3cc7ed7c862eef8128b9167057f4f25229eb91059e43  scripts/validate_dataset.py
+e7022182a385c9c77bd4a46be9e9720416f3e299914a9c4c22937094a94d48d5  scripts/validate_dataset.py
 7afa09ebeda88f8afed693540899f1d3a1ded9ab0bb2c6d67bab1b6ba99d55f0  scripts/visualize_trajectory.py

generation_evidence/README.md

@@ -0,0 +1,32 @@
+# Generation evidence
+
+This directory contains project-authored scripts and design records supporting
+the simulation and preprocessing descriptions in the dataset Datasheet.
+
+## Included
+
+- `lhs/`: constrained-LHS generation and staged-extension implementations,
+  geometry-specific design summaries, and exact case manifests;
+- `impactor/`: construction of the rigid spherical impactor, panel-boundary
+  constraints, contact, gravity, termination, and D3PLOT controls;
+- `export/`: LS-PrePost command files for nodal displacement and shell effective
+  stress export;
+- `conversion/`: compact temporal reduction and PyTorch serialization;
+- `stress/`: retained LS-PrePost header evidence for the effective-stress
+  definition.
+
+## Reproducibility boundary
+
+These files document the algorithms used for the released data. Some generation
+scripts require third-party LS-DYNA keyword templates obtained from the cited
+upstream model. Those keyword files, LS-DYNA executables, raw D3PLOT databases,
+and representative solver logs are not included here. Consequently this
+directory is an auditable generation record, not a standalone redistribution
+of the upstream finite-element model.
+
+Historical local paths and machine-specific wrapper scripts are intentionally
+excluded. Paths appearing in case manifests are relative historical case paths
+and contain no user or machine identity.
+
+The repository's code license applies to the project-authored scripts in this
+directory. See `../THIRD_PARTY_NOTICES.md` for upstream attribution.

generation_evidence/conversion/prepare_floorfrontR_compact_training_data.py

@@ -0,0 +1,656 @@
+from __future__ import annotations
+
+import argparse
+import csv
+import os
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+import torch
+
+from prepare_floorfrontR_training_data import (
+    DEFAULT_PANEL_KEY,
+    PANEL_PID,
+    build_graph,
+    parse_key_mesh,
+    read_curveplot_txt,
+)
+
+
+DEFAULT_CASE_ROOT = Path("cases_floorfrontR_random_50")
+DEFAULT_OUT_ROOT = Path("training_data_floorfrontR_compact")
+RESULTS_DIR = "results_compact"
+NODE_RESULT_NAMES = ("x_displacement", "y_displacement", "z_displacement")
+ELEMENT_RESULT_NAMES = ("effective_stress", "effective_plastic_strain")
+MIN_UNIQUE_ELEMENT_ID_FRACTION = 0.99
+MAX_DOMINANT_STRESS_CURVE_FRACTION = 0.95
+
+
+def parse_args() -> argparse.Namespace:
+    ap = argparse.ArgumentParser(
+        description="Convert compact floorfrontR LS-PrePost curve outputs to lightweight .pt training data."
+    )
+    ap.add_argument("--case-root", type=Path, default=DEFAULT_CASE_ROOT)
+    ap.add_argument("--sweep-root", type=Path, default=None, help="Process every velocity folder under this root.")
+    ap.add_argument("--out-root", type=Path, default=DEFAULT_OUT_ROOT)
+    ap.add_argument("--panel-key", type=Path, default=DEFAULT_PANEL_KEY)
+    ap.add_argument("--panel-pid", type=int, default=PANEL_PID)
+    ap.add_argument("--start", type=int, default=1, help="First case number to convert.")
+    ap.add_argument("--end", type=int, default=0, help="Last case number to convert. Use 0 for all cases.")
+    ap.add_argument("--stride", type=int, default=10, help="Save one state every N time steps.")
+    ap.add_argument("--no-include-last", action="store_true", help="Do not append the final time state.")
+    ap.add_argument("--workers", type=int, default=1)
+    ap.add_argument("--overwrite", action="store_true")
+    ap.add_argument(
+        "--expected-cases",
+        type=int,
+        default=0,
+        help="Expected number of manifest/case entries. Use 0 to disable this check.",
+    )
+    ap.add_argument(
+        "--require-all",
+        action="store_true",
+        help="Fail if any selected case is missing required results_compact files.",
+    )
+    ap.add_argument(
+        "--delete-raw",
+        action="store_true",
+        help="Delete results_compact text files after a case .pt is successfully written.",
+    )
+    return ap.parse_args()
+
+
+def save_npz_from_graph(graph: Dict[str, torch.Tensor], out_path: Path) -> None:
+    arrays = {
+        "nid": graph["nid"].numpy(),
+        "pos": graph["pos"].numpy(),
+        "edge_index": graph["edge_index"].numpy(),
+        "boundary_mask": graph["boundary_mask"].numpy(),
+    }
+    if "element_id" in graph:
+        arrays["element_id"] = graph["element_id"].numpy()
+    np.savez_compressed(out_path, **arrays)
+
+
+def make_stride_indices(n_steps: int, stride: int, include_last: bool) -> torch.Tensor:
+    if stride < 1:
+        raise ValueError("--stride must be >= 1")
+    idx = list(range(0, n_steps, stride))
+    if include_last and idx[-1] != n_steps - 1:
+        idx.append(n_steps - 1)
+    return torch.tensor(idx, dtype=torch.long)
+
+
+def read_manifest_rows(case_root: Path) -> List[dict]:
+    case_manifest = case_root / "case_manifest.csv"
+    if case_manifest.exists():
+        with case_manifest.open("r", newline="") as f:
+            return list(csv.DictReader(f))
+
+    velocity_manifest = case_root.parent / "velocity_manifest.csv"
+    if velocity_manifest.exists():
+        with velocity_manifest.open("r", newline="") as f:
+            rows = list(csv.DictReader(f))
+        return [r for r in rows if r.get("velocity_set") == case_root.name]
+
+    rows = []
+    for case_dir in sorted(case_root.glob("case*")):
+        if not case_dir.is_dir():
+            continue
+        case_name = case_dir.name
+        rows.append(
+            {
+                "case": case_name,
+                "key_file": str(case_dir / f"{case_name}.key"),
+                "panel_pid": str(PANEL_PID),
+            }
+        )
+    return rows
+
+
+def filter_case_rows(rows: List[dict], start: int, end: int) -> List[dict]:
+    if start <= 1 and end <= 0:
+        return rows
+
+    selected = []
+    for row in rows:
+        case_name = row.get("case", "")
+        if not case_name.startswith("case"):
+            selected.append(row)
+            continue
+        try:
+            case_num = int(case_name[4:])
+        except ValueError:
+            selected.append(row)
+            continue
+        if case_num < start:
+            continue
+        if end > 0 and case_num > end:
+            continue
+        selected.append(row)
+    return selected
+
+
+def format_case_preview(cases: List[str], limit: int = 20) -> str:
+    preview = ", ".join(sorted(cases)[:limit])
+    if len(cases) > limit:
+        preview += f", ... (+{len(cases) - limit} more)"
+    return preview
+
+
+def find_missing_compact_results(rows: List[dict]) -> List[str]:
+    missing = []
+    required_names = NODE_RESULT_NAMES + ELEMENT_RESULT_NAMES
+    for row in rows:
+        key_file = Path(row.get("key_file", ""))
+        results_dir = key_file.parent / RESULTS_DIR
+        if not results_dir.exists():
+            missing.append(row["case"])
+            continue
+        if any(not (results_dir / name).exists() or (results_dir / name).stat().st_size <= 0 for name in required_names):
+            missing.append(row["case"])
+    return missing
+
+
+def tensor3(values: List[Optional[str]]) -> Optional[torch.Tensor]:
+    if any(v in (None, "") for v in values):
+        return None
+    return torch.tensor([float(v) for v in values], dtype=torch.float32)
+
+
+def map_nodal_curves(
+    graph_nid: torch.Tensor,
+    curve_nid: torch.Tensor,
+    curves: Dict[str, torch.Tensor],
+    step_idx: torch.Tensor,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    nid_to_row = {int(n): i for i, n in enumerate(curve_nid.tolist())}
+    order = []
+    valid = []
+    for n in graph_nid.tolist():
+        idx = nid_to_row.get(int(n))
+        if idx is None:
+            order.append(-1)
+            valid.append(False)
+        else:
+            order.append(idx)
+            valid.append(True)
+
+    valid_mask = torch.tensor(valid, dtype=torch.bool)
+    valid_order = [idx for idx in order if idx >= 0]
+    disp = torch.full((graph_nid.numel(), step_idx.numel(), 3), float("nan"), dtype=torch.float32)
+    disp[valid_mask] = torch.stack(
+        [
+            curves["x_displacement"][valid_order][:, step_idx],
+            curves["y_displacement"][valid_order][:, step_idx],
+            curves["z_displacement"][valid_order][:, step_idx],
+        ],
+        dim=-1,
+    )
+    return disp, valid_mask
+
+
+def fill_missing_nodal_disp(
+    disp: torch.Tensor,
+    valid_mask: torch.Tensor,
+    edge_index: torch.Tensor,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    filled_mask = ~valid_mask
+    if not bool(filled_mask.any()):
+        return disp, filled_mask
+
+    adjacency: Dict[int, List[int]] = {}
+    for src, dst in edge_index.t().tolist():
+        adjacency.setdefault(int(src), []).append(int(dst))
+
+    for node_idx in torch.nonzero(filled_mask, as_tuple=False).flatten().tolist():
+        neighbors = [idx for idx in adjacency.get(int(node_idx), []) if bool(valid_mask[idx])]
+        if not neighbors:
+            continue
+        disp[node_idx] = disp[neighbors].mean(dim=0)
+        valid_mask[node_idx] = True
+
+    return disp, filled_mask
+
+
+def repair_ids_by_order(reference_ids: torch.Tensor, curve_ids: torch.Tensor) -> Tuple[torch.Tensor, int]:
+    """Repair LS-PrePost curve-header duplicates when row order is anchored."""
+    if reference_ids.numel() != curve_ids.numel():
+        return curve_ids, 0
+    if torch.equal(reference_ids, curve_ids):
+        return curve_ids, 0
+
+    mismatched = reference_ids != curve_ids
+    mismatch_count = int(mismatched.sum())
+    if mismatch_count == 0:
+        return curve_ids, 0
+
+    match_ratio = 1.0 - mismatch_count / max(1, reference_ids.numel())
+    if match_ratio >= 0.99:
+        return reference_ids.clone(), mismatch_count
+
+    # LS-PrePost can label a long contiguous block of otherwise correctly
+    # ordered curves with one repeated element ID. Accept that pattern only
+    # when every singleton label agrees with the reference at its position
+    # and singleton anchors exist on both sides of the mismatched block.
+    unique_ids, inverse, counts = torch.unique(
+        curve_ids, sorted=False, return_inverse=True, return_counts=True
+    )
+    singleton = counts[inverse] == 1
+    reference_set = set(reference_ids.tolist())
+    observed_set = set(unique_ids.tolist())
+    mismatch_indices = torch.nonzero(mismatched, as_tuple=False).flatten()
+    trusted_singleton = singleton & (curve_ids == reference_ids)
+    singleton_count = int(singleton.sum())
+    singleton_mismatch_count = int((singleton & mismatched).sum())
+    allowed_singleton_mismatches = max(1, int(0.01 * singleton_count))
+    trusted_singleton_indices = torch.nonzero(
+        trusted_singleton, as_tuple=False
+    ).flatten()
+    anchored_before = bool(
+        trusted_singleton_indices.numel()
+        and (trusted_singleton_indices < mismatch_indices.min()).any()
+    )
+    anchored_after = bool(
+        trusted_singleton_indices.numel()
+        and (trusted_singleton_indices > mismatch_indices.max()).any()
+    )
+    if (
+        observed_set.issubset(reference_set)
+        and singleton_mismatch_count <= allowed_singleton_mismatches
+        and anchored_before
+        and anchored_after
+    ):
+        return reference_ids.clone(), mismatch_count
+
+    return curve_ids, 0
+
+
+def make_sample(
+    row: dict,
+    graph: Dict[str, torch.Tensor],
+    fixed_mask: torch.Tensor,
+    stride: int,
+    include_last: bool,
+) -> Optional[dict]:
+    case_name = row["case"]
+    key_file = Path(row.get("key_file", ""))
+    if not key_file.is_absolute():
+        case_dir = key_file.parent
+    else:
+        case_dir = key_file.parent
+    if not case_dir.exists():
+        return None
+
+    results_dir = case_dir / RESULTS_DIR
+    if not results_dir.exists():
+        return None
+
+    required = [results_dir / name for name in NODE_RESULT_NAMES + ELEMENT_RESULT_NAMES]
+    if not all(path.exists() for path in required):
+        return None
+
+    node_curves = {}
+    node_time = None
+    node_nid = None
+    for name in NODE_RESULT_NAMES:
+        time, nid, values = read_curveplot_txt(results_dir / name)
+        if node_time is None:
+            node_time = time
+            node_nid = nid
+        elif not torch.allclose(node_time, time):
+            raise RuntimeError(f"Node time grid mismatch in {case_dir}")
+        if not torch.equal(node_nid, nid):
+            raise RuntimeError(f"Node ID order mismatch in {case_dir}")
+        node_curves[name] = values
+
+    node_step_idx = make_stride_indices(node_time.numel(), stride, include_last)
+    disp, valid_node_mask = map_nodal_curves(graph["nid"], node_nid, node_curves, node_step_idx)
+    raw_valid_node_mask = valid_node_mask.clone()
+    disp, _ = fill_missing_nodal_disp(disp, valid_node_mask.clone(), graph["edge_index"])
+    valid_node_mask = torch.isfinite(disp).flatten(start_dim=1).all(dim=1)
+    filled_node_mask = valid_node_mask & ~raw_valid_node_mask
+
+    element_curves = {}
+    element_time = None
+    element_id = None
+    for name in ELEMENT_RESULT_NAMES:
+        time, ids, values = read_curveplot_txt(results_dir / name)
+        if element_time is None:
+            element_time = time
+            element_id = ids
+        elif not torch.allclose(element_time, time):
+            raise RuntimeError(f"Element time grid mismatch in {case_dir}")
+        if not torch.equal(element_id, ids):
+            raise RuntimeError(f"Element ID order mismatch in {case_dir}")
+        element_curves[name] = values
+
+    stress_curves = element_curves["effective_stress"]
+    unique_id_fraction = float(element_id.unique().numel()) / max(1, element_id.numel())
+    _, stress_curve_counts = torch.unique(stress_curves, dim=0, return_counts=True)
+    dominant_stress_fraction = float(stress_curve_counts.max()) / max(
+        1, stress_curves.shape[0]
+    )
+    if unique_id_fraction < MIN_UNIQUE_ELEMENT_ID_FRACTION:
+        raise RuntimeError(
+            f"Degenerate compact stress element IDs in {case_dir}: "
+            f"unique_fraction={unique_id_fraction:.6f}"
+        )
+    if dominant_stress_fraction > MAX_DOMINANT_STRESS_CURVE_FRACTION:
+        raise RuntimeError(
+            f"Degenerate compact stress curves in {case_dir}: "
+            f"dominant_fraction={dominant_stress_fraction:.6f}"
+        )
+
+    element_id, repaired_element_ids = repair_ids_by_order(graph["element_id"], element_id)
+    elem_step_idx = make_stride_indices(element_time.numel(), stride, include_last)
+    effective_stress = element_curves["effective_stress"][:, elem_step_idx]
+    effective_plastic_strain = element_curves["effective_plastic_strain"][:, elem_step_idx]
+
+    impact_xyz = tensor3([row.get("impact_x"), row.get("impact_y"), row.get("impact_z")])
+    ball_center_xyz = tensor3([row.get("ball_center_x"), row.get("ball_center_y"), row.get("ball_center_z")])
+    velocity_vz = row.get("velocity_vz", "")
+    if velocity_vz in ("", None):
+        velocity_vz = "3464.1"
+    velocity_vx = float(row.get("velocity_vx") or 0.0)
+    velocity_vy = float(row.get("velocity_vy") or 0.0)
+    velocity_vz_value = float(velocity_vz)
+    impact_speed = float(
+        row.get("impact_speed")
+        or (velocity_vx**2 + velocity_vy**2 + velocity_vz_value**2) ** 0.5
+    )
+
+    sample = {
+        "case": case_name,
+        "panel_pid": torch.tensor(int(row.get("panel_pid") or PANEL_PID), dtype=torch.long),
+        "nid": graph["nid"],
+        "boundary_mask": fixed_mask,
+        "valid_node_mask": valid_node_mask,
+        "raw_valid_node_mask": raw_valid_node_mask,
+        "filled_node_mask": filled_node_mask,
+        "filled_node_count": torch.tensor(int(filled_node_mask.sum()), dtype=torch.long),
+        "time": node_time[node_step_idx],
+        "time_indices": node_step_idx,
+        "disp": disp,
+        "disp_z": disp[..., 2],
+        "element_time": element_time[elem_step_idx],
+        "element_time_indices": elem_step_idx,
+        "element_id": element_id,
+        "repaired_element_ids": torch.tensor(repaired_element_ids, dtype=torch.long),
+        "effective_stress": effective_stress,
+        "effective_plastic_strain": effective_plastic_strain,
+        "effective_strain": effective_plastic_strain,
+        "velocity_vz": torch.tensor(velocity_vz_value, dtype=torch.float32),
+        "velocity_xyz": torch.tensor(
+            [velocity_vx, velocity_vy, velocity_vz_value], dtype=torch.float32
+        ),
+        "impact_speed": torch.tensor(impact_speed, dtype=torch.float32),
+    }
+
+    if impact_xyz is not None:
+        sample["impact_xyz"] = impact_xyz
+        sample["impact_node_distance"] = torch.linalg.norm(graph["pos"] - impact_xyz[None, :], dim=1)
+    if ball_center_xyz is not None:
+        sample["ball_center_xyz"] = ball_center_xyz
+    if row.get("impact_element_id"):
+        sample["impact_element_id"] = torch.tensor(int(row["impact_element_id"]), dtype=torch.long)
+    if row.get("velocity_set"):
+        sample["velocity_set"] = row["velocity_set"]
+
+    lhs_fields = (
+        "mass_ratio",
+        "impactor_mass",
+        "impactor_density",
+        "theta_deg",
+        "phi_deg",
+        "material_young_mpa",
+        "material_poisson",
+    )
+    for field in lhs_fields:
+        if row.get(field) not in ("", None):
+            sample[field] = torch.tensor(float(row[field]), dtype=torch.float32)
+    if row.get("material_index") not in ("", None):
+        material_index = int(row["material_index"])
+        sample["material_index"] = torch.tensor(material_index, dtype=torch.long)
+        sample["material_one_hot"] = torch.nn.functional.one_hot(
+            torch.tensor(material_index), num_classes=3
+        ).to(torch.float32)
+    if row.get("material_name"):
+        sample["material_name"] = row["material_name"]
+
+    condition_names = (
+        "impact_x",
+        "impact_y",
+        "impact_speed",
+        "mass_ratio",
+        "theta_deg",
+        "phi_deg",
+        "material_index",
+    )
+    if all(row.get(name) not in ("", None) for name in condition_names):
+        sample["condition_names"] = list(condition_names)
+        sample["condition_vector"] = torch.tensor(
+            [float(row[name]) for name in condition_names], dtype=torch.float32
+        )
+
+    return sample
+
+
+def convert_case(
+    row: dict,
+    graph: Dict[str, torch.Tensor],
+    fixed_mask: torch.Tensor,
+    out_cases_dir: Path,
+    stride: int,
+    include_last: bool,
+    overwrite: bool,
+    delete_raw: bool,
+) -> Tuple[str, str, str]:
+    case_name = row["case"]
+    out_path = out_cases_dir / f"{case_name}.pt"
+    if out_path.exists() and not overwrite:
+        return "skipped_existing", case_name, str(out_path)
+
+    try:
+        sample = make_sample(row, graph, fixed_mask, stride, include_last)
+        if sample is None:
+            return "skipped_missing", case_name, ""
+
+        tmp_path = out_path.with_name(f"{out_path.name}.tmp.{os.getpid()}")
+        torch.save(sample, tmp_path)
+        tmp_path.replace(out_path)
+
+        if delete_raw:
+            key_file = Path(row.get("key_file", ""))
+            results_dir = key_file.parent / RESULTS_DIR
+            for name in NODE_RESULT_NAMES + ELEMENT_RESULT_NAMES:
+                path = results_dir / name
+                if path.exists():
+                    path.unlink()
+
+        return "converted", case_name, str(out_path)
+    except Exception as exc:
+        return "error", case_name, str(exc)
+
+
+def write_readme(out_root: Path, case_root: Path, stride: int, include_last: bool) -> None:
+    text = f"""# compact floorfrontR training data
+
+Source case root: `{case_root}`
+
+This dataset stores only the reduced training targets:
+
+- nodal displacement: `disp`, shape `(N, T_reduced, 3)`
+- shell effective stress: `effective_stress`, shape `(Ne, T_reduced)`
+- shell effective strain alias: `effective_strain`, shape `(Ne, T_reduced)`
+- original LS-PrePost variable: `effective_plastic_strain`, shape `(Ne, T_reduced)`
+
+Time downsampling:
+
+- stride: `{stride}`
+- include final state: `{include_last}`
+
+The full LS-PrePost text curves are read from each case `results_compact/` folder.
+The saved `.pt` files keep only the downsampled time states.
+"""
+    (out_root / "README.md").write_text(text, newline="")
+
+
+def convert_case_root(
+    case_root: Path,
+    base_out_root: Path,
+    graph: Dict[str, torch.Tensor],
+    fixed_mask: torch.Tensor,
+    args: argparse.Namespace,
+) -> Tuple[Path, int, int, int, int]:
+    out_root = base_out_root / case_root.name
+    out_cases = out_root / "cases"
+    out_cases.mkdir(parents=True, exist_ok=True)
+
+    mesh_graph_pt = out_root / "mesh_graph.pt"
+    if args.overwrite or not mesh_graph_pt.exists():
+        torch.save(graph, mesh_graph_pt)
+        save_npz_from_graph(graph, out_root / "mesh_graph.npz")
+
+    all_rows = read_manifest_rows(case_root)
+    if args.expected_cases > 0 and len(all_rows) != args.expected_cases:
+        raise RuntimeError(f"Expected {args.expected_cases} cases from {case_root}, found {len(all_rows)}.")
+    rows = filter_case_rows(all_rows, args.start, args.end)
+    missing_before = find_missing_compact_results(rows)
+    if missing_before and args.require_all:
+        raise RuntimeError(
+            f"Missing compact export for {len(missing_before)} case(s): "
+            f"{format_case_preview(missing_before)}"
+        )
+
+    conditions = {
+        "case": [r["case"] for r in all_rows],
+        "velocity_vz": torch.tensor(
+            [float(r.get("velocity_vz") or 3464.1) for r in all_rows],
+            dtype=torch.float32,
+        ),
+    }
+    optional_float_fields = (
+        "impact_x",
+        "impact_y",
+        "impact_z",
+        "velocity_vx",
+        "velocity_vy",
+        "impact_speed",
+        "mass_ratio",
+        "impactor_mass",
+        "impactor_density",
+        "theta_deg",
+        "phi_deg",
+        "material_young_mpa",
+        "material_poisson",
+    )
+    for field in optional_float_fields:
+        if all(row.get(field) not in ("", None) for row in all_rows):
+            conditions[field] = torch.tensor(
+                [float(row[field]) for row in all_rows], dtype=torch.float32
+            )
+    if all(row.get("material_index") not in ("", None) for row in all_rows):
+        conditions["material_index"] = torch.tensor(
+            [int(row["material_index"]) for row in all_rows], dtype=torch.long
+        )
+    if all(row.get("material_name") for row in all_rows):
+        conditions["material_name"] = [row["material_name"] for row in all_rows]
+    torch.save(conditions, out_root / "case_conditions.pt")
+    write_readme(out_root, case_root, args.stride, not args.no_include_last)
+
+    converted = 0
+    skipped_missing = 0
+    missing_cases = []
+    skipped_existing = 0
+    errors = []
+    workers = max(1, int(args.workers))
+
+    if workers == 1:
+        iterator = [
+            convert_case(
+                row,
+                graph,
+                fixed_mask,
+                out_cases,
+                args.stride,
+                not args.no_include_last,
+                args.overwrite,
+                args.delete_raw,
+            )
+            for row in rows
+        ]
+    else:
+        with ThreadPoolExecutor(max_workers=workers) as executor:
+            futures = [
+                executor.submit(
+                    convert_case,
+                    row,
+                    graph,
+                    fixed_mask,
+                    out_cases,
+                    args.stride,
+                    not args.no_include_last,
+                    args.overwrite,
+                    args.delete_raw,
+                )
+                for row in rows
+            ]
+            iterator = [future.result() for future in as_completed(futures)]
+
+    for status, case_name, message in iterator:
+        if status == "converted":
+            converted += 1
+        elif status == "skipped_missing":
+            skipped_missing += 1
+            missing_cases.append(case_name)
+        elif status == "skipped_existing":
+            skipped_existing += 1
+        else:
+            errors.append((case_name, message))
+
+    if errors:
+        detail = "\n".join(f"  {case}: {msg}" for case, msg in errors[:10])
+        raise RuntimeError(f"Failed converting {len(errors)} cases under {case_root}:\n{detail}")
+    if missing_cases:
+        print(f"[INFO] missing compact result cases: {format_case_preview(missing_cases)}")
+
+    return out_root, converted, skipped_existing, skipped_missing, len(rows)
+
+
+def main() -> None:
+    args = parse_args()
+
+    nodes, elements, fixed_nodes = parse_key_mesh(args.panel_key, args.panel_pid)
+    graph = build_graph(nodes, elements)
+    fixed_set = set(fixed_nodes)
+    fixed_mask = torch.tensor([int(n) in fixed_set for n in graph["nid"].tolist()], dtype=torch.bool)
+    graph["boundary_mask"] = fixed_mask
+
+    if args.sweep_root is not None:
+        roots = sorted([p for p in args.sweep_root.iterdir() if p.is_dir() and p.name.startswith("v")])
+    else:
+        roots = [args.case_root]
+
+    print(f"[OK] graph nodes: {graph['nid'].numel()}")
+    print(f"[OK] graph directed edges: {graph['edge_index'].shape[1]}")
+    print(f"[OK] fixed boundary nodes: {int(fixed_mask.sum())}")
+    print(f"[OK] time stride: {args.stride}")
+
+    for root in roots:
+        out_root, converted, skipped_existing, skipped_missing, total = convert_case_root(
+            root, args.out_root, graph, fixed_mask, args
+        )
+        print("=========================================")
+        print(f"[OK] source: {root}")
+        print(f"[OK] output: {out_root}")
+        print(f"[OK] manifest cases: {total}")
+        print(f"[OK] converted: {converted}")
+        print(f"[OK] skipped existing: {skipped_existing}")
+        print(f"[OK] skipped missing compact results: {skipped_missing}")
+
+
+if __name__ == "__main__":
+    main()

generation_evidence/conversion/prepare_floorfrontR_training_data.py

@@ -0,0 +1,535 @@
+from __future__ import annotations
+
+import argparse
+import csv
+import os
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional, Tuple
+
+import numpy as np
+import torch
+
+
+PANEL_PID = 2000395
+DEFAULT_PANEL_KEY = Path("floor_panel_largest_2_pid_2000395_133_floorfrontR.key")
+DEFAULT_CASE_ROOT = Path("cases_floorfrontR_random_50")
+DEFAULT_OUT_ROOT = Path("training_data_floorfrontR_random_50")
+NODE_COORD_NAMES = ("x_coordinate", "y_coordinate", "z_coordinate")
+NODE_RESULT_NAMES = ("x_displacement", "y_displacement", "z_displacement")
+ELEMENT_RESULT_NAMES = (
+    "x_stress",
+    "y_stress",
+    "z_stress",
+    "xy_stress",
+    "yz_stress",
+    "zx_stress",
+    "effective_plastic_strain",
+    "pressure",
+    "effective_stress",
+    "lower_Ipt_x_strain",
+    "lower_Ipt_y_strain",
+    "lower_Ipt_z_strain",
+    "lower_Ipt_xy_strain",
+    "lower_Ipt_yz_strain",
+    "lower_Ipt_zx_strain",
+    "upper_Ipt_x_strain",
+    "upper_Ipt_y_strain",
+    "upper_Ipt_z_strain",
+    "upper_Ipt_xy_strain",
+    "upper_Ipt_yz_strain",
+    "upper_Ipt_zx_strain",
+)
+
+
+@dataclass
+class ShellElement:
+    eid: int
+    pid: int
+    nodes: Tuple[int, ...]
+
+
+def is_keyword(line: str) -> bool:
+    return line.lstrip().startswith("*")
+
+
+def split_fields(line: str) -> List[str]:
+    return line.replace(",", " ").split()
+
+
+def parse_key_mesh(path: Path, panel_pid: int) -> Tuple[Dict[int, Tuple[float, float, float]], List[ShellElement], List[int]]:
+    nodes: Dict[int, Tuple[float, float, float]] = {}
+    elements: List[ShellElement] = []
+    fixed_nodes: List[int] = []
+
+    mode: Optional[str] = None
+    pending_spc_set = False
+
+    with path.open("r", errors="ignore") as f:
+        for raw in f:
+            line = raw.strip()
+            if not line or line.startswith("$"):
+                continue
+
+            upper = line.upper()
+            if is_keyword(line):
+                if upper.startswith("*NODE"):
+                    mode = "node"
+                elif upper.startswith("*ELEMENT_SHELL"):
+                    mode = "shell"
+                elif upper.startswith("*SET_NODE_LIST"):
+                    mode = "node_set"
+                    pending_spc_set = False
+                elif upper.startswith("*BOUNDARY_SPC_SET"):
+                    mode = "spc"
+                    pending_spc_set = True
+                else:
+                    mode = None
+                continue
+
+            if mode == "node":
+                parts = split_fields(line)
+                if len(parts) >= 4:
+                    try:
+                        nid = int(parts[0])
+                        nodes[nid] = (float(parts[1]), float(parts[2]), float(parts[3]))
+                    except ValueError:
+                        pass
+
+            elif mode == "shell":
+                parts = split_fields(line)
+                if len(parts) >= 6:
+                    try:
+                        eid = int(parts[0])
+                        pid = int(parts[1])
+                        elem_nodes = [int(x) for x in parts[2:6]]
+                    except ValueError:
+                        continue
+                    if pid != panel_pid:
+                        continue
+                    if elem_nodes[3] == 0 or elem_nodes[3] == elem_nodes[2]:
+                        elem_nodes = elem_nodes[:3]
+                    elements.append(ShellElement(eid=eid, pid=pid, nodes=tuple(elem_nodes)))
+
+            elif mode == "spc" and pending_spc_set:
+                # The first non-comment data line of *BOUNDARY_SPC_SET gives the fixed node set ID.
+                # The actual nodes are read from the following *SET_NODE_LIST block in this deck.
+                pending_spc_set = False
+
+            elif mode == "node_set":
+                parts = split_fields(line)
+                if len(parts) == 1:
+                    # set ID line
+                    continue
+                for token in parts:
+                    try:
+                        nid = int(token)
+                    except ValueError:
+                        continue
+                    if nid > 0:
+                        fixed_nodes.append(nid)
+
+    if not nodes:
+        raise RuntimeError(f"No *NODE data found in {path}")
+    if not elements:
+        raise RuntimeError(f"No shell elements with PID={panel_pid} found in {path}")
+
+    return nodes, elements, sorted(set(fixed_nodes))
+
+
+def build_graph(
+    nodes: Dict[int, Tuple[float, float, float]],
+    elements: Iterable[ShellElement],
+) -> Dict[str, torch.Tensor]:
+    elements = list(elements)
+    used_nids = sorted({nid for e in elements for nid in e.nodes})
+    nid_to_idx = {nid: i for i, nid in enumerate(used_nids)}
+
+    pos = torch.tensor([nodes[nid] for nid in used_nids], dtype=torch.float32)
+    nid = torch.tensor(used_nids, dtype=torch.long)
+    element_id = torch.tensor([e.eid for e in elements], dtype=torch.long)
+
+    undirected_edges = set()
+    for e in elements:
+        ns = e.nodes
+        for i, a in enumerate(ns):
+            b = ns[(i + 1) % len(ns)]
+            if a in nid_to_idx and b in nid_to_idx:
+                ia, ib = nid_to_idx[a], nid_to_idx[b]
+                undirected_edges.add((min(ia, ib), max(ia, ib)))
+
+    directed = []
+    for ia, ib in sorted(undirected_edges):
+        directed.append((ia, ib))
+        directed.append((ib, ia))
+
+    edge_index = torch.tensor(directed, dtype=torch.long).t().contiguous()
+    return {"nid": nid, "pos": pos, "edge_index": edge_index, "element_id": element_id}
+
+
+def read_manifest(path: Path) -> List[dict]:
+    with path.open("r", newline="") as f:
+        return list(csv.DictReader(f))
+
+
+def read_curveplot_txt(path: Path) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    nids = []
+    curves = []
+    time_ref = None
+
+    lines = path.read_text(errors="ignore").splitlines()
+    i = 0
+    while i < len(lines):
+        line = lines[i].strip()
+        if line and line[0].isdigit() and "#pts=" in line:
+            nid = int(line.split()[0])
+            nids.append(nid)
+            i += 3
+            ts, vs = [], []
+            while i < len(lines):
+                row = lines[i].strip()
+                if row.lower().startswith("endcurve"):
+                    break
+                parts = row.split()
+                if len(parts) == 2:
+                    ts.append(float(parts[0]))
+                    vs.append(float(parts[1]))
+                i += 1
+            t = np.asarray(ts, dtype=np.float32)
+            v = np.asarray(vs, dtype=np.float32)
+            if time_ref is None:
+                time_ref = t
+            elif not np.allclose(time_ref, t):
+                raise ValueError(f"Time grid mismatch in {path}")
+            curves.append(v)
+        i += 1
+
+    if time_ref is None:
+        raise RuntimeError(f"No node curves found in {path}")
+    return (
+        torch.tensor(time_ref, dtype=torch.float32),
+        torch.tensor(nids, dtype=torch.long),
+        torch.tensor(np.stack(curves, axis=0), dtype=torch.float32),
+    )
+
+
+def save_npz_from_graph(graph: Dict[str, torch.Tensor], out_path: Path) -> None:
+    arrays = {
+        "nid": graph["nid"].numpy(),
+        "pos": graph["pos"].numpy(),
+        "edge_index": graph["edge_index"].numpy(),
+        "boundary_mask": graph["boundary_mask"].numpy(),
+    }
+    if "element_id" in graph:
+        arrays["element_id"] = graph["element_id"].numpy()
+    np.savez_compressed(out_path, **arrays)
+
+
+def make_case_sample(
+    row: dict,
+    graph: Dict[str, torch.Tensor],
+    fixed_mask: torch.Tensor,
+) -> Optional[Dict[str, torch.Tensor]]:
+    key_path = Path(row["key_file"])
+    case_dir = key_path.parent
+    results_dir = case_dir / "results"
+    if not results_dir.exists():
+        return None
+
+    node_paths = [results_dir / name for name in NODE_RESULT_NAMES]
+    if not all(path.exists() for path in node_paths):
+        return None
+
+    node_curves = {}
+    node_time = None
+    label_nid = None
+    for name, path in zip(NODE_RESULT_NAMES, node_paths):
+        time, curve_nid, values = read_curveplot_txt(path)
+        if node_time is None:
+            node_time = time
+            label_nid = curve_nid
+        elif not torch.allclose(node_time, time):
+            raise RuntimeError(f"Node time grid mismatch in {case_dir}")
+        if not torch.equal(label_nid, curve_nid):
+            raise RuntimeError(f"Node ID order mismatch in {case_dir}")
+        node_curves[name] = values
+
+    nid_to_row = {int(n): i for i, n in enumerate(label_nid.tolist())}
+    order = []
+    valid_node_mask = []
+    for n in graph["nid"].tolist():
+        idx = nid_to_row.get(int(n))
+        if idx is None:
+            order.append(-1)
+            valid_node_mask.append(False)
+        else:
+            order.append(idx)
+            valid_node_mask.append(True)
+
+    impact_xyz = torch.tensor(
+        [float(row["impact_x"]), float(row["impact_y"]), float(row["impact_z"])],
+        dtype=torch.float32,
+    )
+    ball_center = torch.tensor(
+        [float(row["ball_center_x"]), float(row["ball_center_y"]), float(row["ball_center_z"])],
+        dtype=torch.float32,
+    )
+    impact_features = torch.tensor(
+        [
+            float(row["impact_x"]),
+            float(row["impact_y"]),
+            float(row["impact_z"]),
+            float(row["ball_center_x"]),
+            float(row["ball_center_y"]),
+            float(row["ball_center_z"]),
+            3464.1,
+            float(row["min_boundary_distance_mm"]),
+        ],
+        dtype=torch.float32,
+    )
+    distance = torch.linalg.norm(graph["pos"] - impact_xyz[None, :], dim=1)
+
+    valid_node_mask = torch.tensor(valid_node_mask, dtype=torch.bool)
+    valid_order = [idx for idx in order if idx >= 0]
+    disp = torch.full((graph["nid"].numel(), node_time.numel(), 3), float("nan"), dtype=torch.float32)
+    disp[valid_node_mask] = torch.stack(
+        [
+            node_curves["x_displacement"][valid_order],
+            node_curves["y_displacement"][valid_order],
+            node_curves["z_displacement"][valid_order],
+        ],
+        dim=-1,
+    )
+
+    sample = {
+        "case": row["case"],
+        "panel_pid": torch.tensor(int(row["panel_pid"]), dtype=torch.long),
+        "impact_element_id": torch.tensor(int(row["impact_element_id"]), dtype=torch.long),
+        "impact_xyz": impact_xyz,
+        "ball_center_xyz": ball_center,
+        "impact_features": impact_features,
+        "impact_node_distance": distance,
+        "boundary_mask": fixed_mask,
+        "valid_node_mask": valid_node_mask,
+        "time": node_time,
+        "nid": graph["nid"],
+        "disp": disp,
+        "disp_z": disp[..., 2],
+    }
+
+    coord_paths = [results_dir / name for name in NODE_COORD_NAMES]
+    if all(path.exists() for path in coord_paths):
+        coord_curves = {}
+        coord_time = None
+        coord_nid = None
+        for name, path in zip(NODE_COORD_NAMES, coord_paths):
+            time, curve_nid, values = read_curveplot_txt(path)
+            if coord_time is None:
+                coord_time = time
+                coord_nid = curve_nid
+            elif not torch.allclose(coord_time, time):
+                raise RuntimeError(f"Coordinate time grid mismatch in {case_dir}")
+            if not torch.equal(coord_nid, curve_nid):
+                raise RuntimeError(f"Coordinate node ID order mismatch in {case_dir}")
+
+            coord_curves[name] = values
+
+        coord_nid_to_row = {int(n): i for i, n in enumerate(coord_nid.tolist())}
+        coord_order = []
+        coord_valid_mask = []
+        for n in graph["nid"].tolist():
+            idx = coord_nid_to_row.get(int(n))
+            if idx is None:
+                coord_order.append(-1)
+                coord_valid_mask.append(False)
+            else:
+                coord_order.append(idx)
+                coord_valid_mask.append(True)
+        coord_valid_mask = torch.tensor(coord_valid_mask, dtype=torch.bool)
+        coord_valid_order = [idx for idx in coord_order if idx >= 0]
+        coord = torch.full((graph["nid"].numel(), coord_time.numel(), 3), float("nan"), dtype=torch.float32)
+        coord[coord_valid_mask] = torch.stack(
+            [
+                coord_curves["x_coordinate"][coord_valid_order],
+                coord_curves["y_coordinate"][coord_valid_order],
+                coord_curves["z_coordinate"][coord_valid_order],
+            ],
+            dim=-1,
+        )
+        sample["coord_time"] = coord_time
+        sample["coord"] = coord
+        sample["valid_coord_mask"] = coord_valid_mask
+
+    element_results = {}
+    element_ids = None
+    element_time = None
+    for name in ELEMENT_RESULT_NAMES:
+        path = results_dir / name
+        if not path.exists():
+            continue
+        time, ids, values = read_curveplot_txt(path)
+        if element_time is None:
+            element_time = time
+            element_ids = ids
+        elif not torch.allclose(element_time, time):
+            raise RuntimeError(f"Element time grid mismatch in {case_dir}")
+        if not torch.equal(element_ids, ids):
+            raise RuntimeError(f"Element ID order mismatch in {case_dir}")
+        element_results[name] = values
+
+    if element_results:
+        sample["element_time"] = element_time
+        sample["element_id"] = element_ids
+        sample["element_results"] = element_results
+
+    return sample
+
+
+def convert_case_to_pt(
+    row: dict,
+    graph: Dict[str, torch.Tensor],
+    fixed_mask: torch.Tensor,
+    out_cases_dir: Path,
+    overwrite: bool,
+) -> Tuple[str, str, str]:
+    case_name = row["case"]
+    out_path = out_cases_dir / f"{case_name}.pt"
+
+    if out_path.exists() and not overwrite:
+        return "skipped_existing", case_name, str(out_path)
+
+    try:
+        sample = make_case_sample(row, graph, fixed_mask)
+        if sample is None:
+            return "skipped_missing", case_name, ""
+        tmp_path = out_path.with_name(f"{out_path.name}.tmp.{os.getpid()}")
+        torch.save(sample, tmp_path)
+        tmp_path.replace(out_path)
+        return "converted", case_name, str(out_path)
+    except Exception as exc:
+        return "error", case_name, str(exc)
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--panel-key", type=Path, default=DEFAULT_PANEL_KEY)
+    ap.add_argument("--case-root", type=Path, default=DEFAULT_CASE_ROOT)
+    ap.add_argument("--out-root", type=Path, default=DEFAULT_OUT_ROOT)
+    ap.add_argument("--panel-pid", type=int, default=PANEL_PID)
+    ap.add_argument("--workers", type=int, default=1, help="Number of cases to convert in parallel")
+    ap.add_argument("--overwrite", action="store_true", help="Regenerate existing .pt files")
+    ap.add_argument("--skip-existing", action="store_true", help=argparse.SUPPRESS)
+    args = ap.parse_args()
+
+    manifest = args.case_root / "case_manifest.csv"
+    args.out_root.mkdir(parents=True, exist_ok=True)
+    (args.out_root / "cases").mkdir(exist_ok=True)
+
+    nodes, elements, fixed_nodes = parse_key_mesh(args.panel_key, args.panel_pid)
+    graph = build_graph(nodes, elements)
+    fixed_set = set(fixed_nodes)
+    fixed_mask = torch.tensor([int(n) in fixed_set for n in graph["nid"].tolist()], dtype=torch.bool)
+    graph["boundary_mask"] = fixed_mask
+
+    mesh_graph_pt = args.out_root / "mesh_graph.pt"
+    mesh_graph_npz = args.out_root / "mesh_graph.npz"
+    if args.overwrite or not mesh_graph_pt.exists():
+        torch.save(graph, mesh_graph_pt)
+    if args.overwrite or not mesh_graph_npz.exists():
+        save_npz_from_graph(graph, mesh_graph_npz)
+
+    rows = read_manifest(manifest)
+    case_conditions_pt = args.out_root / "case_conditions.pt"
+    refresh_case_conditions = args.overwrite or not case_conditions_pt.exists()
+    if not refresh_case_conditions:
+        try:
+            existing_conditions = torch.load(case_conditions_pt, map_location="cpu", weights_only=False)
+            refresh_case_conditions = existing_conditions.get("case") != [r["case"] for r in rows]
+        except Exception:
+            refresh_case_conditions = True
+    if refresh_case_conditions:
+        torch.save(
+            {
+                "case": [r["case"] for r in rows],
+                "impact_features": torch.tensor(
+                    [
+                        [
+                            float(r["impact_x"]),
+                            float(r["impact_y"]),
+                            float(r["impact_z"]),
+                            float(r["ball_center_x"]),
+                            float(r["ball_center_y"]),
+                            float(r["ball_center_z"]),
+                            3464.1,
+                            float(r["min_boundary_distance_mm"]),
+                        ]
+                        for r in rows
+                    ],
+                    dtype=torch.float32,
+                ),
+            },
+            case_conditions_pt,
+        )
+
+    converted = 0
+    skipped_missing = 0
+    skipped_existing = 0
+    errors = []
+    out_cases_dir = args.out_root / "cases"
+    workers = max(1, int(args.workers))
+
+    if workers == 1:
+        for row in rows:
+            status, case_name, message = convert_case_to_pt(
+                row, graph, fixed_mask, out_cases_dir, args.overwrite
+            )
+            if status == "converted":
+                converted += 1
+            elif status == "skipped_missing":
+                skipped_missing += 1
+            elif status == "skipped_existing":
+                skipped_existing += 1
+            else:
+                errors.append((case_name, message))
+    else:
+        print(f"[INFO] parallel case conversion workers: {workers}")
+        with ThreadPoolExecutor(max_workers=workers) as executor:
+            futures = [
+                executor.submit(
+                    convert_case_to_pt,
+                    row,
+                    graph,
+                    fixed_mask,
+                    out_cases_dir,
+                    args.overwrite,
+                )
+                for row in rows
+            ]
+            for future in as_completed(futures):
+                status, case_name, message = future.result()
+                if status == "converted":
+                    converted += 1
+                    print(f"[OK] converted {case_name}")
+                elif status == "skipped_missing":
+                    skipped_missing += 1
+                elif status == "skipped_existing":
+                    skipped_existing += 1
+                else:
+                    errors.append((case_name, message))
+
+    print(f"[OK] graph nodes: {graph['nid'].numel()}")
+    print(f"[OK] graph directed edges: {graph['edge_index'].shape[1]}")
+    print(f"[OK] fixed boundary nodes: {int(fixed_mask.sum())}")
+    print(f"[OK] saved: {args.out_root / 'mesh_graph.pt'}")
+    print(f"[OK] saved: {args.out_root / 'case_conditions.pt'}")
+    print(f"[OK] converted case result files: {converted}")
+    print(f"[OK] skipped existing case files: {skipped_existing}")
+    print(f"[OK] skipped cases without displacement results: {skipped_missing}")
+    if errors:
+        details = "\n".join(f"  {case}: {message}" for case, message in errors[:10])
+        raise RuntimeError(f"Case conversion failed for {len(errors)} case(s):\n{details}")
+
+
+if __name__ == "__main__":
+    main()

generation_evidence/conversion/prepare_floorfrontdriver_compact_training_data.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+
+import prepare_floorfrontR_compact_training_data as compact
+
+
+compact.DEFAULT_CASE_ROOT = Path("cases_floorfrontdriver_random_50")
+compact.DEFAULT_OUT_ROOT = Path("training_data_floorfrontdriver_compact")
+compact.DEFAULT_PANEL_KEY = Path("floor_panel_largest_3_pid_2000394_373_floorfrontdriver.key")
+compact.PANEL_PID = 2000394
+
+
+if __name__ == "__main__":
+    compact.main()

generation_evidence/conversion/prepare_trunkfloor_compact_training_data.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+
+import prepare_floorfrontR_compact_training_data as compact
+
+
+compact.DEFAULT_CASE_ROOT = Path("cases_trunkfloor_random_50")
+compact.DEFAULT_OUT_ROOT = Path("training_data_trunkfloor_compact")
+compact.DEFAULT_PANEL_KEY = Path("floor_panel_largest_1_pid_2000447_153_trunkfloor.key")
+compact.PANEL_PID = 2000447
+
+
+if __name__ == "__main__":
+    compact.main()

generation_evidence/export/compact_floorfrontR.cfile

@@ -0,0 +1,23 @@
+open d3plot "d3plot"
+
+genselect target part
+genselect target node
+genselect node add part 2000395/0
+
+ntime 5
+xyplot 1 savefile curve_file "results_compact\x_displacement" 1 all
+ntime 6
+xyplot 1 savefile curve_file "results_compact\y_displacement" 1 all
+ntime 7
+xyplot 1 savefile curve_file "results_compact\z_displacement" 1 all
+
+genselect target part
+genselect target element
+genselect element add part 2000395/0
+
+etime 9
+xyplot 1 savefile curve_file "results_compact\effective_stress" 1 all
+etime 7
+xyplot 1 savefile curve_file "results_compact\effective_plastic_strain" 1 all
+
+exit

generation_evidence/export/compact_floorfrontR_elements.cfile

@@ -0,0 +1,12 @@
+open d3plot "d3plot"
+
+genselect target part
+genselect target element
+genselect element add part 2000395/0
+
+etime 9
+xyplot 1 savefile curve_file "results_compact\effective_stress" 1 all
+etime 7
+xyplot 1 savefile curve_file "results_compact\effective_plastic_strain" 1 all
+
+exit

generation_evidence/export/compact_floorfrontR_nodes.cfile

@@ -0,0 +1,14 @@
+open d3plot "d3plot"
+
+genselect target part
+genselect target node
+genselect node add part 2000395/0
+
+ntime 5
+xyplot 1 savefile curve_file "results_compact\x_displacement" 1 all
+ntime 6
+xyplot 1 savefile curve_file "results_compact\y_displacement" 1 all
+ntime 7
+xyplot 1 savefile curve_file "results_compact\z_displacement" 1 all
+
+exit

generation_evidence/export/compact_floorfrontdriver.cfile

@@ -0,0 +1,23 @@
+open d3plot "d3plot"
+
+genselect target part
+genselect target node
+genselect node add part 2000394/0
+
+ntime 5
+xyplot 1 savefile curve_file "results_compact\x_displacement" 1 all
+ntime 6
+xyplot 1 savefile curve_file "results_compact\y_displacement" 1 all
+ntime 7
+xyplot 1 savefile curve_file "results_compact\z_displacement" 1 all
+
+genselect target part
+genselect target element
+genselect element add part 2000394/0
+
+etime 9
+xyplot 1 savefile curve_file "results_compact\effective_stress" 1 all
+etime 7
+xyplot 1 savefile curve_file "results_compact\effective_plastic_strain" 1 all
+
+exit

generation_evidence/export/compact_trunkfloor.cfile

@@ -0,0 +1,23 @@
+open d3plot "d3plot"
+
+genselect target part
+genselect target node
+genselect node add part 2000447/0
+
+ntime 5
+xyplot 1 savefile curve_file "results_compact\x_displacement" 1 all
+ntime 6
+xyplot 1 savefile curve_file "results_compact\y_displacement" 1 all
+ntime 7
+xyplot 1 savefile curve_file "results_compact\z_displacement" 1 all
+
+genselect target part
+genselect target element
+genselect element add part 2000447/0
+
+etime 9
+xyplot 1 savefile curve_file "results_compact\effective_stress" 1 all
+etime 7
+xyplot 1 savefile curve_file "results_compact\effective_plastic_strain" 1 all
+
+exit

generation_evidence/impactor/add_impactor_to_floor_panels.py

@@ -0,0 +1,530 @@
+import math
+import re
+from pathlib import Path
+
+
+REFERENCE = Path("bottomimpact_60JP1.key")
+PANEL_GLOB = "floor_panel_largest_*.key"
+
+BALL_SOURCE_PID = 9636
+BALL_PID = 9636
+BALL_SECID = 9636
+BALL_MID = 174
+BALL_VZ = 3464.1
+TERMINATION_TIME = 0.03
+
+ADAPT_FREQ = 0.0002
+ADAPT_TOL = 5.0
+ADAPT_OPT = 2
+ADAPT_MAX_LEVEL = 2
+
+CONTACT_ID = 57
+GRAVITY_CURVE_ID = 251
+GRAVITY_Z = 9810.0
+
+
+def is_keyword(line):
+    return line.startswith("*")
+
+
+def first_int(line):
+    fixed = line[:10].strip()
+    if fixed:
+        try:
+            return int(float(fixed))
+        except ValueError:
+            pass
+    fields = line.strip().split()
+    if not fields:
+        return None
+    try:
+        return int(float(fields[0]))
+    except ValueError:
+        return None
+
+
+def parse_int_fields(line):
+    values = []
+    for field in line.strip().split():
+        try:
+            values.append(int(float(field)))
+        except ValueError:
+            pass
+    return values
+
+
+def parse_fixed_ints(line, width=8, count=6):
+    values = []
+    for i in range(count):
+        chunk = line[i * width : (i + 1) * width].strip()
+        if not chunk:
+            values.append(0)
+            continue
+        try:
+            values.append(int(chunk))
+        except ValueError:
+            return None
+    return values
+
+
+def read_blocks(path):
+    block = []
+    with path.open("r", encoding="utf-8", errors="ignore") as f:
+        for line in f:
+            if is_keyword(line) and block:
+                yield block
+                block = [line]
+            else:
+                block.append(line)
+    if block:
+        yield block
+
+
+def data_lines(block):
+    for line in block[1:]:
+        stripped = line.strip()
+        if stripped and not stripped.startswith("$"):
+            yield line
+
+
+def block_id(block):
+    for line in data_lines(block):
+        value = first_int(line)
+        if value is not None:
+            return value
+    return None
+
+
+def parse_part_pid(block):
+    for line in data_lines(block):
+        fields = parse_int_fields(line)
+        if len(fields) >= 3:
+            return fields[0]
+    return None
+
+
+def parse_nodes_from_block(block):
+    nodes = {}
+    for line in block[1:]:
+        stripped = line.strip()
+        if not stripped or stripped.startswith("$"):
+            continue
+        fields = stripped.split()
+        try:
+            nid = int(float(fields[0]))
+            nodes[nid] = (float(fields[1]), float(fields[2]), float(fields[3]))
+        except (IndexError, ValueError):
+            continue
+    return nodes
+
+
+def parse_shell_line(line):
+    fields = parse_int_fields(line)
+    if len(fields) >= 6:
+        return fields[:6]
+    fixed = parse_fixed_ints(line, width=8, count=6)
+    if fixed and fixed[0] and fixed[1]:
+        return fixed
+    return None
+
+
+def shell_edges(nids):
+    clean = []
+    for nid in nids:
+        if nid > 0 and nid not in clean:
+            clean.append(nid)
+    if len(clean) < 3:
+        return []
+    return [
+        tuple(sorted((clean[i], clean[(i + 1) % len(clean)])))
+        for i in range(len(clean))
+    ]
+
+
+def bbox(points):
+    xs = [p[0] for p in points]
+    ys = [p[1] for p in points]
+    zs = [p[2] for p in points]
+    return (min(xs), max(xs), min(ys), max(ys), min(zs), max(zs))
+
+
+def center_of_bbox(points):
+    xmin, xmax, ymin, ymax, zmin, zmax = bbox(points)
+    return ((xmin + xmax) / 2.0, (ymin + ymax) / 2.0, (zmin + zmax) / 2.0)
+
+
+def extract_reference_ball():
+    nodes = {}
+    all_shell_elements = []
+    ball_part = None
+    ball_section = None
+    ball_material = None
+    control_blocks = []
+
+    for block in read_blocks(REFERENCE):
+        key = block[0].strip().upper()
+        if key.startswith("*CONTROL_"):
+            control_blocks.append(block)
+        elif key == "*NODE":
+            nodes.update(parse_nodes_from_block(block))
+        elif key == "*ELEMENT_SHELL":
+            for line in block[1:]:
+                stripped = line.strip()
+                if not stripped or stripped.startswith("$"):
+                    continue
+                parsed = parse_shell_line(line)
+                if parsed:
+                    all_shell_elements.append(parsed)
+        elif key == "*PART" and parse_part_pid(block) == BALL_SOURCE_PID:
+            ball_part = block
+        elif key.startswith("*SECTION_SHELL") and block_id(block) == BALL_SECID:
+            ball_section = block
+        elif key.startswith("*MAT_RIGID") and block_id(block) == BALL_MID:
+            ball_material = block
+
+    ball_elements = [elem for elem in all_shell_elements if elem[1] == BALL_SOURCE_PID]
+    ball_node_ids = sorted({nid for elem in ball_elements for nid in elem[2:6] if nid > 0})
+    ball_nodes = {nid: nodes[nid] for nid in ball_node_ids}
+
+    if not ball_elements or not ball_nodes:
+        raise SystemExit("Failed to extract reference ball mesh")
+    if not (ball_part and ball_section and ball_material):
+        raise SystemExit("Failed to extract reference ball part/section/material")
+
+    points = list(ball_nodes.values())
+    xmin, xmax, ymin, ymax, zmin, zmax = bbox(points)
+    center = center_of_bbox(points)
+    radius = max(xmax - xmin, ymax - ymin, zmax - zmin) / 2.0
+    return {
+        "part": ball_part,
+        "section": ball_section,
+        "material": ball_material,
+        "elements": ball_elements,
+        "nodes": ball_nodes,
+        "center": center,
+        "radius": radius,
+        "controls": control_blocks,
+    }
+
+
+def parse_panel(path):
+    blocks = list(read_blocks(path))
+    nodes = {}
+    shell_elements = []
+    part_ids = []
+    boundary_node_sets = {}
+    keywords = []
+
+    mode = None
+    for block in blocks:
+        key = block[0].strip().upper()
+        keywords.append(key)
+        if key == "*NODE":
+            nodes.update(parse_nodes_from_block(block))
+        elif key == "*ELEMENT_SHELL":
+            for line in block[1:]:
+                stripped = line.strip()
+                if not stripped or stripped.startswith("$"):
+                    continue
+                parsed = parse_shell_line(line)
+                if parsed:
+                    shell_elements.append(parsed)
+        elif key == "*PART":
+            pid = parse_part_pid(block)
+            if pid is not None:
+                part_ids.append(pid)
+
+    if len(part_ids) != 1:
+        raise SystemExit(f"{path} must contain exactly one panel part, found {part_ids}")
+    panel_pid = part_ids[0]
+    panel_node_ids = sorted({nid for elem in shell_elements if elem[1] == panel_pid for nid in elem[2:6] if nid > 0})
+    panel_points = [nodes[nid] for nid in panel_node_ids]
+    xmin, xmax, ymin, ymax, zmin, zmax = bbox(panel_points)
+
+    edge_counts = {}
+    for elem in shell_elements:
+        if elem[1] != panel_pid:
+            continue
+        for edge in shell_edges(elem[2:6]):
+            edge_counts[edge] = edge_counts.get(edge, 0) + 1
+    boundary_nodes = set()
+    for edge, count in edge_counts.items():
+        if count == 1:
+            boundary_nodes.update(edge)
+
+    return {
+        "blocks": blocks,
+        "panel_pid": panel_pid,
+        "nodes": nodes,
+        "shell_elements": shell_elements,
+        "bbox": (xmin, xmax, ymin, ymax, zmin, zmax),
+        "boundary_nodes": boundary_nodes,
+    }
+
+
+def next_ids(panel):
+    used_nodes = set(panel["nodes"])
+    used_elems = {elem[0] for elem in panel["shell_elements"]}
+    node_base = max(max(used_nodes) + 1, 9000000)
+    elem_base = max(max(used_elems) + 1, 9000000)
+    return node_base, elem_base
+
+
+def translated_ball(ball, panel):
+    xmin, xmax, ymin, ymax, zmin, zmax = panel["bbox"]
+    target_center = (
+        (xmin + xmax) / 2.0,
+        (ymin + ymax) / 2.0,
+        zmin - ball["radius"] - 5.0,
+    )
+    sx, sy, sz = ball["center"]
+    tx, ty, tz = target_center
+    return (tx - sx, ty - sy, tz - sz), target_center
+
+
+def update_part_id_block(block, pid, secid, mid):
+    out = []
+    replaced = False
+    for line in block:
+        if not replaced and not line.strip().startswith("$") and not line.startswith("*") and len(parse_int_fields(line)) >= 3:
+            out.append(f"{pid:10d}{secid:10d}{mid:10d}         0         0         0         0         0\n")
+            replaced = True
+        else:
+            out.append(line)
+    return out
+
+
+def update_section_id_block(block, secid):
+    out = []
+    replaced = False
+    for line in block:
+        if not replaced and not line.strip().startswith("$") and not line.startswith("*") and first_int(line) is not None:
+            rest = line[10:] if len(line) > 10 else "\n"
+            out.append(f"{secid:10d}{rest}")
+            replaced = True
+        else:
+            out.append(line)
+    return out
+
+
+def update_material_id_block(block, mid):
+    out = []
+    replaced = False
+    for line in block:
+        if not replaced and not line.strip().startswith("$") and not line.startswith("*") and first_int(line) is not None:
+            rest = line[10:] if len(line) > 10 else "\n"
+            out.append(f"{mid:10d}{rest}")
+            replaced = True
+        else:
+            out.append(line)
+    return out
+
+
+def update_control_termination_block(block):
+    out = []
+    replaced = False
+    for line in block:
+        if not replaced and not line.strip().startswith("$") and not line.startswith("*"):
+            out.append(f"{TERMINATION_TIME:10.4f}         0        0.        0.        0.         0\n")
+            replaced = True
+        else:
+            out.append(line)
+    return out
+
+
+def update_part_adpopt_block(block, adpopt):
+    out = []
+    replaced = False
+    for line in block:
+        if not replaced and not line.strip().startswith("$") and not line.startswith("*"):
+            fields = parse_int_fields(line)
+            if len(fields) >= 3:
+                while len(fields) < 8:
+                    fields.append(0)
+                fields[6] = adpopt
+                out.append("".join(f"{item:10d}" for item in fields[:8]) + "\n")
+                replaced = True
+                continue
+        out.append(line)
+    return out
+
+
+def write_control_adaptive(out):
+    out.write("*CONTROL_ADAPTIVE\n")
+    out.write("$# adpfreq    adptol    adpopt    maxlvl    tbirth    tdeath     lcadp    ioflag\n")
+    out.write(
+        f"{ADAPT_FREQ:10.6f}{ADAPT_TOL:10.1f}{ADAPT_OPT:10d}{ADAPT_MAX_LEVEL:10d}"
+        f"{0.0:10.1f}{TERMINATION_TIME:10.4f}{0:10d}{0:10d}\n"
+    )
+
+
+def write_node_set(out, sid, title, node_ids):
+    out.write("*SET_NODE_LIST_TITLE\n")
+    out.write(f"{title}\n")
+    out.write("$#     sid       da1       da2       da3       da4    solver\n")
+    out.write(f"{sid:10d}       0.0       0.0       0.0       0.0MECH\n")
+    out.write("$#    nid1      nid2      nid3      nid4      nid5      nid6      nid7      nid8\n")
+    row = []
+    for nid in sorted(node_ids):
+        row.append(nid)
+        if len(row) == 8:
+            out.write("".join(f"{item:10d}" for item in row) + "\n")
+            row = []
+    if row:
+        out.write("".join(f"{item:10d}" for item in row) + "\n")
+
+
+def format_node(nid, xyz):
+    x, y, z = xyz
+    return f"{nid:8d}{x:16.8f}{y:16.8f}{z:16.8f}       0       0\n"
+
+
+def format_shell(eid, pid, nids):
+    padded = list(nids[:4])
+    while len(padded) < 4:
+        padded.append(padded[-1])
+    return f"{eid:8d}{pid:8d}{padded[0]:8d}{padded[1]:8d}{padded[2]:8d}{padded[3]:8d}\n"
+
+
+def strip_end(blocks):
+    return [block for block in blocks if block[0].strip().upper() != "*END"]
+
+
+def output_path(path):
+    return path.with_name(path.stem + "_with_ball.key")
+
+
+def add_ball_to_panel(path, ball):
+    panel = parse_panel(path)
+    node_base, elem_base = next_ids(panel)
+    translation, target_center = translated_ball(ball, panel)
+    dx, dy, dz = translation
+
+    node_map = {}
+    moved_nodes = {}
+    for index, (old_nid, xyz) in enumerate(sorted(ball["nodes"].items())):
+        new_nid = node_base + index
+        node_map[old_nid] = new_nid
+        moved_nodes[new_nid] = (xyz[0] + dx, xyz[1] + dy, xyz[2] + dz)
+
+    moved_elements = []
+    for index, elem in enumerate(ball["elements"]):
+        new_eid = elem_base + index
+        new_nids = [node_map[nid] for nid in elem[2:6] if nid > 0]
+        moved_elements.append((new_eid, BALL_PID, new_nids))
+
+    out_path = output_path(path)
+    panel_pid = panel["panel_pid"]
+    boundary_set_id = 9100000 + (panel_pid % 10000)
+
+    with out_path.open("w", encoding="utf-8", newline="\n") as out:
+        out.write("*KEYWORD\n")
+        out.write("$ Control cards copied from bottomimpact_60JP1.key\n")
+        for block in ball["controls"]:
+            if block[0].strip().upper() == "*CONTROL_TERMINATION":
+                out.writelines(update_control_termination_block(block))
+            else:
+                out.writelines(block)
+            if not block[-1].endswith("\n"):
+                out.write("\n")
+        write_control_adaptive(out)
+        out.write("$-------------------------------------------------------------------------------\n")
+
+        for block in strip_end(panel["blocks"]):
+            key = block[0].strip().upper()
+            if key == "*KEYWORD":
+                continue
+            if key == "*PART" and parse_part_pid(block) == panel_pid:
+                out.writelines(update_part_adpopt_block(block, 1))
+                continue
+            if key == "*NODE":
+                out.writelines(block)
+                for nid in sorted(moved_nodes):
+                    out.write(format_node(nid, moved_nodes[nid]))
+                continue
+            if key == "*ELEMENT_SHELL":
+                out.writelines(block)
+                for eid, pid, nids in moved_elements:
+                    out.write(format_shell(eid, pid, nids))
+                continue
+            if key.startswith("*SET_NODE_LIST"):
+                # Regenerate the fixed boundary set after adding the ball.
+                continue
+            if key.startswith("*BOUNDARY_SPC_SET"):
+                continue
+            out.writelines(block)
+
+        out.write("$-------------------------------------------------------------------------------\n")
+        out.writelines(update_part_id_block(ball["part"], BALL_PID, BALL_SECID, BALL_MID))
+        out.writelines(update_section_id_block(ball["section"], BALL_SECID))
+        out.writelines(update_material_id_block(ball["material"], BALL_MID))
+
+        out.write("$-------------------------------------------------------------------------------\n")
+        write_node_set(out, boundary_set_id, f"PID {panel_pid} outer boundary nodes - fixed", panel["boundary_nodes"])
+        out.write("*BOUNDARY_SPC_SET\n")
+        out.write("$#    nsid       cid      dofx      dofy      dofz     dofrx     dofry     dofrz\n")
+        out.write(f"{boundary_set_id:10d}         0         1         1         1         1         1         1\n")
+
+        out.write("*CONTACT_AUTOMATIC_SURFACE_TO_SURFACE_ID\n")
+        out.write(f"{CONTACT_ID:10d}        ball\n")
+        out.write("$#    ssid      msid     sstyp     mstyp    sboxid    mboxid       spr       mpr\n")
+        out.write(f"{panel_pid:10d}{BALL_PID:10d}         3         3         0         0         0         0\n")
+        out.write("$#      fs        fd        dc        vc       vdc    penchk        bt        dt\n")
+        out.write("      0.15      0.15       0.0       0.0       0.0         0       0.0       0.0\n")
+        out.write("$#     sfs       sfm       sst       mst      sfst      sfmt       fsf       vsf\n")
+        out.write("       1.0       1.0       1.0       1.0       1.0       1.0       1.0       1.0\n")
+        out.write("$#    soft    sofscl    lcidab    maxpar     sbopt     depth     bsort    frcfrq\n")
+        out.write("         1       0.0         0       0.0       0.0         0         0         0\n")
+        out.write("$#  penmax    thkopt    shlthk     snlog      isym     i2d3d    sldthk    sldstf\n")
+        out.write("       0.0         0         0         0         0         0       0.0       0.0\n")
+
+        out.write("*INITIAL_VELOCITY_RIGID_BODY\n")
+        out.write("$      PID|       VX|       VY|       VZ|      VXR|      VYR|      VZR|     ICID|\n")
+        out.write(f"{BALL_PID:10d}        0.        0.{BALL_VZ:10.1f}        0.        0.        0.         0\n")
+
+        out.write("*LOAD_BODY_Z\n")
+        out.write(f"{GRAVITY_CURVE_ID:10d}{GRAVITY_Z:10.1f}\n")
+        out.write("*DEFINE_CURVE\n")
+        out.write("$#    lcid      sidr       sfa       sfo      offa      offo    dattyp\n")
+        out.write(f"{GRAVITY_CURVE_ID:10d}         0       1.0       1.0       0.0       0.0         0\n")
+        out.write("$#                a1                  o1\n")
+        out.write("                 0.0                 1.0\n")
+        out.write("              1000.0                 1.0\n")
+
+        out.write("*DATABASE_BINARY_D3PLOT\n")
+        out.write("$#      dt      lcdt      beam     npltc    psetid\n")
+        out.write("  0.000200         0         0         0         0\n")
+        out.write("*DATABASE_GLSTAT\n")
+        out.write("  0.000100\n")
+        out.write("*DATABASE_MATSUM\n")
+        out.write("  0.000100\n")
+        out.write("*DATABASE_RCFORC\n")
+        out.write("  0.000100\n")
+
+        out.write("*END\n")
+
+    print(
+        f"{out_path.name}: panel_pid={panel_pid}, ball_nodes={len(moved_nodes)}, "
+        f"ball_elements={len(moved_elements)}, ball_center=({target_center[0]:.3f}, "
+        f"{target_center[1]:.3f}, {target_center[2]:.3f}), radius={ball['radius']:.3f}"
+    )
+    return out_path
+
+
+def main():
+    ball = extract_reference_ball()
+    print(
+        f"Reference ball: nodes={len(ball['nodes'])}, elements={len(ball['elements'])}, "
+        f"center=({ball['center'][0]:.3f}, {ball['center'][1]:.3f}, {ball['center'][2]:.3f}), "
+        f"radius={ball['radius']:.3f}"
+    )
+    panel_paths = sorted(Path(".").glob(PANEL_GLOB))
+    panel_paths = [path for path in panel_paths if not path.stem.endswith("_with_ball")]
+    if len(panel_paths) < 3:
+        raise SystemExit(f"Expected at least 3 panel key files matching {PANEL_GLOB}")
+    for path in panel_paths[:3]:
+        add_ball_to_panel(path, ball)
+
+
+if __name__ == "__main__":
+    main()

generation_evidence/lhs/extend_floorfrontdriver_lhs_cases_to_500.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import csv
+from collections import Counter
+from pathlib import Path
+
+import numpy as np
+
+import generate_floorfrontdriver_lhs_cases as lhs
+import generate_floorfrontdriver_random_cases as base
+
+
+CASE_ROOT = Path("cases_floorfrontdriver_lhs_100")
+START_CASE = 201
+END_CASE = 500
+SEED = 20260722
+TRIALS = 128
+
+
+def main() -> None:
+    manifest_path = CASE_ROOT / "case_manifest.csv"
+    if not manifest_path.exists():
+        raise FileNotFoundError(manifest_path)
+    with manifest_path.open(newline="", encoding="utf-8") as handle:
+        reader = csv.DictReader(handle)
+        fieldnames = list(reader.fieldnames or [])
+        existing = list(reader)
+
+    expected_existing = START_CASE - 1
+    expected_names = [f"case{number:03d}" for number in range(1, START_CASE)]
+    if len(existing) != expected_existing or [row["case"] for row in existing] != expected_names:
+        raise RuntimeError(
+            f"Expected an uninterrupted case001-case{expected_existing:03d} manifest; "
+            f"found {len(existing)} rows"
+        )
+    for number in range(START_CASE, END_CASE + 1):
+        case_dir = CASE_ROOT / f"case{number:03d}"
+        if case_dir.exists() and any(case_dir.iterdir()):
+            raise RuntimeError(f"Refusing to overwrite existing case directory: {case_dir}")
+
+    template = base.parse_template(lhs.TEMPLATE)
+    used_element_ids = {int(row["impact_element_id"]) for row in existing}
+    available = [item for item in template["candidates"] if int(item["eid"]) not in used_element_ids]
+    count = END_CASE - START_CASE + 1
+    design, impacts, score = lhs.make_design(count, available, SEED, TRIALS)
+
+    added: list[dict[str, object]] = []
+    for number, unit, impact in zip(range(START_CASE, END_CASE + 1), design, impacts):
+        speed = lhs.scale(float(unit[2]), lhs.SPEED_RANGE)
+        mass_ratio = lhs.scale(float(unit[3]), lhs.MASS_RATIO_RANGE)
+        theta_deg = lhs.scale(float(unit[4]), lhs.THETA_RANGE_DEG)
+        phi_deg = lhs.scale(float(unit[5]), lhs.PHI_RANGE_DEG)
+        material_index = min(int(unit[6] * len(lhs.MATERIALS)), len(lhs.MATERIALS) - 1)
+        material = lhs.MATERIALS[material_index]
+        velocity = speed * lhs.direction(theta_deg, phi_deg)
+        density = lhs.BASE_DENSITY * mass_ratio
+        mass = lhs.BASE_MASS * mass_ratio
+
+        case_name = f"case{number:03d}"
+        case_dir = CASE_ROOT / case_name
+        case_dir.mkdir(parents=True, exist_ok=True)
+        key_path = case_dir / f"{case_name}.key"
+        key_lines, ball_center = lhs.make_case_key(template, impact, velocity, density, material)
+        key_path.write_text("".join(key_lines), encoding="utf-8", newline="\n")
+        center = impact["center"]
+        row = {
+            "case": case_name,
+            "key_file": str(key_path),
+            "panel_pid": lhs.PANEL_PID,
+            "impact_element_id": impact["eid"],
+            "impact_x": f"{center[0]:.8f}",
+            "impact_y": f"{center[1]:.8f}",
+            "impact_z": f"{center[2]:.8f}",
+            "ball_center_x": f"{ball_center[0]:.8f}",
+            "ball_center_y": f"{ball_center[1]:.8f}",
+            "ball_center_z": f"{ball_center[2]:.8f}",
+            "velocity_vx": f"{velocity[0]:.8f}",
+            "velocity_vy": f"{velocity[1]:.8f}",
+            "velocity_vz": f"{velocity[2]:.8f}",
+            "impact_speed": f"{speed:.8f}",
+            "mass_ratio": f"{mass_ratio:.8f}",
+            "impactor_mass": f"{mass:.10f}",
+            "impactor_density": f"{density:.10E}",
+            "theta_deg": f"{theta_deg:.8f}",
+            "phi_deg": f"{phi_deg:.8f}",
+            "material_index": material_index,
+            "material_name": material["name"],
+            "material_young_mpa": f"{material['young_mpa']:.1f}",
+            "material_poisson": f"{material['poisson']:.4f}",
+            "min_boundary_distance_mm": f"{impact['min_boundary_distance']:.8f}",
+            **{
+                f"lhs_u_{name}": f"{unit[index]:.10f}"
+                for index, name in enumerate(("x", "y", "v", "m", "theta", "phi", "material"))
+            },
+        }
+        if set(row) != set(fieldnames):
+            raise RuntimeError("Existing manifest schema differs from the LHS generator schema")
+        added.append(row)
+
+    temporary = manifest_path.with_suffix(".csv.tmp")
+    with temporary.open("w", newline="", encoding="utf-8") as handle:
+        writer = csv.DictWriter(handle, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(existing)
+        writer.writerows(added)
+    temporary.replace(manifest_path)
+
+    all_rows = existing + added
+    counts = Counter(row["material_name"] for row in all_rows)
+    summary = (
+        "floorfrontdriver sequential constrained LHS extension\n"
+        f"preserved_cases=1-{START_CASE - 1}\n"
+        f"added_cases={START_CASE}-{END_CASE}\n"
+        f"added_count={count}\ntotal_cases={len(all_rows)}\n"
+        f"extension_seed={SEED}\nextension_trials={TRIALS}\n"
+        f"extension_normalized_maximin_score={score:.8f}\n"
+        f"extension_minimum_xy_spacing_mm={lhs.min_impact_spacing(impacts):.8f}\n"
+        f"combined_material_counts={dict(counts)}\n"
+        "The added 300 cases form an independent constrained LHS batch.\n"
+    )
+    (CASE_ROOT / "lhs_extension_201_500_summary.txt").write_text(
+        summary, encoding="utf-8", newline="\n"
+    )
+    print(summary, end="")
+    print(f"manifest={manifest_path}")
+
+
+if __name__ == "__main__":
+    main()

generation_evidence/lhs/extend_floorfrontdriver_lhs_to_200.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import csv
+from collections import Counter
+from pathlib import Path
+
+import numpy as np
+
+import generate_floorfrontdriver_lhs_cases as lhsgen
+import generate_floorfrontdriver_random_cases as base
+
+
+ROOT = Path("cases_floorfrontdriver_lhs_100")
+TOTAL_CASES = 200
+SEED = 20260722
+TRIALS = 128
+PARAMETER_NAMES = ("v", "m", "theta", "phi", "material")
+
+
+def complementary_values(rows: list[dict], name: str, rng: np.random.Generator) -> np.ndarray:
+    occupied = {int(np.floor(TOTAL_CASES * float(row[f"lhs_u_{name}"]))) for row in rows}
+    missing = np.asarray(sorted(set(range(TOTAL_CASES)) - occupied), dtype=np.int64)
+    if len(missing) != 100:
+        raise RuntimeError(f"{name}: expected 100 unoccupied nested-LHS bins, found {len(missing)}")
+    rng.shuffle(missing)
+    return (missing + rng.random(len(missing))) / TOTAL_CASES
+
+
+def select_design(template: dict, old_rows: list[dict]) -> tuple[np.ndarray, list[dict], float]:
+    old_eids = {int(row["impact_element_id"]) for row in old_rows}
+    candidates = [item for item in template["candidates"] if int(item["eid"]) not in old_eids]
+    old_design = np.asarray(
+        [
+            [float(row[f"lhs_u_{name}"]) for name in ("x", "y", *PARAMETER_NAMES)]
+            for row in old_rows
+        ],
+        dtype=np.float64,
+    )
+    root_rng = np.random.default_rng(SEED)
+    best_design = None
+    best_impacts = None
+    best_score = -np.inf
+
+    for _ in range(TRIALS):
+        rng = np.random.default_rng(int(root_rng.integers(0, np.iinfo(np.int64).max)))
+        design = np.empty((100, 7), dtype=np.float64)
+        design[:, :2] = lhsgen.lhs(100, 2, rng)
+        for column, name in enumerate(PARAMETER_NAMES, start=2):
+            design[:, column] = complementary_values(old_rows, name, rng)
+        impacts, mapped = lhsgen.map_xy_to_panel(design, candidates, rng)
+        scored_new = mapped.copy()
+        scored_old = old_design.copy()
+        scored_new[:, 6] = (np.floor(scored_new[:, 6] * 3) + 0.5) / 3
+        scored_old[:, 6] = (np.floor(scored_old[:, 6] * 3) + 0.5) / 3
+        score = lhsgen.pairwise_min_distance(np.vstack((scored_old, scored_new)))
+        if score > best_score:
+            best_design, best_impacts, best_score = mapped, impacts, score
+
+    assert best_design is not None and best_impacts is not None
+    return best_design, best_impacts, best_score
+
+
+def main() -> None:
+    manifest = ROOT / "case_manifest.csv"
+    with manifest.open(newline="", encoding="utf-8") as handle:
+        old_rows = list(csv.DictReader(handle))
+    if len(old_rows) == TOTAL_CASES:
+        print("[OK] manifest already contains 200 cases; nothing to generate")
+        return
+    if len(old_rows) != 100:
+        raise RuntimeError(f"Expected existing 100-case manifest, found {len(old_rows)} rows")
+
+    template = base.parse_template(lhsgen.TEMPLATE)
+    design, impacts, score = select_design(template, old_rows)
+    new_rows: list[dict] = []
+    for case_number, (unit, impact) in enumerate(zip(design, impacts), start=101):
+        speed = lhsgen.scale(float(unit[2]), lhsgen.SPEED_RANGE)
+        mass_ratio = lhsgen.scale(float(unit[3]), lhsgen.MASS_RATIO_RANGE)
+        theta_deg = lhsgen.scale(float(unit[4]), lhsgen.THETA_RANGE_DEG)
+        phi_deg = lhsgen.scale(float(unit[5]), lhsgen.PHI_RANGE_DEG)
+        material_index = min(int(unit[6] * len(lhsgen.MATERIALS)), len(lhsgen.MATERIALS) - 1)
+        material = lhsgen.MATERIALS[material_index]
+        velocity = speed * lhsgen.direction(theta_deg, phi_deg)
+        density = lhsgen.BASE_DENSITY * mass_ratio
+        mass = lhsgen.BASE_MASS * mass_ratio
+        case_name = f"case{case_number:03d}"
+        case_dir = ROOT / case_name
+        case_dir.mkdir(parents=True, exist_ok=True)
+        key_path = case_dir / f"{case_name}.key"
+        key_lines, ball_center = lhsgen.make_case_key(template, impact, velocity, density, material)
+        key_path.write_text("".join(key_lines), encoding="utf-8", newline="\n")
+        center = impact["center"]
+        new_rows.append(
+            {
+                "case": case_name,
+                "key_file": str(key_path),
+                "panel_pid": lhsgen.PANEL_PID,
+                "impact_element_id": impact["eid"],
+                "impact_x": f"{center[0]:.8f}",
+                "impact_y": f"{center[1]:.8f}",
+                "impact_z": f"{center[2]:.8f}",
+                "ball_center_x": f"{ball_center[0]:.8f}",
+                "ball_center_y": f"{ball_center[1]:.8f}",
+                "ball_center_z": f"{ball_center[2]:.8f}",
+                "velocity_vx": f"{velocity[0]:.8f}",
+                "velocity_vy": f"{velocity[1]:.8f}",
+                "velocity_vz": f"{velocity[2]:.8f}",
+                "impact_speed": f"{speed:.8f}",
+                "mass_ratio": f"{mass_ratio:.8f}",
+                "impactor_mass": f"{mass:.10f}",
+                "impactor_density": f"{density:.10E}",
+                "theta_deg": f"{theta_deg:.8f}",
+                "phi_deg": f"{phi_deg:.8f}",
+                "material_index": material_index,
+                "material_name": material["name"],
+                "material_young_mpa": f"{material['young_mpa']:.1f}",
+                "material_poisson": f"{material['poisson']:.4f}",
+                "min_boundary_distance_mm": f"{impact['min_boundary_distance']:.8f}",
+                **{
+                    f"lhs_u_{name}": f"{unit[index]:.10f}"
+                    for index, name in enumerate(("x", "y", "v", "m", "theta", "phi", "material"))
+                },
+            }
+        )
+
+    all_rows = old_rows + new_rows
+    temporary = manifest.with_suffix(".csv.tmp")
+    with temporary.open("w", newline="", encoding="utf-8") as handle:
+        writer = csv.DictWriter(handle, fieldnames=list(all_rows[0]))
+        writer.writeheader()
+        writer.writerows(all_rows)
+    temporary.replace(manifest)
+
+    counts = Counter(row["material_name"] for row in all_rows)
+    summary = (
+        f"cases={len(all_rows)}\nseed_extension={SEED}\ntrials={TRIALS}\n"
+        f"combined_normalized_maximin_score={score:.8f}\n"
+        f"material_counts={dict(counts)}\n"
+        "case001-case100 preserved; case101-case200 use complementary 200-bin nested LHS strata.\n"
+    )
+    (ROOT / "lhs_design_summary_200.txt").write_text(summary, encoding="utf-8", newline="\n")
+    print(summary, end="")
+
+
+if __name__ == "__main__":
+    main()

generation_evidence/lhs/floorfrontR/lhs_design_summary.txt

@@ -0,0 +1,13 @@
+floorfrontR constrained LHS design
+cases=500
+seed=20260728
+trials=128
+normalized_maximin_score=0.17315438
+minimum_xy_spacing_mm=5.02509788
+speed_range_mm_per_s=(1732.05, 5196.15)
+mass_ratio_range=(0.75, 1.25)
+theta_range_deg=(0.0, 15.0)
+phi_range_deg=(0.0, 360.0)
+material_counts={'titanium_rigid': 167, 'aluminum_rigid': 166, 'steel_rigid': 167}
+theta is measured from global +Z; phi is measured in global XY from +X toward +Y.
+Rigid material class controls E/nu used by contact; mass ratio independently scales density.

generation_evidence/lhs/floorfrontdriver/lhs_design_summary.txt

@@ -0,0 +1,13 @@
+floorfrontdriver constrained LHS design
+cases=100
+seed=20260721
+trials=128
+normalized_maximin_score=0.34123189
+minimum_xy_spacing_mm=9.70521446
+speed_range_mm_per_s=(1732.05, 5196.15)
+mass_ratio_range=(0.75, 1.25)
+theta_range_deg=(0.0, 15.0)
+phi_range_deg=(0.0, 360.0)
+material_counts={'titanium_rigid': 33, 'steel_rigid': 33, 'aluminum_rigid': 34}
+theta is measured from global +Z; phi is measured in global XY from +X toward +Y.
+Rigid material class controls E/nu used by contact; mass ratio independently scales density.

generation_evidence/lhs/floorfrontdriver/lhs_design_summary_200.txt

@@ -0,0 +1,6 @@
+cases=200
+seed_extension=20260722
+trials=128
+combined_normalized_maximin_score=0.25806791
+material_counts={'titanium_rigid': 67, 'steel_rigid': 66, 'aluminum_rigid': 67}
+case001-case100 preserved; case101-case200 use complementary 200-bin nested LHS strata.

generation_evidence/lhs/floorfrontdriver/lhs_extension_201_500_summary.txt

@@ -0,0 +1,11 @@
+floorfrontdriver sequential constrained LHS extension
+preserved_cases=1-200
+added_cases=201-500
+added_count=300
+total_cases=500
+extension_seed=20260722
+extension_trials=128
+extension_normalized_maximin_score=0.22052899
+extension_minimum_xy_spacing_mm=6.43164167
+combined_material_counts={'titanium_rigid': 167, 'steel_rigid': 166, 'aluminum_rigid': 167}
+The added 300 cases form an independent constrained LHS batch.

generation_evidence/lhs/generate_floorfrontR_lhs_cases.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+
+import generate_floorfrontdriver_lhs_cases as lhs
+import generate_floorfrontdriver_random_cases as base
+
+
+lhs.TEMPLATE = Path("floor_panel_largest_2_pid_2000395_133_floorfrontR_with_ball.key")
+lhs.OUTPUT_ROOT = Path("cases_floorfrontR_lhs_500")
+lhs.DESIGN_NAME = "floorfrontR"
+lhs.DEFAULT_CASES = 500
+lhs.DEFAULT_SEED = 20260728
+lhs.PANEL_PID = 2000395
+
+# The shared template parser selects valid panel elements through this module global.
+base.PANEL_PID = lhs.PANEL_PID
+
+
+if __name__ == "__main__":
+    lhs.main()

generation_evidence/lhs/generate_floorfrontdriver_lhs_cases.py

@@ -0,0 +1,300 @@
+from __future__ import annotations
+
+import argparse
+import csv
+import math
+from collections import Counter
+from pathlib import Path
+
+import numpy as np
+
+import generate_floorfrontdriver_random_cases as base
+
+
+TEMPLATE = Path("floor_panel_largest_3_pid_2000394_373_floorfrontdriver_with_ball.key")
+OUTPUT_ROOT = Path("cases_floorfrontdriver_lhs_100")
+DESIGN_NAME = "floorfrontdriver"
+DEFAULT_CASES = 100
+DEFAULT_SEED = 20260721
+PANEL_PID = 2000394
+BALL_PID = 9636
+BALL_MID = 174
+BASE_DENSITY = 5.205e-5
+BASE_MASS = 0.01
+BALL_GAP_MM = 5.0
+
+SPEED_RANGE = (1732.05, 5196.15)
+MASS_RATIO_RANGE = (0.75, 1.25)
+THETA_RANGE_DEG = (0.0, 15.0)
+PHI_RANGE_DEG = (0.0, 360.0)
+
+MATERIALS = (
+    {"index": 0, "name": "aluminum_rigid", "young_mpa": 70000.0, "poisson": 0.33},
+    {"index": 1, "name": "titanium_rigid", "young_mpa": 110000.0, "poisson": 0.34},
+    {"index": 2, "name": "steel_rigid", "young_mpa": 210000.0, "poisson": 0.30},
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description=f"Generate constrained LHS {DESIGN_NAME} impact cases."
+    )
+    parser.add_argument("--template", type=Path, default=TEMPLATE)
+    parser.add_argument("--output-root", type=Path, default=OUTPUT_ROOT)
+    parser.add_argument("--cases", type=int, default=DEFAULT_CASES)
+    parser.add_argument("--seed", type=int, default=DEFAULT_SEED)
+    parser.add_argument("--trials", type=int, default=128)
+    parser.add_argument("--overwrite", action="store_true")
+    return parser.parse_args()
+
+
+def lhs(n: int, dimensions: int, rng: np.random.Generator) -> np.ndarray:
+    design = np.empty((n, dimensions), dtype=np.float64)
+    for dimension in range(dimensions):
+        design[:, dimension] = (rng.permutation(n) + rng.random(n)) / n
+    return design
+
+
+def pairwise_min_distance(values: np.ndarray) -> float:
+    delta = values[:, None, :] - values[None, :, :]
+    distance2 = np.einsum("ijk,ijk->ij", delta, delta)
+    np.fill_diagonal(distance2, np.inf)
+    return float(np.sqrt(distance2.min()))
+
+
+def map_xy_to_panel(
+    design: np.ndarray,
+    candidates: list[dict],
+    rng: np.random.Generator,
+) -> tuple[list[dict], np.ndarray]:
+    centers = np.asarray([item["center"][:2] for item in candidates], dtype=np.float64)
+    low = centers.min(axis=0)
+    span = centers.max(axis=0) - low
+    normalized = (centers - low) / span
+    available = np.ones(len(candidates), dtype=bool)
+    selected_indices = np.empty(len(design), dtype=np.int64)
+
+    # Random order avoids systematically giving early rows the best projection.
+    for row_index in rng.permutation(len(design)):
+        distance2 = ((normalized - design[row_index, :2]) ** 2).sum(axis=1)
+        distance2[~available] = np.inf
+        chosen = int(np.argmin(distance2))
+        selected_indices[row_index] = chosen
+        available[chosen] = False
+
+    mapped = design.copy()
+    mapped[:, :2] = normalized[selected_indices]
+    return [candidates[index] for index in selected_indices], mapped
+
+
+def make_design(n: int, candidates: list[dict], seed: int, trials: int) -> tuple[np.ndarray, list[dict], float]:
+    root_rng = np.random.default_rng(seed)
+    best_design = None
+    best_impacts = None
+    best_score = -np.inf
+
+    for _ in range(trials):
+        trial_seed = int(root_rng.integers(0, np.iinfo(np.int64).max))
+        rng = np.random.default_rng(trial_seed)
+        design = lhs(n, 7, rng)
+        impacts, mapped = map_xy_to_panel(design, candidates, rng)
+        material_coordinate = (np.floor(mapped[:, 6] * len(MATERIALS)) + 0.5) / len(MATERIALS)
+        scored = mapped.copy()
+        scored[:, 6] = material_coordinate
+        score = pairwise_min_distance(scored)
+        if score > best_score:
+            best_design = mapped
+            best_impacts = impacts
+            best_score = score
+
+    assert best_design is not None and best_impacts is not None
+    return best_design, best_impacts, best_score
+
+
+def scale(unit_value: float, limits: tuple[float, float]) -> float:
+    return limits[0] + unit_value * (limits[1] - limits[0])
+
+
+def direction(theta_deg: float, phi_deg: float) -> np.ndarray:
+    theta = math.radians(theta_deg)
+    phi = math.radians(phi_deg)
+    return np.asarray(
+        [math.sin(theta) * math.cos(phi), math.sin(theta) * math.sin(phi), math.cos(theta)],
+        dtype=np.float64,
+    )
+
+
+def update_mat_rigid(block: list[str], density: float, young_mpa: float, poisson: float) -> tuple[list[str], bool]:
+    output = list(block)
+    for index, line in enumerate(output[1:], start=1):
+        stripped = line.strip()
+        if not stripped or stripped.startswith("$"):
+            continue
+        fields = stripped.split()
+        if len(fields) >= 4 and fields[0] == str(BALL_MID):
+            output[index] = f"{BALL_MID:10d}{density:10.4E}{young_mpa:10.1f}{poisson:10.4f}\n"
+            return output, True
+    return output, False
+
+
+def update_initial_velocity(block: list[str], velocity: np.ndarray) -> tuple[list[str], bool]:
+    output = list(block)
+    for index, line in enumerate(output[1:], start=1):
+        stripped = line.strip()
+        if not stripped or stripped.startswith("$"):
+            continue
+        fields = stripped.split()
+        if fields and fields[0] == str(BALL_PID):
+            values = [BALL_PID, *velocity.tolist(), 0.0, 0.0, 0.0, 0]
+            output[index] = (
+                f"{values[0]:10d}"
+                + "".join(f"{value:10.3E}" for value in values[1:7])
+                + f"{values[7]:10d}\n"
+            )
+            return output, True
+    return output, False
+
+
+def make_case_key(
+    template: dict,
+    impact: dict,
+    velocity: np.ndarray,
+    density: float,
+    material: dict,
+) -> tuple[list[str], np.ndarray]:
+    impact_center = np.asarray(impact["center"], dtype=np.float64)
+    travel_direction = velocity / np.linalg.norm(velocity)
+    ball_center = impact_center - travel_direction * (template["ball_radius"] + BALL_GAP_MM)
+    output_blocks: list[list[str]] = []
+    material_updated = False
+    velocity_updated = False
+
+    for block in template["blocks"]:
+        if base.block_is_control_adaptive(block) or base.block_is_end(block):
+            continue
+        key = block[0].strip().upper()
+        if key == "*NODE":
+            modified = base.move_ball_nodes_in_node_block(
+                block, template["ball_node_ids"], template["ball_center"], ball_center
+            )
+        elif key == "*PART":
+            modified = base.update_part_adpopt_block(block, PANEL_PID, 0)
+            modified = base.update_part_adpopt_block(modified, BALL_PID, 0)
+        elif key.startswith("*MAT_RIGID"):
+            modified, changed = update_mat_rigid(
+                block, density, material["young_mpa"], material["poisson"]
+            )
+            material_updated |= changed
+        elif key == "*INITIAL_VELOCITY_RIGID_BODY":
+            modified, changed = update_initial_velocity(block, velocity)
+            velocity_updated |= changed
+        else:
+            modified = block
+        output_blocks.append(modified)
+
+    if not material_updated:
+        raise RuntimeError(f"Could not update rigid material MID {BALL_MID}")
+    if not velocity_updated:
+        raise RuntimeError(f"Could not update initial velocity for PID {BALL_PID}")
+
+    lines = [line for block in output_blocks for line in block]
+    lines.append("*END\n")
+    return lines, ball_center
+
+
+def min_impact_spacing(impacts: list[dict]) -> float:
+    xy = np.asarray([item["center"][:2] for item in impacts])
+    delta = xy[:, None, :] - xy[None, :, :]
+    distance2 = np.einsum("ijk,ijk->ij", delta, delta)
+    np.fill_diagonal(distance2, np.inf)
+    return float(np.sqrt(distance2.min()))
+
+
+def main() -> None:
+    args = parse_args()
+    if args.cases < 3:
+        raise ValueError("--cases must be at least 3")
+    if not args.template.exists():
+        raise FileNotFoundError(args.template)
+    if args.output_root.exists() and any(args.output_root.iterdir()) and not args.overwrite:
+        raise RuntimeError(f"Output root is not empty: {args.output_root}; use --overwrite to replace keys")
+
+    template = base.parse_template(args.template)
+    design, impacts, score = make_design(args.cases, template["candidates"], args.seed, args.trials)
+    args.output_root.mkdir(parents=True, exist_ok=True)
+    rows = []
+
+    for index, (unit, impact) in enumerate(zip(design, impacts), start=1):
+        speed = scale(float(unit[2]), SPEED_RANGE)
+        mass_ratio = scale(float(unit[3]), MASS_RATIO_RANGE)
+        theta_deg = scale(float(unit[4]), THETA_RANGE_DEG)
+        phi_deg = scale(float(unit[5]), PHI_RANGE_DEG)
+        material_index = min(int(unit[6] * len(MATERIALS)), len(MATERIALS) - 1)
+        material = MATERIALS[material_index]
+        velocity = speed * direction(theta_deg, phi_deg)
+        density = BASE_DENSITY * mass_ratio
+        mass = BASE_MASS * mass_ratio
+
+        case_name = f"case{index:03d}"
+        case_dir = args.output_root / case_name
+        case_dir.mkdir(parents=True, exist_ok=True)
+        key_path = case_dir / f"{case_name}.key"
+        key_lines, ball_center = make_case_key(template, impact, velocity, density, material)
+        key_path.write_text("".join(key_lines), encoding="utf-8", newline="\n")
+        center = impact["center"]
+        rows.append(
+            {
+                "case": case_name,
+                "key_file": str(key_path),
+                "panel_pid": PANEL_PID,
+                "impact_element_id": impact["eid"],
+                "impact_x": f"{center[0]:.8f}",
+                "impact_y": f"{center[1]:.8f}",
+                "impact_z": f"{center[2]:.8f}",
+                "ball_center_x": f"{ball_center[0]:.8f}",
+                "ball_center_y": f"{ball_center[1]:.8f}",
+                "ball_center_z": f"{ball_center[2]:.8f}",
+                "velocity_vx": f"{velocity[0]:.8f}",
+                "velocity_vy": f"{velocity[1]:.8f}",
+                "velocity_vz": f"{velocity[2]:.8f}",
+                "impact_speed": f"{speed:.8f}",
+                "mass_ratio": f"{mass_ratio:.8f}",
+                "impactor_mass": f"{mass:.10f}",
+                "impactor_density": f"{density:.10E}",
+                "theta_deg": f"{theta_deg:.8f}",
+                "phi_deg": f"{phi_deg:.8f}",
+                "material_index": material_index,
+                "material_name": material["name"],
+                "material_young_mpa": f"{material['young_mpa']:.1f}",
+                "material_poisson": f"{material['poisson']:.4f}",
+                "min_boundary_distance_mm": f"{impact['min_boundary_distance']:.8f}",
+                **{f"lhs_u_{name}": f"{unit[i]:.10f}" for i, name in enumerate(("x", "y", "v", "m", "theta", "phi", "material"))},
+            }
+        )
+
+    manifest = args.output_root / "case_manifest.csv"
+    with manifest.open("w", newline="", encoding="utf-8") as handle:
+        writer = csv.DictWriter(handle, fieldnames=list(rows[0]))
+        writer.writeheader()
+        writer.writerows(rows)
+
+    counts = Counter(row["material_name"] for row in rows)
+    summary = (
+        f"{DESIGN_NAME} constrained LHS design\n"
+        f"cases={args.cases}\nseed={args.seed}\ntrials={args.trials}\n"
+        f"normalized_maximin_score={score:.8f}\n"
+        f"minimum_xy_spacing_mm={min_impact_spacing(impacts):.8f}\n"
+        f"speed_range_mm_per_s={SPEED_RANGE}\n"
+        f"mass_ratio_range={MASS_RATIO_RANGE}\n"
+        f"theta_range_deg={THETA_RANGE_DEG}\nphi_range_deg={PHI_RANGE_DEG}\n"
+        f"material_counts={dict(counts)}\n"
+        "theta is measured from global +Z; phi is measured in global XY from +X toward +Y.\n"
+        "Rigid material class controls E/nu used by contact; mass ratio independently scales density.\n"
+    )
+    (args.output_root / "lhs_design_summary.txt").write_text(summary, encoding="utf-8", newline="\n")
+    print(summary, end="")
+    print(f"manifest={manifest}")
+
+
+if __name__ == "__main__":
+    main()

generation_evidence/lhs/generate_floorfrontdriver_random_cases.py

@@ -0,0 +1,424 @@
+import csv
+import math
+import random
+from pathlib import Path
+
+
+TEMPLATE = Path("floor_panel_largest_3_pid_2000394_373_floorfrontdriver_with_ball.key")
+OUTPUT_ROOT = Path("cases_floorfrontdriver_random_50")
+
+PANEL_PID = 2000394
+BALL_PID = 9636
+NUM_CASES = 50
+RANDOM_SEED = 20260611
+
+MIN_BOUNDARY_DISTANCE_MM = 80.0
+TARGET_PAIRWISE_DISTANCE_MM = 120.0
+MIN_PAIRWISE_DISTANCE_MM = 60.0
+PAIRWISE_RELAX_STEP_MM = 10.0
+BALL_GAP_MM = 5.0
+
+
+def is_keyword(line):
+    return line.startswith("*")
+
+
+def parse_int_fields(line):
+    values = []
+    for field in line.strip().split():
+        try:
+            values.append(int(float(field)))
+        except ValueError:
+            pass
+    if len(values) >= 6:
+        return values
+
+    fixed = []
+    if len(line) >= 48:
+        for i in range(6):
+            chunk = line[i * 8 : (i + 1) * 8].strip()
+            if not chunk:
+                fixed.append(0)
+                continue
+            try:
+                fixed.append(int(chunk))
+            except ValueError:
+                return values
+    return fixed if len(fixed) >= len(values) else values
+
+
+def read_blocks(path):
+    block = []
+    with path.open("r", encoding="utf-8", errors="ignore") as f:
+        for line in f:
+            if is_keyword(line) and block:
+                yield block
+                block = [line]
+            else:
+                block.append(line)
+    if block:
+        yield block
+
+
+def parse_node_line(line):
+    fields = line.strip().split()
+    if len(fields) < 4:
+        return None
+    try:
+        return int(float(fields[0])), (float(fields[1]), float(fields[2]), float(fields[3]))
+    except ValueError:
+        return None
+
+
+def format_node(nid, xyz):
+    x, y, z = xyz
+    return f"{nid:8d}{x:16.8f}{y:16.8f}{z:16.8f}       0       0\n"
+
+
+def shell_edges(nids):
+    clean = []
+    for nid in nids:
+        if nid > 0 and nid not in clean:
+            clean.append(nid)
+    if len(clean) < 3:
+        return []
+    return [tuple(sorted((clean[i], clean[(i + 1) % len(clean)]))) for i in range(len(clean))]
+
+
+def centroid(points):
+    n = len(points)
+    return (
+        sum(p[0] for p in points) / n,
+        sum(p[1] for p in points) / n,
+        sum(p[2] for p in points) / n,
+    )
+
+
+def xy_distance(a, b):
+    return math.hypot(a[0] - b[0], a[1] - b[1])
+
+
+def block_is_control_adaptive(block):
+    return block[0].strip().upper() == "*CONTROL_ADAPTIVE"
+
+
+def block_is_end(block):
+    return block[0].strip().upper() == "*END"
+
+
+def parse_template(path):
+    blocks = list(read_blocks(path))
+    nodes = {}
+    shell_elements = []
+
+    for block in blocks:
+        key = block[0].strip().upper()
+        if key == "*NODE":
+            for line in block[1:]:
+                stripped = line.strip()
+                if not stripped or stripped.startswith("$"):
+                    continue
+                parsed = parse_node_line(line)
+                if parsed:
+                    nodes[parsed[0]] = parsed[1]
+        elif key == "*ELEMENT_SHELL":
+            for line in block[1:]:
+                stripped = line.strip()
+                if not stripped or stripped.startswith("$"):
+                    continue
+                fields = parse_int_fields(line)
+                if len(fields) >= 6:
+                    shell_elements.append(fields[:6])
+
+    panel_elements = [elem for elem in shell_elements if elem[1] == PANEL_PID]
+    ball_elements = [elem for elem in shell_elements if elem[1] == BALL_PID]
+    if not panel_elements:
+        raise SystemExit(f"No panel elements found for PID {PANEL_PID}")
+    if not ball_elements:
+        raise SystemExit(f"No ball elements found for PID {BALL_PID}")
+
+    ball_node_ids = {nid for elem in ball_elements for nid in elem[2:6] if nid > 0}
+    ball_points = [nodes[nid] for nid in ball_node_ids]
+    ball_center = centroid(ball_points)
+    ball_radius = max(
+        max(p[0] for p in ball_points) - min(p[0] for p in ball_points),
+        max(p[1] for p in ball_points) - min(p[1] for p in ball_points),
+        max(p[2] for p in ball_points) - min(p[2] for p in ball_points),
+    ) / 2.0
+
+    edge_counts = {}
+    for elem in panel_elements:
+        for edge in shell_edges(elem[2:6]):
+            edge_counts[edge] = edge_counts.get(edge, 0) + 1
+
+    boundary_node_ids = set()
+    for edge, count in edge_counts.items():
+        if count == 1:
+            boundary_node_ids.update(edge)
+    boundary_points = [nodes[nid] for nid in boundary_node_ids if nid in nodes]
+
+    candidates = []
+    for elem in panel_elements:
+        elem_nodes = [nodes[nid] for nid in elem[2:6] if nid > 0 and nid in nodes]
+        if len(elem_nodes) < 3:
+            continue
+        c = centroid(elem_nodes)
+        min_boundary_distance = min(xy_distance(c, bp) for bp in boundary_points)
+        if min_boundary_distance >= MIN_BOUNDARY_DISTANCE_MM:
+            candidates.append(
+                {
+                    "eid": elem[0],
+                    "center": c,
+                    "min_boundary_distance": min_boundary_distance,
+                }
+            )
+
+    if len(candidates) < NUM_CASES:
+        raise SystemExit(
+            f"Only {len(candidates)} safe impact candidates found; need {NUM_CASES}. "
+            f"Reduce MIN_BOUNDARY_DISTANCE_MM."
+        )
+
+    return {
+        "blocks": blocks,
+        "nodes": nodes,
+        "panel_elements": panel_elements,
+        "ball_node_ids": ball_node_ids,
+        "ball_center": ball_center,
+        "ball_radius": ball_radius,
+        "candidates": candidates,
+        "boundary_node_count": len(boundary_node_ids),
+    }
+
+
+def update_part_adpopt_line(line, adpopt):
+    fields = parse_int_fields(line)
+    if len(fields) < 3:
+        return line
+    while len(fields) < 8:
+        fields.append(0)
+    fields[6] = adpopt
+    return "".join(f"{item:10d}" for item in fields[:8]) + "\n"
+
+
+def update_part_adpopt_block(block, pid, adpopt):
+    out = []
+    replaced = False
+    for line in block:
+        if (
+            not replaced
+            and not line.startswith("*")
+            and not line.strip().startswith("$")
+            and parse_int_fields(line)[:1] == [pid]
+        ):
+            out.append(update_part_adpopt_line(line, adpopt))
+            replaced = True
+        else:
+            out.append(line)
+    return out
+
+
+def move_ball_nodes_in_node_block(block, ball_node_ids, old_center, new_center):
+    dx = new_center[0] - old_center[0]
+    dy = new_center[1] - old_center[1]
+    dz = new_center[2] - old_center[2]
+
+    out = []
+    for line in block:
+        parsed = parse_node_line(line)
+        if parsed and parsed[0] in ball_node_ids:
+            nid, xyz = parsed
+            out.append(format_node(nid, (xyz[0] + dx, xyz[1] + dy, xyz[2] + dz)))
+        else:
+            out.append(line)
+    return out
+
+
+def make_case_key(template, impact):
+    impact_center = impact["center"]
+    new_ball_center = (
+        impact_center[0],
+        impact_center[1],
+        impact_center[2] - template["ball_radius"] - BALL_GAP_MM,
+    )
+
+    out_blocks = []
+    for block in template["blocks"]:
+        if block_is_control_adaptive(block):
+            continue
+        if block_is_end(block):
+            continue
+
+        key = block[0].strip().upper()
+        if key == "*NODE":
+            out_blocks.append(
+                move_ball_nodes_in_node_block(
+                    block,
+                    template["ball_node_ids"],
+                    template["ball_center"],
+                    new_ball_center,
+                )
+            )
+        elif key == "*PART":
+            modified = update_part_adpopt_block(block, PANEL_PID, 0)
+            modified = update_part_adpopt_block(modified, BALL_PID, 0)
+            out_blocks.append(modified)
+        else:
+            out_blocks.append(block)
+
+    lines = []
+    for block in out_blocks:
+        lines.extend(block)
+        if block and not block[-1].endswith("\n"):
+            lines.append("\n")
+    lines.append("*END\n")
+    return lines, new_ball_center
+
+
+def greedy_select(candidates, min_spacing, rng):
+    shuffled = candidates[:]
+    rng.shuffle(shuffled)
+    selected = []
+
+    for candidate in shuffled:
+        center = candidate["center"]
+        if all(xy_distance(center, item["center"]) >= min_spacing for item in selected):
+            selected.append(candidate)
+            if len(selected) == NUM_CASES:
+                return selected
+    return selected
+
+
+def farthest_point_select(candidates):
+    rng = random.Random(RANDOM_SEED)
+    first = rng.choice(candidates)
+    selected = [first]
+    selected_centers = [first["center"]]
+
+    remaining = [candidate for candidate in candidates if candidate is not first]
+    while len(selected) < NUM_CASES and remaining:
+        best_idx = None
+        best_dist = -1.0
+        for idx, candidate in enumerate(remaining):
+            d = min(xy_distance(candidate["center"], center) for center in selected_centers)
+            if d > best_dist:
+                best_dist = d
+                best_idx = idx
+
+        chosen = remaining.pop(best_idx)
+        selected.append(chosen)
+        selected_centers.append(chosen["center"])
+
+    return selected
+
+
+def select_impacts(candidates):
+    spacing = TARGET_PAIRWISE_DISTANCE_MM
+    while spacing >= MIN_PAIRWISE_DISTANCE_MM:
+        rng = random.Random(RANDOM_SEED)
+        selected = greedy_select(candidates, spacing, rng)
+        if len(selected) == NUM_CASES:
+            return selected, spacing
+        spacing -= PAIRWISE_RELAX_STEP_MM
+
+    selected = farthest_point_select(candidates)
+    actual_spacing = selected_min_pairwise_distance(selected)
+    if actual_spacing < MIN_PAIRWISE_DISTANCE_MM:
+        raise SystemExit(
+            f"Could not select {NUM_CASES} points with pairwise spacing >= "
+            f"{MIN_PAIRWISE_DISTANCE_MM} mm. Best farthest-point spacing: "
+            f"{actual_spacing:.6f} mm. Safe candidates: {len(candidates)}"
+        )
+    return selected, actual_spacing
+
+
+def selected_min_pairwise_distance(impacts):
+    min_dist = float("inf")
+    for i, a in enumerate(impacts):
+        for b in impacts[i + 1 :]:
+            min_dist = min(min_dist, xy_distance(a["center"], b["center"]))
+    return min_dist
+
+
+def nearest_selected_distance(impact, prior_impacts):
+    if not prior_impacts:
+        return ""
+    return min(xy_distance(impact["center"], other["center"]) for other in prior_impacts)
+
+
+def main():
+    if not TEMPLATE.exists():
+        raise SystemExit(f"Missing template key: {TEMPLATE}")
+
+    template = parse_template(TEMPLATE)
+    impacts, required_spacing = select_impacts(template["candidates"])
+    actual_spacing = selected_min_pairwise_distance(impacts)
+    OUTPUT_ROOT.mkdir(exist_ok=True)
+
+    manifest_path = OUTPUT_ROOT / "case_manifest.csv"
+    with manifest_path.open("w", newline="", encoding="utf-8") as csvfile:
+        writer = csv.writer(csvfile)
+        writer.writerow(
+            [
+                "case",
+                "key_file",
+                "panel_pid",
+                "impact_element_id",
+                "impact_x",
+                "impact_y",
+                "impact_z",
+                "ball_center_x",
+                "ball_center_y",
+                "ball_center_z",
+                "min_boundary_distance_mm",
+                "nearest_selected_distance_mm",
+                "required_pairwise_distance_mm",
+            ]
+        )
+
+        prior_impacts = []
+        for idx, impact in enumerate(impacts, start=1):
+            case_name = f"case{idx:03d}"
+            case_dir = OUTPUT_ROOT / case_name
+            case_dir.mkdir(exist_ok=True)
+            key_path = case_dir / f"{case_name}.key"
+
+            key_lines, ball_center = make_case_key(template, impact)
+            key_path.write_text("".join(key_lines), encoding="utf-8", newline="\n")
+
+            c = impact["center"]
+            nearest = nearest_selected_distance(impact, prior_impacts)
+            writer.writerow(
+                [
+                    case_name,
+                    str(key_path),
+                    PANEL_PID,
+                    impact["eid"],
+                    f"{c[0]:.6f}",
+                    f"{c[1]:.6f}",
+                    f"{c[2]:.6f}",
+                    f"{ball_center[0]:.6f}",
+                    f"{ball_center[1]:.6f}",
+                    f"{ball_center[2]:.6f}",
+                    f"{impact['min_boundary_distance']:.6f}",
+                    "" if nearest == "" else f"{nearest:.6f}",
+                    f"{required_spacing:.6f}",
+                ]
+            )
+            prior_impacts.append(impact)
+
+    print(f"Template: {TEMPLATE}")
+    print(f"Output root: {OUTPUT_ROOT}")
+    print(f"Generated cases: {NUM_CASES}")
+    print(f"Candidate safe points: {len(template['candidates'])}")
+    print(f"Boundary nodes avoided: {template['boundary_node_count']}")
+    print(f"Minimum boundary distance: {MIN_BOUNDARY_DISTANCE_MM} mm")
+    print(f"Required pairwise impact distance used: {required_spacing} mm")
+    print(f"Actual minimum selected pairwise distance: {actual_spacing:.6f} mm")
+    print(f"Manifest: {manifest_path}")
+    print("Adaptive disabled: removed *CONTROL_ADAPTIVE and set ADPOPT=0")
+    print("Ball velocity kept from template: VZ = 3464.1")
+
+
+if __name__ == "__main__":
+    main()

generation_evidence/lhs/generate_trunkfloor_lhs_cases.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+
+import generate_floorfrontdriver_lhs_cases as lhs
+import generate_floorfrontdriver_random_cases as base
+
+
+lhs.TEMPLATE = Path("floor_panel_largest_1_pid_2000447_153_trunkfloor_with_ball.key")
+lhs.OUTPUT_ROOT = Path("cases_trunkfloor_lhs_500")
+lhs.DESIGN_NAME = "trunkfloor"
+lhs.DEFAULT_CASES = 500
+lhs.DEFAULT_SEED = 20260723
+lhs.PANEL_PID = 2000447
+
+# The shared template parser selects valid panel elements through this module global.
+base.PANEL_PID = lhs.PANEL_PID
+
+
+if __name__ == "__main__":
+    lhs.main()

generation_evidence/lhs/trunkfloor/lhs_design_summary.txt

@@ -0,0 +1,13 @@
+trunkfloor constrained LHS design
+cases=500
+seed=20260723
+trials=128
+normalized_maximin_score=0.17719975
+minimum_xy_spacing_mm=1.43095918
+speed_range_mm_per_s=(1732.05, 5196.15)
+mass_ratio_range=(0.75, 1.25)
+theta_range_deg=(0.0, 15.0)
+phi_range_deg=(0.0, 360.0)
+material_counts={'titanium_rigid': 167, 'aluminum_rigid': 166, 'steel_rigid': 167}
+theta is measured from global +Z; phi is measured in global XY from +X toward +Y.
+Rigid material class controls E/nu used by contact; mass ratio independently scales density.

generation_evidence/stress/effective_stress_definition.txt

@@ -0,0 +1,12 @@
+CurvePlot source header observed from the retained LS-PrePost export:
+
+Curveplot
+Element History
+Time
+Effective Stress (v-m), ip#max
+Element no.
+2340533 #pts=152
+
+Interpretation: for every shell element and exported state, effective_stress
+is the maximum von Mises stress across the available through-thickness
+integration points. It is not a fixed upper, lower, or middle surface value.

metadata/LHS_DESIGN.md

@@ -0,0 +1,59 @@
+# Constrained-LHS design
+
+## Design coordinates
+
+Each constrained Latin hypercube design uses seven normalized coordinates:
+
+`[x, y, impact_speed, mass_ratio, theta_deg, phi_deg, material_index]`.
+
+The continuous domains are:
+
+| Parameter | Domain | Unit |
+|---|---:|---|
+| impact speed | [1732.05, 5196.15] | mm/s |
+| mass ratio | [0.75, 1.25] | dimensionless |
+| theta | [0, 15] | degree |
+| phi | [0, 360] | degree |
+
+Theta is measured from global +Z. Phi is measured in global XY from +X toward
++Y. Speed and angles are converted to the Cartesian velocity vector as
+
+`v = speed * [sin(theta) cos(phi), sin(theta) sin(phi), cos(theta)]`.
+
+Material is a three-level categorical coordinate with balanced counts. It
+selects one of the rigid-impactor E/nu pairs listed in
+`SIMULATION_PROTOCOL.md`; it is not a continuously interpolated material.
+
+## Geometry-constrained position sampling
+
+Impact positions are panel-shell centroids, not arbitrary points in a
+rectangular three-dimensional box. The topological outer boundary is computed
+from shell edges occurring in only one element. Candidate centroids must be at
+least 80 mm from all outer-boundary nodes in XY.
+
+The first two LHS coordinates are projected to the nearest available candidate
+centroid in normalized XY, without reusing a centroid. Consequently:
+
+- X and Y are space-filling design coordinates constrained by the mesh;
+- Z is inherited from the selected shell centroid;
+- the geometry JSON ranges are observed coordinate extrema, not continuous LHS
+  box bounds.
+
+## Maximin selection and seeds
+
+For a requested batch, 128 candidate seven-dimensional LHS designs are
+generated. Material coordinates are mapped to category-bin centers for scoring,
+and the design maximizing the normalized minimum pairwise distance is retained.
+
+| Geometry | Construction | Seed |
+|---|---|---:|
+| `floorfrontR` | independent single batch | 20260728 |
+| `trunkfloor` | independent single batch | 20260723 |
+| `floorfrontdriver`, cases 001--100 | initial batch | 20260721 |
+| `floorfrontdriver`, cases 101--200 | complementary nested extension | 20260722 |
+| `floorfrontdriver`, cases 201--500 | independent augmentation | 20260722 |
+
+Thus, the final set for each geometry contains 500 constrained-LHS cases, but
+the `floorfrontdriver` set is not one monolithic 500-point Latin hypercube.
+The three geometries share design bounds but use different eligible position
+sets and are not case-wise paired.

metadata/SIMULATION_PROTOCOL.md

@@ -0,0 +1,92 @@
+# Simulation protocol
+
+## Scope
+
+The three panel datasets use the same impactor construction, parameter bounds,
+boundary-condition rule, contact definition, solver-output settings, and
+compact-result conversion. Their panel meshes, eligible impact locations,
+part identifiers, and LHS seeds differ. Equal case identifiers across
+geometries are not paired simulations.
+
+## Units
+
+The LS-DYNA models use the tonne--mm--s--N consistent unit system:
+
+| Quantity | Unit |
+|---|---|
+| coordinate and displacement | mm |
+| time | s |
+| velocity | mm/s |
+| mass | tonne |
+| density | tonne/mm^3 |
+| force | N |
+| stress and Young's modulus | MPa |
+| angle | degree |
+
+## Solver
+
+Cases were run with LS-DYNA SMP single precision R12 using the `lsdyna_sp.exe`
+distributed through ANSYS v221. The batch configuration used `ncpu=8` and
+`memory=400m`. The exact R12 sub-build is not retained for every released case.
+The termination time is 0.03 s.
+
+## Rigid spherical impactor
+
+| Setting | Value |
+|---|---|
+| part ID | 9636 |
+| section ID | 9636 |
+| material ID | 174 |
+| material model | `*MAT_RIGID` |
+| element type | shell |
+| shell formulation | ELFORM=2 |
+| shear factor | SHRF=0.833333 |
+| thickness integration | NIP=3 |
+| shell thickness | 0.1 mm |
+| sphere radius | 12.5 mm |
+| initial gap | 5.0 mm |
+| reference nominal mass | 0.01 tonne |
+| reference density | 5.205e-5 tonne/mm^3 |
+
+For impact target p and unit travel direction v_hat, the initial center is
+`c_ball = p - v_hat * (12.5 mm + 5.0 mm)`. No initial angular velocity is
+applied. The generator records `impactor_mass = 0.01 tonne * mu` and writes
+`impactor_density = 5.205e-5 tonne/mm^3 * mu` into the rigid material. The
+released `impactor_mass` should therefore be interpreted as the nominal mass
+recorded by the generator.
+
+The material category changes only the rigid impactor's E and nu:
+
+| Index | Label | E (MPa) | nu |
+|---:|---|---:|---:|
+| 0 | `aluminum_rigid` | 70000 | 0.33 |
+| 1 | `titanium_rigid` | 110000 | 0.34 |
+| 2 | `steel_rigid` | 210000 | 0.30 |
+
+## Panel boundary and contact
+
+Panel outer-boundary nodes are determined topologically: nodes belonging to a
+shell edge used by only one panel element are included in the boundary set.
+All six translational and rotational degrees of freedom in that set are fixed
+using `*BOUNDARY_SPC_SET`.
+
+The impactor and panel interact through
+`*CONTACT_AUTOMATIC_SURFACE_TO_SURFACE_ID`. Static and dynamic friction
+coefficients are both 0.15. A body acceleration of 9810 mm/s^2 is applied in
+global +Z.
+
+Panel materials and shell sections are retained from the cited upstream 2020
+Nissan Rogue Version 3 model. Their full keyword cards and the complete vehicle
+model are not part of this compact release.
+
+## Outputs
+
+D3PLOT output uses a nominal 0.0002-s interval. Nodal X/Y/Z displacement is
+exported with LS-PrePost `ntime 5/6/7`. Shell effective stress is exported with
+`etime 9`, labeled `Effective Stress (v-m), ip#max`. See
+`TEMPORAL_SAMPLING.md` and the main Datasheet for the compact reduction and
+stress semantics.
+
+Representative self-contained keyword inputs and solver `d3hsp`/`matsum`
+outputs were retained as audit material but are not distributed in the public
+dataset.

metadata/TEMPORAL_SAMPLING.md

@@ -0,0 +1,36 @@
+# Temporal sampling and peak-event time
+
+## Raw solver output
+
+Each LS-DYNA simulation terminates at 0.03 s. D3PLOT is requested at a nominal
+0.0002-s interval. Actual floating-point state times can differ slightly from
+the nominal values and are therefore stored explicitly.
+
+## Compact 17-state sequence
+
+Compact conversion uses stride 10 on both nodal displacement and shell stress,
+then appends the final available state when it is not already selected. Across
+all released cases, both `time_indices` and `element_time_indices` equal:
+
+`[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 151]`.
+
+The first 16 retained states therefore have a nominal spacing of 0.002 s. Index
+151 is the appended terminal state and can be separated from index 150 by much
+less than 0.002 s. Consumers must use the stored `time` and `element_time`
+arrays rather than reconstructing timestamps from an assumed uniform interval.
+
+## Discrete peak-event definition
+
+Let T17 be the 17 retained states, Vvalid the valid-node set, and u_i(t) the
+three-dimensional nodal displacement. The supplied peak-target builder uses
+
+`t* = argmax_(t in T17) max_(i in Vvalid) ||u_i(t)||_2`.
+
+The implementation flattens the node-by-retained-state magnitude array and
+uses the first maximum returned by `torch.argmax`. The displacement field and
+the shell von Mises effective-stress field at the same selected retained state
+form the paired peak-event target.
+
+Accordingly, `t*` is quantized to the released 17-state grid. It is not an
+interpolated time and is not guaranteed to equal the continuous-time maximum
+over every raw solver state.

metadata/dataset.json

@@ -1,6 +1,6 @@
 {
   "title": "Automotive Impact Dataset",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "release_status": "public-release",
   "resource_type": "dataset",
   "total_cases": 1500,
@@ -33,15 +33,16 @@
     ]
   },
   "units": {
-    "status": "NOT_SPECIFIED_IN_RELEASE",
-    "coordinate": null,
-    "displacement": null,
-    "time": null,
-    "velocity": null,
+    "status": "SPECIFIED",
+    "system": "tonne-mm-s-N",
+    "coordinate": "mm",
+    "displacement": "mm",
+    "time": "s",
+    "velocity": "mm/s",
     "effective_stress": "MPa",
-    "young_modulus": "field name states MPa; verify against solver unit system",
-    "impactor_mass": null,
-    "impactor_density": null,
+    "young_modulus": "MPa",
+    "impactor_mass": "tonne",
+    "impactor_density": "tonne/mm^3",
     "mass_ratio": "dimensionless",
     "theta_phi": "degree"
   },
@@ -54,12 +55,64 @@
     "name": "2020 Nissan Rogue finite-element model",
     "developer": "CCSA, George Mason University",
     "sponsor": "NHTSA",
-    "exact_version": "not specified in release",
+    "exact_version": "Version 3, released August 2024",
     "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"
+  },
+  "simulation": {
+    "solver": "LS-DYNA SMP single precision R12 via ANSYS v221 lsdyna_sp.exe",
+    "exact_r12_subbuild_retained_for_every_case": false,
+    "ncpu": 8,
+    "memory": "400m",
+    "termination_time_s": 0.03,
+    "d3plot_nominal_interval_s": 0.0002,
+    "gravity_global_z_mm_per_s2": 9810.0,
+    "boundary_condition": "topological outer-boundary nodes fixed in all six degrees of freedom",
+    "contact": "CONTACT_AUTOMATIC_SURFACE_TO_SURFACE_ID",
+    "static_friction": 0.15,
+    "dynamic_friction": 0.15
+  },
+  "impactor": {
+    "type": "rigid spherical shell",
+    "part_id": 9636,
+    "section_id": 9636,
+    "material_id": 174,
+    "material_model": "MAT_RIGID",
+    "radius_mm": 12.5,
+    "initial_gap_mm": 5.0,
+    "elform": 2,
+    "shrf": 0.833333,
+    "nip": 3,
+    "shell_thickness_mm": 0.1,
+    "reference_nominal_mass_tonne": 0.01,
+    "reference_density_tonne_per_mm3": 5.205e-05,
+    "mass_scaling": "impactor_mass = reference_nominal_mass_tonne * mass_ratio",
+    "density_scaling": "impactor_density = reference_density_tonne_per_mm3 * mass_ratio"
+  },
+  "design": {
+    "method": "seven-dimensional constrained Latin hypercube with maximin selection over 128 trials",
+    "dimensions": ["position_x", "position_y", "impact_speed", "mass_ratio", "theta", "phi", "material_class"],
+    "impact_speed_mm_per_s": [1732.05, 5196.15],
+    "mass_ratio": [0.75, 1.25],
+    "theta_deg": [0.0, 15.0],
+    "phi_deg": [0.0, 360.0],
+    "minimum_boundary_distance_mm": 80.0,
+    "seeds": {
+      "floorfrontR": 20260728,
+      "trunkfloor": 20260723,
+      "floorfrontdriver_initial": 20260721,
+      "floorfrontdriver_extensions": 20260722
+    }
+  },
+  "temporal_sampling": {
+    "raw_nominal_interval_s": 0.0002,
+    "compact_stride": 10,
+    "append_final_state": true,
+    "retained_indices": [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 151],
+    "peak_time_definition": "discrete argmax of valid-node displacement magnitude over retained states"
   }
 }

metadata/floorfrontR_geometry.json

@@ -102,7 +102,14 @@
     "titanium_rigid": 167
   },
   "units": {
-    "status": "NOT_SPECIFIED_IN_RELEASE",
+    "status": "SPECIFIED",
+    "system": "tonne-mm-s-N",
+    "coordinate": "mm",
+    "displacement": "mm",
+    "time": "s",
+    "velocity": "mm/s",
+    "mass": "tonne",
+    "density": "tonne/mm^3",
     "effective_stress": "MPa",
     "material_young_field_name": "material_young_mpa",
     "angles": "degrees"

metadata/floorfrontdriver_geometry.json

@@ -102,7 +102,14 @@
     "titanium_rigid": 167
   },
   "units": {
-    "status": "NOT_SPECIFIED_IN_RELEASE",
+    "status": "SPECIFIED",
+    "system": "tonne-mm-s-N",
+    "coordinate": "mm",
+    "displacement": "mm",
+    "time": "s",
+    "velocity": "mm/s",
+    "mass": "tonne",
+    "density": "tonne/mm^3",
     "effective_stress": "MPa",
     "material_young_field_name": "material_young_mpa",
     "angles": "degrees"

metadata/trunkfloor_geometry.json

@@ -102,7 +102,14 @@
     "titanium_rigid": 167
   },
   "units": {
-    "status": "NOT_SPECIFIED_IN_RELEASE",
+    "status": "SPECIFIED",
+    "system": "tonne-mm-s-N",
+    "coordinate": "mm",
+    "displacement": "mm",
+    "time": "s",
+    "velocity": "mm/s",
+    "mass": "tonne",
+    "density": "tonne/mm^3",
     "effective_stress": "MPa",
     "material_young_field_name": "material_young_mpa",
     "angles": "degrees"

release_inventory.json

@@ -1,6 +1,6 @@
 {
   "dataset": "Automotive Impact Dataset",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "case_files": 1500,
   "archive_files": 15,
   "archive_bytes": 5032143218,

schema.json

@@ -1,5 +1,5 @@
 {
-  "schema_version": "1.0.0",
+  "schema_version": "1.1.0",
   "case_format": "PyTorch serialized plain dictionary",
   "recommended_load": "torch.load(file, map_location='cpu', weights_only=True)",
   "state_count": 17,
@@ -7,16 +7,16 @@
     "case": {"type": "string", "description": "caseNNN identifier"},
     "panel_pid": {"dtype": "int64", "shape": []},
     "nid": {"dtype": "int64", "shape": ["N"]},
-    "boundary_mask": {"dtype": "bool", "shape": ["N"]},
+    "boundary_mask": {"dtype": "bool", "shape": ["N"], "description": "true for nodes on the topological outer boundary fixed in all six degrees of freedom"},
     "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]},
+    "time": {"dtype": "float32", "shape": [17], "units": "s", "description": "exact retained nodal-state times"},
+    "time_indices": {"dtype": "int64", "shape": [17], "values": [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 151]},
+    "disp": {"dtype": "float32", "shape": ["N", 17, 3], "units": "mm", "description": "nodal Cartesian displacement"},
+    "element_time": {"dtype": "float32", "shape": [17], "units": "s", "description": "exact retained shell-state times"},
+    "element_time_indices": {"dtype": "int64", "shape": [17], "values": [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 151]},
     "element_id": {"dtype": "int64", "shape": ["Ne"]},
     "repaired_element_ids": {"dtype": "int64", "shape": "variable"},
     "effective_stress": {
@@ -30,20 +30,20 @@
       "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]},
+    "velocity_vz": {"dtype": "float32", "shape": [], "units": "mm/s", "description": "global-Z component retained for compatibility"},
+    "velocity_xyz": {"dtype": "float32", "shape": [3], "units": "mm/s", "description": "rigid-impactor initial Cartesian velocity"},
+    "impact_speed": {"dtype": "float32", "shape": [], "units": "mm/s", "design_domain": [1732.05, 5196.15]},
+    "impact_xyz": {"dtype": "float32", "shape": [3], "units": "mm", "description": "selected eligible panel-shell centroid; Z is not independently sampled"},
+    "impact_node_distance": {"dtype": "float32", "shape": ["N"], "units": "mm"},
+    "ball_center_xyz": {"dtype": "float32", "shape": [3], "units": "mm", "description": "initial spherical-impactor center"},
     "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": []},
+    "mass_ratio": {"dtype": "float32", "shape": [], "units": "dimensionless", "design_domain": [0.75, 1.25], "description": "common scale factor for reference rigid-impactor mass and density"},
+    "impactor_mass": {"dtype": "float32", "shape": [], "units": "tonne", "description": "generator-recorded nominal mass equal to 0.01 * mass_ratio"},
+    "impactor_density": {"dtype": "float32", "shape": [], "units": "tonne/mm^3", "description": "rigid-impactor density equal to 5.205e-5 * mass_ratio"},
+    "theta_deg": {"dtype": "float32", "shape": [], "units": "degree", "design_domain": [0.0, 15.0], "description": "polar angle from global +Z"},
+    "phi_deg": {"dtype": "float32", "shape": [], "units": "degree", "design_domain": [0.0, 360.0], "description": "azimuth in global XY from +X toward +Y"},
+    "material_young_mpa": {"dtype": "float32", "shape": [], "units": "MPa", "values": [70000.0, 110000.0, 210000.0], "entity": "rigid_impactor"},
+    "material_poisson": {"dtype": "float32", "shape": [], "units": "dimensionless", "values": [0.33, 0.34, 0.30], "entity": "rigid_impactor"},
     "material_index": {"dtype": "int64", "shape": []},
     "material_one_hot": {"dtype": "float32", "shape": [3]},
     "material_name": {"type": "string"},
@@ -51,11 +51,11 @@
     "condition_vector": {"dtype": "float32", "shape": [7]}
   },
   "mesh_fields": {
-    "node_pos": {"dtype": "float32", "shape": ["N", 3]},
+    "node_pos": {"dtype": "float32", "shape": ["N", 3], "units": "mm"},
     "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"]}
+    "boundary_mask": {"dtype": "bool", "shape": ["N"], "description": "topological outer-boundary nodes"}
   },
   "geometry_shapes": {
     "floorfrontdriver": {"N": 7408, "E": 29572, "Ne": 7374},
@@ -63,8 +63,21 @@
     "trunkfloor": {"N": 14440, "E": 58074, "Ne": 14589}
   },
   "units": {
-    "status": "NOT_SPECIFIED_IN_RELEASE",
+    "status": "SPECIFIED",
+    "system": "tonne-mm-s-N",
+    "coordinate": "mm",
+    "displacement": "mm",
+    "time": "s",
+    "velocity": "mm/s",
+    "mass": "tonne",
+    "density": "tonne/mm^3",
     "effective_stress": "MPa",
-    "warning": "Do not infer units from numeric magnitudes; only explicitly named units are defined."
+    "young_modulus": "MPa"
+  },
+  "temporal_sampling": {
+    "d3plot_nominal_interval_s": 0.0002,
+    "compact_stride": 10,
+    "append_final_state": true,
+    "peak_time_scope": "argmax over valid nodes and 17 retained states"
   }
 }

scripts/validate_dataset.py

@@ -273,7 +273,7 @@ def main() -> None:
     )
     report = {
         "dataset": "Automotive Impact Dataset",
-        "version": "1.0.0",
+        "version": "1.1.0",
         "status": "passed" if not errors else "failed",
         "cases_validated": 1500,
         "split_sizes": {key: len(value) for key, value in split.items()},
@@ -283,8 +283,8 @@ def main() -> None:
         "elapsed_seconds": time.time() - started,
         "errors": errors,
         "scope_note": (
-            "Technical package validation only; provenance and unit limitations "
-            "are documented in the release metadata."
+            "Technical package validation only; provenance and remaining "
+            "configuration limitations are documented in the release metadata."
         ),
     }
     rendered = json.dumps(report, indent=2, ensure_ascii=False) + "\n"