4. Feature engineering for crashworthiness

Surrogate models are only as good as the feature matrix that feeds them. In crashworthiness CAE, that matrix has three distinct column families: design variables that describe the geometry, material model variables that describe constitutive behavior, and scalar responses that quantify what happened during the impact. The first two are inputs the surrogate learns to map from; the third is the output it learns to predict. Getting the extraction right — consistent units, consistent coordinate conventions, consistent sampling — matters more than the choice of regression algorithm.

Geometric Parameterization

Crash structures are rarely parameterized by raw node coordinates. Instead, engineers define a small set of physically meaningful shape variables that a morphing tool (e.g., ANSA Morph, DEP MeshWorks, or LS-OPT's built-in morphing) can apply to the baseline mesh. Typical variables for a front rail or B-pillar include:

• Wall thickness t — the single most influential variable in most crash studies; ranges are usually ±20–30% of nominal.
• Section dimensions — rail height H, width W, and corner radius R, which control the folding wavelength.
• Trigger bead depth and position — d_bead, x_bead, which set the initial imperfection that determines where the first plastic hinge forms.
• Longitudinal offsets — e.g., the position of a bulkhead or the length of a crush initiator zone.

A practical parameterization keeps the variable count between roughly 5 and 15. Beyond that, the number of DOE runs needed for a space-filling design grows quickly, and the surrogate's variance explodes. Each variable should be defined with an explicit lower and upper bound and a nominal value, and the morphing must be verified to produce valid, non-inverted elements across the entire design space — a common failure mode is a morph that looks fine at the nominal point but collapses a fillet at the corner of the box.

Material Model Variables

For crashworthiness, the dominant constitutive models are *MAT_PLASTIC_KINEMATIC (MAT_003), *MAT_MODIFIED_PIECEWISE_LINEAR_PLASTICITY (MAT_024), and for composites or polymers *MAT_CRUSHABLE_FOAM (MAT_063) or *MAT_SAMP-1. The variables that matter most for the response are:

• Yield stress σ_y and hardening modulus E_t — these set the plateau force in axial crushing.
• Strain-rate parameters C and P in the Cowper–Symonds relation σ_d/σ_s = 1 + (ε̇/C)^(1/P), which govern the dynamic increase in flow stress.
• Failure strain ε_f — controls when elements are deleted and thus when the structure loses load-carrying capacity.
• Density ρ — affects inertia and, in explicit dynamics, the stable time step.

Material variables are often treated as uncertain rather than design variables. In a calibration study, you might sample σ_y from a normal distribution with a 5% coefficient of variation to represent batch-to-batch scatter, while keeping geometry fixed. The distinction matters: design variables are things you can change on the drawing; material variables are things you can only specify within a tolerance band.

Extracting Scalar Responses from d3plot and binout

LS-DYNA writes two primary result streams. d3plot files contain the full state of the model — nodal coordinates, displacements, velocities, stresses, strains, and element state — at each output time. binout files contain reduced, time-history data organized by database: binout/glstat (global energy and momentum), binout/matsum (per-material energy), binout/nodout (nodal time histories), binout/elout (element time histories), and binout/secforc (cross-section forces).

The scalar responses you extract depend on the crashworthiness metric. Common ones include:

In practice, extraction is scripted. The LS-DYNA Python package lasso-python (or the older lsda / lspp batch mode) reads both formats directly. A minimal extraction loop looks like this:

import lasso
from lasso.dyna import D3plot, Binout, ArrayType

d3plot = D3plot("d3plot")
binout = Binout("binout")

# Nodal displacement magnitude over time
disp = d3plot.arrays[ArrayType.node_displacement]   # shape (t, n_nodes, 3)
intrusion = np.linalg.norm(disp, axis=2).max(axis=1)  # per timestep
peak_intrusion = intrusion.max()

# Global internal energy
ie = binout.glstat["internal_energy"]
energy_absorbed = ie[-1]

# Cross-section force
force = binout.secforc["resultant_force"]  # shape (t, n_sections)
peak_force = force.max(axis=0)

Three conventions must be fixed before any of this is comparable across runs. First, units: LS-DYNA is unit-agnostic, so a model in mm–tonne–s–N produces forces in N and energies in mJ; a model in m–kg–s–N produces J. Mixing them silently corrupts the surrogate. Second, filtering: acceleration signals must be filtered per SAE J211 (channel frequency class 60 for occupant, 180 or 1000 for structural), and the filter must be applied identically to every run. Third, time window: responses should be sampled over the same physical duration, not the same number of timesteps, because explicit time steps vary with mesh and material.

Putting the Feature Matrix Together

The final feature matrix has one row per simulation and columns grouped as: design variables (geometry), material variables, and scalar responses. A typical study with 8 geometry variables, 4 material variables, and 6 responses, run over a 60-point Latin Hypercube, yields a 60×18 table. Before training, responses are usually log-transformed (energy, force) or normalized (intrusion as a fraction of available stroke) to stabilize variance. The surrogate then learns a map from the 12 input columns to the 6 output columns — and every one of those columns must be traceable back to a specific extraction script, a specific unit system, and a specific filter setting.

The diagram above summarizes the full pipeline: geometry and material variables feed the explicit simulation, which writes d3plot and binout, from which scalar responses are extracted under fixed conventions to form the final feature matrix. Each stage has its own failure modes — invalid morphs, unit mismatches, unfiltered signals, truncated binout files — and each must be validated before the surrogate is trained. The next chapter moves from feature construction to the design of experiments that populates this matrix efficiently.