2. Far-Side Occupant Kinematics in Pole Impact: Seat Belt Routing Sensitivity

Why Belt Routing Dominates Far-Side Response in Pole Impacts

In a side pole impact, the struck-side structure deforms inward and the vehicle develops a strong lateral and yaw acceleration. A far-side occupant — seated on the side opposite the pole — is loaded primarily through the restraint system rather than through direct door intrusion. That makes belt geometry the dominant variable: the diagonal shoulder segment's path across the torso, the lap segment's position over the pelvis, and the anchor and buckle locations together determine how the occupant is coupled to the decelerating vehicle. Small changes in routing produce large changes in head excursion, chest deflection, and pelvis kinematics.

This case isolates that sensitivity. Using the baseline side pole model established previously, we vary the far-side occupant's belt routing across a controlled set of configurations, run each variant, and compare head, chest, and pelvis injury metrics against the baseline reference values. The goal is not to find a single "correct" routing but to quantify how much each routing decision moves the injury response — information you need before trusting any far-side countermeasure evaluation.

Defining the Routing Variables

Three routing parameters are varied independently, each with a physically meaningful range. All other model inputs — impact velocity, pole position, occupant size, seat position, and pretensioner/load-limiter settings — are held at baseline values so that observed differences are attributable to routing alone.

Each variant is run as a single-parameter perturbation of the baseline, giving six runs plus the baseline for a seven-run matrix. This one-at-a-time design keeps attribution clean; if you later need interaction effects, extend to a full factorial, but start here.

Implementing the Routing Variants

In a typical explicit FE solver (LS-DYNA syntax shown), belt routing is defined through the seatbelt element's node path and the retractor/slipring definitions. The D-ring height is set by the coordinates of the slipring node; the lap anchor and buckle positions are set by the belt segment's terminal nodes. A reproducible way to parameterize this is to drive the coordinates from a small include file so each run differs only in that file.

*PARAMETER
$ D-ring vertical offset from nominal (mm)
DringDz, 0.0
$ Lap anchor fore-aft offset (mm)
LapDx, 0.0
$ Buckle stalk length offset (mm)
BuckleDz, 0.0

*DEFINE_COORDINATE_NODES
$ Slipring node follows D-ring offset
SlipNode, 0, 0, 0, 0, 0, 0
$ (node coordinates updated in the include file per run)

*ELEMENT_SEATBELT_SLIPRING
$ id, node, friction
1, SlipNode, 0.15

*ELEMENT_SEATBELT_RETRACTOR
$ id, node, pull-out force, lock
1, RetractNode, 2.5, 1

*ELEMENT_SEATBELT_PRETENSIONER
$ id, node, time, pull-in
1, RetractNode, 0.0, 80.0

*ELEMENT_SEATBELT_2D_SEATBELT
$ id, node1, node2, ...
1, LapAnchorNode, BuckleNode, ...

For each run, edit only the three parameter values in the include file, then submit. A minimal batch driver keeps the matrix reproducible:

#!/bin/bash
# run_matrix.sh — one run per routing variant
SOLVER=ls-dyna_smp_s_R11_1_0
BASE=far_side_pole_baseline.k

run_variant () {
  local name=$1 dring=$2 lap=$3 buckle=$4
  sed -e "s/^DringDz,.*/DringDz, ${dring}/" \
      -e "s/^LapDx,.*/LapDx, ${lap}/" \
      -e "s/^BuckleDz,.*/BuckleDz, ${buckle}/" \
      routing_params.inc > routing_params_${name}.inc
  $SOLVER i=${BASE} ncpu=8 memory=200m \
    keyword=routing_params_${name}.inc > log_${name}.out 2>&1
}

run_variant baseline   0    0    0
run_variant dring_low  -60  0    0
run_variant dring_high  60  0    0
run_variant lap_fwd     0   40   0
run_variant lap_rear    0  -40   0
run_variant buckle_short 0  0   -50
run_variant buckle_long  0  0    50

Confirm each run terminated normally (check the termination time in the log matches the requested end time) before extracting metrics. A run that stops early will produce misleadingly low injury values.

Extracting and Comparing Injury Metrics

From each run, extract the same three metrics used for the baseline reference: head resultant acceleration and HIC36, chest deflection (maximum rib deflection), and pelvis resultant acceleration. Use the same nodal/part sets and the same filtering (CFC 1000 for head, CFC 600 for chest) across all runs so comparisons are valid.

# extract_metrics.py — pull peak values from d3plot via lasso-python
import lasso
import numpy as np

def peak_metric(d3plot, part_id, component, cfc):
    db = lasso.dyna.D3plot(d3plot)
    # ... select part, apply CFC filter, return peak
    return peak

runs = ["baseline","dring_low","dring_high","lap_fwd",
        "lap_rear","buckle_short","buckle_long"]
for r in runs:
    hic = peak_metric(f"d3plot_{r}", HEAD_PART, "resultant", 1000)
    chest = peak_metric(f"d3plot_{r}", CHEST_PART, "deflection", 600)
    pelvis = peak_metric(f"d3plot_{r}", PELVIS_PART, "resultant", 600)
    print(f"{r:14s} HIC36={hic:7.1f}  chest={chest:6.1f}mm  pelvis={pelvis:6.1f}g")

Report each variant as a percentage change from baseline. The table below shows the structure of the comparison; the values are illustrative placeholders to be replaced by your actual run output — do not treat them as measured results.

Reading the Sensitivity Result

The figure below maps how each routing parameter propagates to the three injury metrics. It is the interpretive companion to the run matrix: it shows which routing decisions couple to which injury channel, so you can prioritize the parameters that matter for a given countermeasure.

Two patterns typically emerge from this matrix and are worth checking explicitly in your results. First, D-ring height is the strongest single lever on head metrics: lowering it lets the diagonal drift toward the neck, increasing head excursion and HIC, while raising it improves shoulder capture but shifts load into the chest. Second, lap anchor position trades pelvis coupling against abdominal loading — rearward placement improves iliac engagement and reduces pelvis excursion, but if pushed too far it can promote submarining. Buckle stalk length acts mainly as a secondary modifier of the inboard lap path.

Verification and Failure Symptoms

Validate the matrix in three steps. (1) Baseline reproduction: the baseline run's metrics must match the reference values from the prior case within a few percent; a mismatch means the parameterization altered the model. (2) Monotonicity check: for a single parameter, the low and high variants should bracket the baseline in a physically consistent direction — if both extremes move the same way, suspect a substitution error or a belt that has slipped off its intended path. (3) Visual check: animate the belt in the low-D-ring and forward-lap runs and confirm the belt actually sits where the parameter intends; a belt that has migrated off the shoulder or onto the abdomen invalidates the numeric comparison.

Common failure symptoms and their causes: identical metrics across all variants (the include-file substitution did not take effect — inspect the generated file); early termination in one run (contact or element error — check the log's termination message); and a single variant producing an implausibly large jump (belt element penetrating the torso — review the belt-to-body contact definition).

Deliverable: Routing Sensitivity Summary

Record the completed matrix in a compact summary you can carry into the next cases. Fill the Δ columns from your actual run output; the structure below is the reusable form.

With this matrix complete, you have a quantified ranking of routing levers for the far-side occupant in pole impact. That ranking is the input you need when you later sweep impact angle or pole diameter: it tells you which routing configuration to hold fixed and which to treat as a confound.