luminary-shift/SHIFT-Crash-sample

SHIFT-Crash Sample: High-Fidelity Crash Simulation Dataset for Automotive Structural Mechanics

We're excited to introduce the SHIFT-Crash Sample dataset — a sample release of high-fidelity crash simulations developed as part of the Luminary SHIFT Models initiative. This dataset enables the training and benchmarking of real-time physics AI models for automotive crashworthiness prediction.

Website: shift.luminarycloud.com

Contact: [email protected]

Summary

Physics AI models can transform early-stage automotive design by giving engineers real-time feedback on crash performance — without running expensive finite element simulations that take hours per case. However, the lack of large-scale, high-quality crash simulation datasets has been a barrier to developing these models.

SHIFT-Crash is a massive step forward: over 5,000 high-fidelity frontal crash simulations of a parametrically morphed 2010 Toyota Yaris, covering a wide range of vehicle geometries and front rail material properties. Each simulation captures the full 120 ms crash event at 10 ms intervals, producing time-resolved deformation, stress, strain, and energy fields across ~376,000 surface nodes.

This repository provides access to the first 100 simulations from the larger SHIFT-Crash dataset, hence the qualifier "Sample". To access the full dataset (~5,200 cases, ~1.4 TB), please see luminary-shift/SHIFT-Crash or visit the SHIFT website.

This sample dataset supports training surface-based crash surrogate models, real-time inference systems, design-space exploration for vehicle crashworthiness, and benchmarking time-dependent structural mechanics models.

Applications

• Training crash surrogate models (e.g., GeoTransolver, DeepONet, FNO, graph neural networks)
• Rapid design-space exploration for vehicle crashworthiness
• Shape-performance correlation studies for frontal impact
• Benchmarking time-dependent structural mechanics AI models
• Research in point cloud learning and physics-aware generative models for structural applications

Attribution

The baseline vehicle model is the 2010 Toyota Yaris developed by the Center for Collision Safety and Analysis (CCSA) at George Mason University for NHTSA. Parametric morphing and crash simulations by Luminary Cloud.

An article is being prepared so users can cite this dataset — we will update accordingly when available. Until then you can use this citation:

