2. LS-DYNA explicit solver essentials for airbag simulation

Airbag deployment is a transient, highly nonlinear event: the folded cushion unfolds in roughly 20–50 ms, fabric undergoes large membrane deformation, gas pressure loads the shell, and contact between the bag, the occupant, and the steering wheel or instrument panel changes continuously. LS-DYNA's explicit solver is the standard tool for this class of problem because it advances the solution one small time increment at a time without assembling or factorizing a global stiffness matrix. Understanding how that time integration works — and how the time step, mass scaling, and stability limits interact — is what separates a model that runs to termination from one that blows up at cycle 300.

Central-Difference Time Integration

LS-DYNA uses the explicit central-difference method. For each node, acceleration at time t_n is obtained directly from the equation of motion:

M · a_n = F_ext,n − F_int,n
a_n = M⁻¹ (F_ext,n − F_int,n)

Because the mass matrix M is lumped (diagonal), the inverse is trivial and no linear solve is required. Velocity and displacement are then updated with second-order accurate central differences:

v_(n+1/2) = v_(n−1/2) + a_n · Δt_n
d_(n+1)   = d_n + v_(n+1/2) · Δt_(n+1/2)

The scheme is conditionally stable. If the time step exceeds a critical value, the numerical solution grows without bound and the run terminates with the familiar "negative volume" or "energy ratio" error. The critical step for a linear elastic material is:

Δt_crit = 2 / ω_max = L_c / c
c = sqrt(E / ρ)

where L_c is the characteristic element length, c is the wave speed, E is Young's modulus, and ρ is density. For airbag fabric, E is on the order of 1–5 GPa and ρ ≈ 700–900 kg/m³, giving wave speeds of roughly 1200–2500 m/s. A 5 mm fabric element therefore has a critical step near 2–4 µs. This is the number that governs the entire cost of the simulation.

Time-Step Control in Practice

LS-DYNA computes the time step from the smallest element in the model, not the average. A single collapsed or sliver element in the folded cushion can reduce the global step by an order of magnitude. The recommended workflow is:

1. Run a short initialization (e.g., *CONTROL_TERMINATION with ENDTIM = 0.001 s) and inspect the d3hsp file for the reported "smallest timestep" and the element ID that controls it.
2. Fix the offending element by remeshing, smoothing, or adjusting the fold geometry rather than accepting the penalty.
3. Set *CONTROL_TIMESTEP with DTINIT left at 0 (auto-compute) and a TSSFAC of 0.9 for fabric-dominated models (0.6–0.9 is typical; lower values add robustness at the cost of runtime).

For airbag models, the fabric shell elements usually control the step. If the gas inside the bag is modeled with *AIRBAG_* keywords (uniform pressure or particle method), the gas does not add a wave-speed constraint, but the fabric does. If a CFD or ALE gas domain is used, the gas element step may become critical instead.

Mass Scaling: When and How

Mass scaling artificially increases the density of small elements so their critical step rises to a target value. It is the most common lever for reducing airbag runtimes, but it must be applied with discipline. Two forms exist:

• Selective mass scaling (*CONTROL_TIMESTEP with DT2MS < 0): only elements whose step is below the target are scaled. This is the preferred option for airbag folding because it leaves the bulk of the mesh untouched.
• Global mass scaling (DT2MS > 0): all elements are scaled to the target step. Rarely appropriate for airbags because it adds mass everywhere and corrupts the inertia of the deploying cushion.

A practical target is to scale only elements below 1 µs up to 1 µs, which typically recovers 30–60% of runtime. The added mass must be monitored: LS-DYNA reports the "percentage mass increase" in the d3hsp file and in the glstat output. Keep the total added mass below 1–2% of the model mass for airbag work; above that, the deployment kinematics (especially early-time unfolding) can be visibly altered.

Stability Considerations Beyond the Time Step

Even with a valid time step, airbag models can become unstable for reasons unrelated to the Courant condition:

• Hourglassing in under-integrated shell elements. Use *CONTROL_HOURGLASS with type 4 (stiffness-based) or type 6 (assumed strain) and verify that the hourglass energy in glstat stays below 5% of internal energy.
• Contact instability at the bag–occupant interface. Set SOFT = 1 or 2 on *CONTROL_CONTACT and use a nonzero PENSL to avoid chattering.
• Negative volume in the folded cushion. This usually traces back to a bad fold or an element that inverts during the first few milliseconds. Inspect the messag file for the element ID and remesh that region.
• Energy ratio (total energy / initial energy) drifting above 1.05. This indicates numerical energy being added; check for mass scaling, contact penalties, or hourglass control.

The following diagram summarizes how the time step, mass scaling, and stability checks relate to one another in a typical airbag run.

Putting It Together: A Minimal Working Setup

A defensible starting configuration for a driver-side airbag model looks like this:

*CONTROL_TERMINATION
$  ENDTIM   ENDCYC   DTMIN   ENDENG   ENDMAS
   0.050    0        0.0     0.0      0.0

*CONTROL_TIMESTEP
$  DTINIT   TSSFAC   ISDO     DT2MS    LCTM     ERODE   MS1ST
   0.0      0.9      0       -1.0E-6   0        0       0

*CONTROL_HOURGLASS
$  IHQ      QH
   4        0.05

*CONTROL_CONTACT
$  SLSFAC   RWPNAL   ISLCHK   SHLTHK   PENOPT   THKCHG   ORIEN
   0.1      0.0      2        1        1        1        0
$  USRSTR   USRFRC   NSBCS    INTERM   XPENE    SSTHK    ECDT
   0        0        0        0        0        0        0
$  TIEDPRJ  SFRIC    DFRIC    EDC       INN     ...
   0        0.0      0.0      0.0       0

After the first run, check three numbers in glstat: the time step actually used (should be close to DT2MS if scaling is active), the percentage mass increase (should be under 2%), and the hourglass energy fraction (under 5%). If any of these is out of range, adjust the mesh or the scaling target before extending the termination time. This iterative check is the core discipline of explicit airbag simulation: the solver will run whatever you give it, but only a controlled time step and a monitored mass budget produce results you can trust.