2. LS-DYNA DOE fundamentals

Design of Experiments (DOE) in LS-DYNA is not a separate solver feature; it is a disciplined way of wrapping the explicit solver in a parameterized input deck so that a driver — LS-OPT, LS-DYNA's own *PARAMETER machinery, or an external Python/optiSLang loop — can vary inputs, run cases, and collect scalar responses. The quality of an optimization study is decided almost entirely before the first simulation runs: by how cleanly the design variables are exposed, how precisely the responses are extracted, and how the keyword deck is structured so that a single file can represent an entire design space.

Design variables: what should actually be varied

A design variable (DV) is a numeric quantity that the DOE driver writes into the deck before each run. In crashworthiness and impact work, typical DVs are sheet-metal gauge (t), rib spacing, fillet radius, material yield stress, foam density, or a lumped stiffness of a simplified joint. The essential rule is that every DV must be physically meaningful, independently controllable, and bounded by manufacturing reality. A gauge that varies from 0.8 mm to 2.0 mm is a legitimate DV; a mesh size that changes topology between runs is not, because it introduces discretization noise that swamps the physical effect being studied.

Two practical constraints govern DV selection. First, keep the count modest — with a 5-level full factorial, 6 DVs already require 15,625 runs, so screening designs (Plackett-Burman, fractional factorial) or Latin Hypercube sampling are used to identify the influential subset before a response-surface or metamodel-based optimization is attempted. Second, define bounds and a nominal baseline for every DV, because the driver needs a reference point for sensitivity and because out-of-range values frequently cause negative-volume or contact-instability errors rather than clean results.

Responses: turning a transient field into a scalar

An optimizer cannot consume a contour plot. Each response must be reduced to one number per run: peak acceleration at a node, maximum intrusion of a firewall, HIC36, total mass, or the time of a specific event. In LS-DYNA this reduction is done with *DATABASE_ASCII output plus a post-processing step, or natively with *ELEMENT_SEATBELT_...-style history variables and, more generally, *DATABASE_HISTORY_NODE / *DATABASE_HISTORY_SHELL followed by extraction of the maximum over the time history. The response definition must be unambiguous: "peak acceleration" is meaningless unless the filter (SAE J211 CFC 60 or CFC 180), the node set, and the time window are all fixed. Changing the filter between runs invalidates the DOE.

A useful discipline is to declare responses in a small extraction script that reads the nodout or glstat file and writes a single CSV row per run. This keeps the response definition version-controlled and identical across every case.

Parameterizing the deck with *PARAMETER

The *PARAMETER keyword is the backbone of a parameterized LS-DYNA deck. It declares named scalars and, critically, allows arithmetic expressions so that derived quantities stay consistent when a primary DV changes. A minimal, realistic block looks like this:

*PARAMETER
$#   prmr        val
      THK1      1.2000
      THK2      0.8000
      RIBW      25.000
      YIELD     350.00
      THK1H     &THK1/2.0
      MASS_TGT  12.500
*PARAMETER_EXPRESSION
$#   prmr                              expression
      AREA_RIB                          &RIBW*&THK1

Every downstream card then references the parameter with an ampersand prefix, for example &THK1 in a *SECTION_SHELL thickness field or &YIELD in a *MAT_PIECEWISE_LINEAR_PLASTICITY yield stress. The DOE driver only needs to rewrite the val column of the *PARAMETER block — a single, well-defined edit point — and the rest of the deck follows automatically. This is why parameterization should be done once, thoroughly: a hard-coded thickness buried in a *PART or *INITIAL_... card silently breaks the DOE because that run no longer responds to the DV.

*DEFINE_CURVE: parameterizing time-dependent inputs

Many DVs are not constants but curves — a velocity pulse, a pressure-time history, or a material hardening table. *DEFINE_CURVE stores abscissa/ordinate pairs, and its ordinate values can themselves be parameter expressions, so a curve can be scaled or shifted by a DV without editing every point:

*DEFINE_CURVE
$#    lcid      sidr       sfa       sfo      offa      offo    dattyp
         1         0     &VSCALE   1.000     0.000     0.000         0
$#                a1                  o1
               0.000               0.000
               0.005             &PULSE
               0.010             &PULSE
               0.020               0.000

Here &VSCALE and &PULSE are DVs, letting the DOE explore pulse amplitude and duration independently. The same mechanism parameterizes *DEFINE_TABLE-driven strain-rate curves. A common pitfall: *DEFINE_CURVE is referenced by lcid, and if a parameter changes the lcid numbering, references break — so keep curve IDs fixed and vary only ordinates.

The simulation workflow for optimization

The end-to-end loop is: (1) build a baseline deck that runs cleanly to termination; (2) replace every candidate DV with a *PARAMETER reference and verify by running the baseline twice with a perturbed value and confirming the response changes; (3) define responses and an extraction script; (4) choose a DOE sampling plan (full factorial for ≤3 DVs, Latin Hypercube or D-optimal otherwise); (5) let the driver generate N decks, run them in parallel, and collect the response CSV; (6) fit a metamodel (quadratic response surface or Kriging) and run the optimizer on the surrogate; (7) validate the optimum with a full LS-DYNA run and, if the surrogate error exceeds tolerance, add points and refit.

Worked example: a simplified front-rail gauge study

Consider a simplified front rail modeled with shell elements, where the objective is to minimize mass subject to peak acceleration at the occupant reference node ≤ 45 g (CFC 60) and firewall intrusion ≤ 120 mm. Two DVs are declared: THK1 (outer, 1.0–1.8 mm) and THK2 (inner, 0.6–1.2 mm). A 3×3 full factorial gives 9 runs. The extraction script reads nodout for the reference node, applies the CFC 60 filter, and writes peak_accel and max_intrusion to responses.csv. After the 9 runs, a quadratic surface is fit to each response; the optimizer then searches the surrogate for the minimum-mass point satisfying both constraints. The candidate optimum is re-run in LS-DYNA, and if the measured peak acceleration differs from the surrogate prediction by more than, say, 5%, additional points near the optimum are added and the surface refit.

The payoff of this discipline is that the DOE becomes reproducible and auditable: the parameter block, the curve definitions, the response script, and the sampling plan together fully define the study, so any engineer can regenerate every run and trace the optimum back to specific solver outputs.