2. Sled Test Pulse Generation from Target Crash Pulse

Why a Sled Pulse Is Not Simply "Played Back"

A target crash pulse is a specification: acceleration a(t) measured on a vehicle structure during a barrier or car-to-car event, usually delivered as a sampled table with a defined CFC (channel frequency class) filter, a time zero, and a velocity change Δv. A sled is a different dynamic system. The hydraulic or servo-hydraulic actuator, the sled mass, the fixture stiffness, the brake/stopping device, and the control loop all reshape the command before it reaches the sled table. If you load the target pulse directly as a command, the measured sled acceleration will typically show a slower rise, overshoot at the peak, and a long low-amplitude tail — the classic signature of an under-compensated closed-loop system driving a compliant load.

The engineering task is therefore iterative command shaping: find a drive command c(t) such that the measured sled acceleration a_m(t) matches the target a_t(t) within a stated tolerance, while respecting actuator limits (peak force, slew rate, stroke) and keeping the sled velocity change correct.

Defining the Match Criterion Before Iterating

Iteration without a metric degenerates into eyeballing. Define the acceptance criteria up front; a practical set for a 30–50 ms frontal pulse is:

All channels must be filtered identically (e.g., CFC 60 per SAE J211/1) before comparison; comparing a filtered target against an unfiltered measurement is the most common source of phantom "mismatch".

The Iterative Control Loop in Practice

The standard industrial method is a frequency-domain correction loop, sometimes called remote parameter control (RPC) or iterative learning control. In its simplest single-input form:

1. Initial command: use the target pulse itself, scaled by an estimated system gain g₀ (from a low-level sine sweep or a previous similar test).
2. Run and measure: execute the command, record sled table acceleration, filter to the same CFC as the target.
3. Compute the error: e(t) = a_t(t) − a_m(t).
4. Update in the frequency domain: transform command and response to the frequency domain, estimate the system FRF H(f) = A_m(f)/C(f), and correct the command as C_k+1(f) = C_k(f) + α · E(f)/H(f), with a relaxation factor α (typically 0.5–0.9) to damp oscillation between iterations.
5. Constrain and re-run: clip the command to actuator limits, re-run, and repeat until the metrics above are met or the iteration budget (usually 5–10 runs) is exhausted.

A minimal, self-contained implementation of the update step in Python (numpy only) is shown below. It assumes you already have the measured response from the previous run.

import numpy as np

def update_command(cmd, meas, target, dt, alpha=0.7, f_lo=2.0, f_hi=400.0):
    """One RPC-style correction step. All signals same length, same units (m/s^2)."""
    n = len(cmd)
    freqs = np.fft.rfftfreq(n, d=dt)
    C = np.fft.rfft(cmd)
    M = np.fft.rfft(meas)
    T = np.fft.rfft(target)

    # Regularized FRF estimate; avoid division by tiny magnitudes
    eps = 1e-6 * np.max(np.abs(C))
    H = M / (C + eps)

    # Only correct inside the band where the system is well-conditioned
    band = (freqs >= f_lo) & (freqs <= f_hi) & (np.abs(H) > 1e-3)
    E = T - M
    dC = np.zeros_like(C)
    dC[band] = alpha * E[band] / H[band]

    cmd_new = np.fft.irfft(C + dC, n=n)
    return cmd_new

# Example: 40 ms half-sine target, 10 kHz sample rate
dt = 1e-4
t = np.arange(0, 0.040, dt)
target = 400.0 * np.sin(np.pi * t / 0.040)   # ~400 m/s^2 peak
cmd = target.copy()                          # iteration 0
# ... run cmd on the sled, capture meas, then:
# cmd = update_command(cmd, meas, target, dt)

Two practical notes on this code. First, the FRF estimate is noisy at low frequency because the pulse contains little energy there; the band mask prevents the correction from injecting a large DC drift that would corrupt Δv. Second, the relaxation factor α is the single most important tuning knob: α near 1 converges fast but can ring on lightly damped fixtures, while α below 0.5 wastes runs.

Reading the Iteration History

The figure below shows the signal chain and the diagnostic pattern you should expect across iterations. The key insight is that each iteration should reduce the shape error monotonically; if the RMS error stalls or oscillates, the problem is almost always in the FRF estimate (bad coherence, wrong filter, or a nonlinearity such as the sled hitting a mechanical stop).

Worked Example: Three Iterations on a 40 ms Pulse

Consider a target half-sine of 400 m/s² peak, 40 ms duration, Δv ≈ 10.2 km/h, sampled at 10 kHz and filtered to CFC 60. The sled has a known first structural resonance near 85 Hz that the fixture cannot remove. Using the loop above with α = 0.7 and a correction band of 2–400 Hz:

• Iteration 0 (command = target): measured peak 372 m/s², time-to-peak 6 ms late, RMS error ≈ 14 % of peak. The 85 Hz resonance shows as a visible ripple on the falling edge.
• Iteration 1: the FRF correction adds pre-emphasis around 60–100 Hz and a small lead at the rise. Measured peak 391 m/s², RMS error ≈ 9 %.
• Iteration 2: peak 398 m/s², time-to-peak within 1 ms, RMS error ≈ 6 %, Δv within 0.3 km/h. All metrics inside tolerance.

These numbers are illustrative of the expected trend, not a claim about a specific rig. The important behavior is the monotone decrease in RMS error and the fact that the correction is concentrated in the band where the FRF is well-conditioned.

Command Constraints and Velocity Check

Before every run, verify the command against the sled's physical envelope:

• Peak force / acceleration: command peak must stay below the actuator's rated limit with margin (typically 10 %).
• Slew rate: the derivative of the command must not exceed the servo valve's achievable rate; a clipped slew rate shows up as a flattened rise in the measured pulse.
• Stroke: integrate the command twice to estimate sled displacement and confirm it fits the available stroke with braking margin.
• Δv: integrate the measured acceleration, not the command, and compare to the target Δv. A command that matches shape but not Δv means the pulse window or the filter cutoff is wrong.

Deliverable: Iteration Log Template

Keep a per-run log so the convergence is auditable and reproducible. A minimal, fillable version:

Two confirmation runs on the frozen command are standard practice: they catch run-to-run variability (temperature, fixture settling) that a single "good" run can hide. If the confirmation runs fall outside tolerance, the command is not yet robust and the loop should continue.