2. CAE toolchain and workflow for airbag folding and deployment

An occupant-restraint simulation is only as trustworthy as the chain of tools that produced it. Airbag folding and deployment sits at the intersection of three disciplines: geometry preparation, explicit dynamic solving, and restraint-system post-processing. Each stage hands a specific data artifact to the next, and a defect introduced early — an inverted shell, a missing fabric property, an unstable time step — will surface much later as a non-physical result that is expensive to diagnose. This section maps the toolchain end to end and explains what each stage must deliver.

Stage 1 — Pre-processing: from CAD cushion to folded mesh

Pre-processing begins with the uninflated cushion surface, usually delivered as CAD or as a flattened 2D pattern. The first task is meshing the fabric. Airbag fabric is thin and nearly inextensible, so membrane or shell elements are standard. A typical driver-side cushion uses shell elements with an edge length of 5–10 mm in the deployment-critical regions and coarser mesh (15–20 mm) in areas that only need to hold pressure. Because the fabric carries almost no bending stiffness, membrane formulation is often sufficient, but shell elements are preferred when the folded package must resist self-contact and maintain crease geometry.

Material definition is the second critical input. Woven nylon 6.6 is commonly represented with a fabric material model that captures orthotropic stiffness, nonlinear stress–strain response, and — most importantly — permeability. Permeability controls how much gas leaks through the weave and therefore governs the pressure history inside the cushion. A representative example parameter set for a coated nylon fabric might use a Young's modulus of 2–4 GPa in the warp and weft directions, a Poisson's ratio near 0.3, and a permeability coefficient calibrated so that a static pressure-hold test loses roughly 5–10 % of internal pressure per second. These values are illustrative and must be replaced by coupon-test data for any real program.

Folding is the step that distinguishes airbag simulation from ordinary structural analysis. The flat or partially shaped cushion must be transformed into the compact packaged geometry that sits behind the module cover. Two families of methods dominate:

• Explicit folding simulation — rigid folding plates or a folding fixture push the fabric through a prescribed sequence of motions. This preserves fabric wrinkling and residual stress but is computationally expensive and requires careful contact management.
• Geometric or mapping-based folding — the mesh is projected onto a pre-defined folded topology, or a 2D pattern is mapped into a 3D folded state. This is fast and repeatable, and is often used when the fold pattern is already known from physical prototypes.

Regardless of method, the folded model must be checked for penetrating elements, inverted normals, and excessive initial strain. A useful verification is to run a short static relaxation with the fabric held in the folded state and confirm that element quality metrics (aspect ratio, warpage, minimum angle) remain within solver tolerances.

Stage 2 — Solver selection and explicit dynamics setup

Deployment is a transient, highly nonlinear event dominated by contact, large deformation, and rapid gas flow. Implicit solvers are unsuitable because convergence becomes intractable once the fabric self-contacts and the inflator fires. The standard choice is an explicit dynamics solver — LS-DYNA, Radioss, Abaqus/Explicit, or PAM-CRASH — where the equations of motion are integrated with a central-difference scheme and no global stiffness matrix is assembled.

The stability of an explicit solution is governed by the Courant–Friedrichs–Lewy condition. The stable time step is approximately the smallest element characteristic length divided by the wave speed in the material:

Δt_stable ≈ L_min / c,   c = sqrt(E / ρ)

Example (fabric shell, 6 mm element):
  E = 3.0 GPa, ρ = 1150 kg/m³
  c = sqrt(3.0e9 / 1150) ≈ 1615 m/s
  Δt_stable ≈ 0.006 m / 1615 m/s ≈ 3.7e-6 s

With a 0.7 safety factor: Δt ≈ 2.6e-6 s
A 100 ms deployment therefore needs ~38,000 cycles.

Mass scaling is frequently applied to small or stiff elements that would otherwise force an impractically small time step, but it must be used sparingly: adding mass changes inertia and can distort the early deployment kinematics. A common guideline is to keep added mass below 1–2 % of the total model mass and to verify that the kinetic energy of scaled regions does not dominate the energy balance.

Two solver subsystems deserve explicit attention. First, the inflator model: gas inflow is prescribed either as a mass-flow-rate curve (tank test data) or through a simplified gas generator model using a JWL or ideal-gas equation of state. Second, contact: the fabric must contact itself, the module housing, the cover, and the occupant. A single-surface penalty contact with a friction coefficient around 0.1–0.3 for fabric-to-fabric and fabric-to-metal is a reasonable starting point, but contact thickness and penalty stiffness often need tuning to prevent penetration without introducing spurious oscillations.

Stage 3 — Post-processing for restraint systems

Post-processing answers the engineering question: did the restraint system protect the occupant? The workflow typically extracts three classes of output.

Pressure–time and volume–time curves are the fastest diagnostic. A cushion that inflates too slowly shows a delayed pressure rise and allows excessive occupant excursion; one that inflates too aggressively shows a sharp pressure spike that can cause high HIC even when the occupant is properly positioned. Seam or fabric stress exceeding the material strength indicates a design that will fail in the physical test.

Workflow integration and data hand-off

The three stages are not independent tools bolted together; they form a data pipeline where each artifact must be traceable. The diagram below shows the principal hand-offs and the verification gate at each transition.

The dashed feedback path is the reality of restraint development: a failed injury criterion rarely means the solver is wrong. More often it points back to a fold pattern that produces an asymmetric deployment, a permeability value that lets pressure decay too quickly, or an inflator mass-flow curve that is mismatched to the cushion volume. Keeping the hand-off artifacts — mesh, material card, fold definition, inflator curve, and contact settings — under version control makes that iteration traceable rather than guesswork.

In practice, the toolchain is only as strong as its weakest verification gate. Meshing and folding determine whether the geometry is physically meaningful; the explicit solver determines whether the transient response is numerically credible; post-processing determines whether the result answers the safety question. Treating each stage as a checkpoint — rather than a formality — is what separates a simulation that supports a design decision from one that merely produces colorful contour plots.