@misc{shift_crash_2026,
  author = "{Luminary Cloud}",
  title = {SHIFT-Crash: High-Fidelity Crash Simulation Dataset for Automotive Structural Mechanics},
  year = {2026},
  url = {https://huggingface.co/datasets/luminary-shift/SHIFT-Crash}
}

Contents

Geometry Variation

The vehicle geometry is parameterized using a deformation cage approach to morph the discrete baseline Yaris model. The parametric modifications span the range from a sub-compact to a compact sedan, covering four geometric design variables and two front rail material properties:

Parameter	Description	Range	Unit
front_rails	Front rail / crush zone length offset	-40 to 100	mm
cabin_length	Cabin length offset	-40 to 100	mm
car_width	Vehicle width offset	-40 to 40	mm
roof_height	Roof height offset	-40 to 100	mm
rail_thickness	Front rail shell thickness	1.2 to 2.5	mm
rail_yield_strength	Front rail steel yield strength	250 to 400	MPa

The front rails are the primary energy-absorbing structure during a frontal impact. By parameterizing both the geometry and the rail material properties, this dataset enables studying how structural design choices affect crash performance.

Examples of geometry variants:

Variant 1	Variant 50	Variant 100

Crash Solver

All cases were simulated using OpenRadioss 2024.1, an open-source explicit dynamics solver for crash and impact problems. The simulation setup models a 56 km/h frontal impact into a rigid wall over 120 ms of physical time.

Key solver settings:

• Impact velocity: 56 km/h (NCAP frontal impact standard)
• Duration: 120 ms (captures full crush, rebound, and secondary impacts)
• Output: 13 frames at 10 ms intervals (t = 0, 10, 20, ..., 120 ms)
• Mesh: Yaris coarse FE model with ~378K shell elements and ~393K nodes
• Element types: Shell elements (quads and triangles) for vehicle body structure
• Contact: Automatic surface-to-surface contact with friction
• Material models: Elasto-plastic with isotropic hardening for steel components

Example Results

Deformation field (displacement magnitude after rigid body subtraction, 0–500 mm):

Von Mises stress field (0–300 MPa, 10 discrete color bands):

Files

Each simulation is stored in a directory named yaris_xNNNNN/ containing three files:

yaris_x00001/
├── merged_surfaces.vtp     (~245 MB) — unified multi-timestep surface mesh
├── merged_surfaces.stl     (~35 MB)  — undeformed reference geometry
└── params.json             (<1 KB)   — design parameters

merged_surfaces.vtp

The main data file. A VTK PolyData file containing the undeformed (t=0) surface mesh geometry with all 13 timesteps embedded as point data arrays. This format enables efficient random access to any timestep without loading separate files.

Point data fields (135 total):

Field pattern	Timesteps	Shape	Unit	Description
thickness	static	(N,)	mm	Shell thickness at t=0
displacement_t{time}	0–12 (13)	(N,3)	mm	3D displacement vector
thickness_t{time}	0–12 (13)	(N,)	mm	Dynamic shell thickness
stress_vm_t{time}	1–12 (12)	(N,)	Pa	Von Mises stress
effective_plastic_strain_t{time}	1–12 (12)	(N,)	—	Effective plastic strain
specific_energy_t{time}	1–12 (12)	(N,)	J/mm³	Specific internal energy
stress_{xx,yy,xy}_upper_t{time}	1–12 (36)	(N,)	Pa	Upper shell surface stress tensor
stress_{xx,yy,xy}_lower_t{time}	1–12 (36)	(N,)	Pa	Lower shell surface stress tensor

Where N = 376,593 nodes and {time} takes values 0.000, 0.010, 0.020, ..., 0.120 (seconds).

Cell data fields (3):

Field	Type	Description
ELEMENT_ID	int32	FE element ID from the solver
PART_ID	int32	Component/part ID (e.g., body panel, rail, wheel)
EROSION_STATUS	int32	Element erosion flag: 0 = active, 1 = eroded

Notes:

• Dynamic target fields (stress_vm, effective_plastic_strain, specific_energy, stress tensor) are undefined at t=0 (the undeformed state) and only present for t > 0
• The EROSION_STATUS field tracks elements that have been removed by the solver due to excessive distortion — this is physically meaningful in crash simulations
• Displacement is stored as absolute displacement from the reference configuration, including global rigid body motion

merged_surfaces.stl

Binary STL file of the undeformed vehicle surface mesh. This is the reference geometry before the crash event begins. Useful for visualization and as a geometric prior for ML models.

params.json

JSON file containing the 6 design parameters for this variant:

{
  "variant_name": "yaris_x00001",
  "sample_id": 1,
  "front_rails": -40.0,
  "cabin_length": -40.0,
  "car_width": -40.0,
  "roof_height": -40.0,
  "rail_thickness": 1.2,
  "rail_yield_strength": 400.0,
  "baseline": "combine_wparams.key.ansa",
  "smooth_method": "auto_smooth"
}

Sample Dataset Statistics

Metric	Value
Cases in this sample	100
Cases in full dataset	~5,200
Timesteps per case	13 (0 to 120 ms)
Surface nodes per case	376,593
Surface elements per case	375,219
Point data fields per case	135
Per-case size	~280 MB
Total sample size	~28 GB

Downloading

You can use HuggingFace to access the entire sample repository. Note you will need to have git lfs installed first, then run:

git clone [email protected]:datasets/luminary-shift/SHIFT-Crash-sample

If you will access only a subset of the data, or wish to interact in a staged manner, you can clone the repository where the LFS files are not checked out (simply pointers):

GIT_LFS_SKIP_SMUDGE=1 git clone [email protected]:datasets/luminary-shift/SHIFT-Crash-sample .

# to ensure future `git pull` commands won't checkout full files:
cd <path/to/repo>
git lfs install --skip-smudge --local

You can then pull down files you want to interact with:

# pull a specific case
git lfs pull --include="yaris_x00001/*"

# pull multiple cases
git lfs pull --include="yaris_x0000[1-9]/*"

# pull only STL files (geometry, no simulation data)
git lfs pull --include="*/merged_surfaces.stl"

Loading Data with Python

import pyvista as pv
import json

# Load the VTP
mesh = pv.read("yaris_x00001/merged_surfaces.vtp")

# Access displacement at t=60ms
disp_60ms = mesh.point_data["displacement_t0.060"]  # shape: (376593, 3)

# Access Von Mises stress at t=60ms
stress_60ms = mesh.point_data["stress_vm_t0.060"]   # shape: (376593,)

# Load parameters
with open("yaris_x00001/params.json") as f:
    params = json.load(f)
print(f"Rail thickness: {params['rail_thickness']} mm")

Credits

CCSA / George Mason University

The baseline 2010 Toyota Yaris finite element model was developed by the Center for Collision Safety and Analysis (CCSA) at George Mason University under contract with NHTSA. The SHIFT-Crash dataset uses a parametrically morphed version of this model.

Luminary Cloud

Parametric morphing, simulation setup, quality assurance, and dataset curation by Luminary Cloud.

License

This dataset is distributed under the CC-BY-NC-4.0 license, which is also included in the dataset itself. By downloading the dataset you acknowledge the terms of this license.