3. Neck Nij Criterion Calculation from Six-Axis Load Cell Data

Why Nij Needs Normalization Before Comparison

The Neck Injury Criterion (Nij) is a dimensionless interaction criterion that combines axial force and bending moment at the occipital condyle (or upper neck) into a single number. Raw load-cell channels are not directly comparable: an axial force of 3.5 kN and a bending moment of 60 N·m mean very different things depending on whether the load is tension or compression, and whether the moment is flexion or extension. Nij resolves this by dividing each measured quantity by its critical intercept value, so that a value of 1.0 always represents the threshold of injury risk regardless of the loading mode.

The four Nij modes are defined by the sign combination of the axial force and the bending moment:

• NTE — Neck Tension Extension: tension force with extension moment.
• NTF — Neck Tension Flexion: tension force with flexion moment.
• NCE — Neck Compression Extension: compression force with extension moment.
• NCF — Neck Compression Flexion: compression force with flexion moment.

Each mode has its own critical intercept pair (F_crit, M_crit). A common set of intercepts used in frontal-impact analysis is F_crit,tension = 6.8 kN, F_{crit,compression} = 6.2 kN, M_{crit,extension} = 90 N·m, and M_crit,flexion = 90 N·m. These values are illustrative and must be replaced with the intercepts specified by the applicable regulation or the validated model being used. The criterion for a single mode is:

Nij_mode(t) = F(t) / F_crit + M(t) / M_crit

where F(t) and M(t) are the measured axial force and bending moment at time t, each carrying the sign convention of the mode under evaluation. The peak Nij is the maximum of |Nij_mode(t)| over the event window, and the phase at which that peak occurs identifies the dominant loading mechanism.

Sign Convention and Channel Preparation

Before any arithmetic, fix the sign convention and document it. A workable convention for upper-neck data is: positive axial force = tension, negative axial force = compression; positive bending moment = extension, negative bending moment = flexion. If the load cell or the post-processing pipeline uses the opposite convention, every mode assignment will be inverted and the root-cause conclusion will be wrong. Verify the convention against a known calibration case or a static check (for example, a pure tension pull should produce a positive F channel and near-zero M).

Prepare the time histories as aligned arrays sampled at a common rate. The force and moment channels must share the same time base; a one-sample misalignment between F and M can shift the peak Nij phase and distort the mode classification. Resample to a uniform rate (e.g., 10 kHz) and apply the same anti-alias filter to both channels before computing Nij.

Computing Nij from Measured Time Histories

The following Python snippet computes Nij for all four modes from two aligned arrays and reports the peak value and its time of occurrence. It assumes the sign convention stated above and uses the illustrative intercepts; substitute the correct values for the study.

import numpy as np

# Illustrative critical intercepts (replace with study-specific values)
F_CRIT_TENSION = 6800.0      # N
F_CRIT_COMPRESSION = 6200.0  # N
M_CRIT_EXTENSION = 90.0      # N·m
M_CRIT_FLEXION = 90.0        # N·m

def compute_nij(t, F, M):
    """F in N (tension +), M in N·m (extension +). Returns dict of mode arrays."""
    F = np.asarray(F, dtype=float)
    M = np.asarray(M, dtype=float)
    tension = F >= 0.0
    compression = F < 0.0
    extension = M >= 0.0
    flexion = M < 0.0

    nij = {}
    nij['NTE'] = np.where(tension & extension,
                          F / F_CRIT_TENSION + M / M_CRIT_EXTENSION, 0.0)
    nij['NTF'] = np.where(tension & flexion,
                          F / F_CRIT_TENSION + (-M) / M_CRIT_FLEXION, 0.0)
    nij['NCE'] = np.where(compression & extension,
                          (-F) / F_CRIT_COMPRESSION + M / M_CRIT_EXTENSION, 0.0)
    nij['NCF'] = np.where(compression & flexion,
                          (-F) / F_CRIT_COMPRESSION + (-M) / M_CRIT_FLEXION, 0.0)
    return nij

def peak_nij(t, F, M):
    nij = compute_nij(t, F, M)
    results = {}
    for mode, arr in nij.items():
        idx = int(np.argmax(np.abs(arr)))
        results[mode] = {'peak': float(arr[idx]), 'time_s': float(t[idx])}
    return results

# Example: synthetic 50 ms event, 10 kHz
t = np.arange(0, 0.050, 1e-4)
F = 4200.0 * np.exp(-((t - 0.022) / 0.006) ** 2)   # tension pulse, N
M = 55.0 * np.exp(-((t - 0.024) / 0.007) ** 2)     # extension pulse, N·m

for mode, r in peak_nij(t, F, M).items():
    print(f"{mode}: peak={r['peak']:.3f} at t={r['time_s']*1000:.1f} ms")

With the synthetic inputs above, the expected output is a dominant NTE peak of roughly 1.23 near 22–24 ms, with the other modes near zero because the sign combination only satisfies tension-extension. This is a constructed example, not a measured result; it exists to confirm that the code path, sign handling, and peak search behave as intended before applying them to real data.

Reading the Peak Phase

The time of the peak Nij is the phase that should anchor the root-cause investigation. If the peak occurs during the restraint-loading phase, the dominant contributor is likely the belt or airbag force path; if it occurs during rebound or a secondary head-torso interaction, the mechanism is different. Cross-check the peak time against the kinematic chain reconstruction: the peak Nij phase should coincide with the interval where head and torso relative motion is largest or where the restraint force is highest.

The SVG below shows the processing chain from raw six-axis channels to the four normalized mode curves, with the peak phase marked on the dominant mode.

Verification and Common Failure Modes

Before trusting a peak Nij, run three checks. First, confirm the sign convention by inspecting the raw F and M traces at the peak: the signs must match the mode you are reporting. Second, confirm that the peak time is inside the event window and not at a boundary artifact from filtering or resampling. Third, recompute the peak with a slightly different filter cutoff (e.g., CFC 600 vs. CFC 1000) and confirm the mode classification is stable; if the dominant mode flips with filter choice, the event is near a mode boundary and the conclusion must be reported with that sensitivity.

Once the peak Nij, its mode, and its time are confirmed, the result feeds directly into the root-cause question: which loading path produced that force-moment combination at that phase, and does the kinematic chain support that mechanism? That question is the bridge to the next analytical step.