4. Validating Head Injury Criterion Against Experimental Drop Test Data

Why a Head Drop Test Is the Right Validation Vehicle

Head injury criterion (HIC) is a scalar derived from the resultant translational acceleration at the head center of gravity. Because it is a pure function of the acceleration–time history, a head model can only be trusted for injury prediction if its simulated acceleration trace reproduces the shape, peak, and duration of a physically measured trace. The classic free-fall drop test — a headform released onto a rigid plate, with a uniaxial accelerometer at the CG — is the cleanest way to isolate that behavior: there is no neck, no belt, and no torso to confound the signal. If the model cannot match a drop test, no amount of restraint-system fidelity will rescue its HIC prediction.

This case therefore has three coupled deliverables: a stable drop simulation, a correct HIC computation from the simulated acceleration, and a defensible comparison against published experimental corridors. Each of the three can fail independently, and the failure modes look different.

Defining the Drop Setup and the Reference Frame

Adopt a single sign convention and hold it everywhere: +Z is up, gravity acts as -9.81 m/s² in Z, and the accelerometer reports the head acceleration (not the reaction at the plate). A drop from height h onto a rigid surface gives an impact speed of v = sqrt(2·g·h). For a 4.7 kg headform dropped from 1.0 m, the nominal impact speed is about 4.43 m/s; this is the number the corridor was generated at, so it must be matched, not approximated.

A workable LS-DYNA deck skeleton for the impact region is shown below. The headform is a rigid body with a concentrated mass and an accelerometer node at the CG; the plate is a rigid wall. The initial velocity is applied to the head part only.

*KEYWORD
*CONTROL_TERMINATION
         30.0
*CONTROL_TIMESTEP
       0.0      0.90                             0
*DATABASE_GLSTAT
       0.1
*DATABASE_NODOUT
      0.01
*PART
headform,       1,         1,         1
*MAT_RIGID
         1,    7.85e-9,  2.10e5,       0.3
       0.0,       0.0,       0.0
*PART
plate,          2,         2,         2
*MAT_RIGID
         2,    7.85e-9,  2.10e5,       0.3
       0.0,       0.0,       0.0
*INITIAL_VELOCITY_RIGID_BODY
         1,       0.0,       0.0,     -4430.0
*RIGIDWALL_PLANAR
         0,         0,       1.0,       0.0
       0.0,       0.0,       0.0,       0.0
*CONSTRAINED_EXTRA_NODES
         1,         0
*SET_NODE_LIST
         0,         0
      1001,
*DATABASE_HISTORY_NODE
      1001,
*END

Two details matter more than they appear. First, *DATABASE_NODOUT at 0.01 ms gives a 100 kHz sampling rate — HIC is sensitive to peak resolution, and a 1 kHz trace will systematically under-predict the peak. Second, the accelerometer node must be a node of the rigid headform, not a separate mass, so that the recorded acceleration is the rigid-body CG acceleration.

Computing HIC Correctly from the Output

HIC is defined over a time window [t1, t2] as

HIC = max over t1,t2 of [ (t2 − t1) · ( (1/(t2−t1)) ∫ a(t) dt )^2.5 ]

with a(t) in g and the window length capped at 36 ms for the standard HIC36. The practical pitfalls are: (1) using the plate reaction instead of the head acceleration, (2) integrating in m/s² and forgetting the /9.81 conversion, and (3) searching windows that start before impact. The script below reads the nodout history, converts to g, and performs the window search.

import numpy as np

def load_nodout(path):
    t, az = [], []
    with open(path) as f:
        for line in f:
            parts = line.split()
            if len(parts) >= 4 and parts[0].replace('.','',1).isdigit():
                t.append(float(parts[0]))
                az.append(float(parts[3]))   # Z acceleration, model units
    return np.array(t), np.array(az)

def hic(t, a_g, window_ms=36.0):
    dt = t[1] - t[0]
    n = int(window_ms / (dt * 1000.0))
    best = 0.0
    best_win = (0.0, 0.0)
    for i in range(len(t)):
        for j in range(i + 1, min(i + n, len(t))):
            dur = t[j] - t[i]
            if dur <= 0:
                continue
            mean_a = np.trapz(a_g[i:j+1], t[i:j+1]) / dur
            val = dur * (mean_a ** 2.5)
            if val > best:
                best = val
                best_win = (t[i], t[j])
    return best, best_win

t, az = load_nodout("nodout")
a_g = az / 9810.0          # mm/s^2 -> g
h, win = hic(t, a_g)
print(f"HIC36 = {h:.1f}  window = {win[0]*1000:.2f}–{win[1]*1000:.2f} ms")

Run this against the simulated trace and record the peak acceleration, the HIC window, and the pulse duration. These three numbers are what you compare to the corridor — not HIC alone.

Reading the Corridor Comparison

Published drop-test corridors are usually given as an acceleration envelope (upper and lower bounds versus time) plus a HIC range. A model is validated when the simulated trace stays inside the envelope for the dominant pulse and the computed HIC falls within the reported range. The SVG below shows the three diagnostic outcomes you will actually encounter when you overlay the simulated trace on the corridor.

The three outcomes map to distinct root causes. A trace that overshoots the upper bound with a short, sharp pulse usually means the headform–plate contact is too stiff or the headform mass is too low; check *CONTACT stiffness and the rigid-body mass. A trace that sits below the lower bound with a stretched pulse points to excessive damping or a soft contact definition. High-frequency ringing superimposed on the pulse is almost always a contact-stiffness or hourglass artifact, not a physical response — filter it before computing HIC, but never filter so aggressively that you erase the peak.

Acceptance Criteria and What to Record

Treat the validation as passed only when all three conditions hold simultaneously: the simulated peak acceleration lies within the corridor envelope, the HIC36 falls inside the published range, and the pulse duration (time above 50% of peak) matches within roughly 10%. Record the following in a short validation table so the result is auditable:

If the model fails, do not tune HIC directly — HIC is an output, not a knob. Adjust the physical inputs that control the pulse: headform mass, contact stiffness, and any damping in the headform material. Re-run, recompute HIC with the same script, and re-overlay. A model that passes the drop test on peak, HIC, and duration is then defensible when it is embedded in a full restraint simulation, because its injury-prediction capability has been anchored to measured data rather than assumed.