Metric reference

One row per number the interface can show. Scope driver = shown by default; engineer = Engineer view only. Formulas are rendered on the methodology pages.

id	label	scope	stored unit	shown	source	parameters	page
lap_time	Lap time	driver	s	s	GPS positions (valid samples) and the start/finish gate	lap_gate_min_halfwidth_m, lap_gate_spread_factor, lap_gate_heading_max_deg, lap_cross_min_speed_ms, lap_min_lap_s	lap-detection
delta_to_fastest	vs fastest	driver	s	s	lap times	—	lap-detection
lap_spread	Lap spread	driver	s	s	lap times of the racing laps	—	lap-detection
lap_progress_time	Lap time at position	driver	s	s	continuity-constrained projection of the lap onto the centerline	centerline_ds_m, proj_sigma_s_m, proj_back_tol_m, proj_n_max_m	track-progress
final_delta	Lap delta	driver	s	s	lap progress t(s) of both laps	delta_invariant_tol_s	lap-delta
delta_t	Time delta along the lap	driver	s	s	PCHIP progress interpolants t_A(s), t_R(s) on the 1 m centerline grid	centerline_ds_m, delta_display_smooth_m, sg_polyorder, delta_low_confidence	lap-delta
segment_delta	Segment delta	driver	s	s	unsmoothed Δt(s) of the pair; segment boundaries as fractions of lap length	segment_curvature_smooth_m, segment_corner_fraction, segment_blob_m, segment_min_length_m, segment_center_fraction	lap-delta
speed	Speed	driver	m/s	mph	GoPro reported 2-D GPS speed (receiver velocity solution)	speed_cutoff_hz, speed_gap_fill_s, gps_gap_s	speed
a_long_path	Longitudinal acceleration (path)	engineer	m/s²	g	v_analysis	sg_window_long_s, sg_polyorder, speed_cutoff_hz	speed
cornering_g	Cornering G	driver	m/s²	g	GPS only: v_analysis and the path heading from GPS positions	sg_window_heading_s, sg_polyorder, speed_cutoff_hz, heading_min_speed_ms	cornering-g
cornering_g_sustained	Cornering G, sustained	driver	g	g	Cornering G inside the segment	sustained_window_s	cornering-g
chassis_load	Chassis Lateral Load	driver	m/s²	g	accelerometer (specific force) rotated into the vehicle frame by the mount calibration	imu_cutoff_hz, imu_hampel_window, imu_hampel_nsigma, imu_replace_clipped, imu_decimate_hz, calib_corr_good, calib_corr_ok, mount_drift_max_deg	chassis-load
chassis_load_sustained	Chassis Load, sustained	driver	g	g	Chassis Lateral Load inside the segment	sustained_window_s	chassis-load
min_speed	Minimum speed	driver	m/s	mph	v_analysis inside the segment	speed_cutoff_hz	speed
entry_exit_speed	Entry / exit speed	driver	m/s	mph	v_analysis at the segment boundaries	—	speed
brake_point	Brake point	driver	m (track position s)	m	a_long_path inside the segment	brake_threshold_ms2, brake_sustain_s, sg_window_long_s	speed
accel_point	Acceleration point	driver	m (track position s)	m	a_long_path after the minimum speed	accel_threshold_ms2, accel_sustain_s, sg_window_long_s	speed
line_offset	Line offset	driver	m	m	continuity-constrained projection onto the centerline	proj_n_max_m, centerline_ds_m	track-progress
gps_valid_fraction	GPS valid	driver	fraction	%	GPS quality flags	gps_fix_min, gps_dop_max, gps_prelock_valid_run_s, gps_jump_speed_factor, gps_jump_noise_m, gps_jump_speed_floor_ms, gps_speed_max_ms, gps_spike_accel_ms2, gps_spike_recovery_samples, gps_hampel_window, gps_hampel_nsigma, gps_hampel_min_ms	gps-validation
proj_confidence	Projection confidence	engineer	fraction	—	continuity-constrained projection	proj_n_max_m, proj_sigma_s_m, proj_min_window_m, proj_back_tol_m, proj_lost_limit	track-progress
body_yaw_lateral	Body-yaw lateral (gyro)	engineer	m/s²	g	gyroscope yaw rate in the vehicle frame and v_analysis	lean_lowpass_hz, imu_cutoff_hz, imu_decimate_hz	cornering-g
lean_est	Lean estimate	engineer	rad	°	Chassis Lateral Load, vertical specific force and Cornering G	lean_lowpass_hz	chassis-load
mount_confidence	Mount calibration confidence	engineer	fraction	—	stationary up-vector, lateral-axis fit, handedness test	stationary_min_seconds, stationary_speed_max_ms, calib_corr_good, calib_corr_ok, handedness_agreement_min, handedness_min_lat_ms2, stationary_up_spread_max_deg	chassis-load
gps_lag	GPS lag	engineer	s	s	cross-correlation of low-passed f_body_x with a_long_path (yaw rate as cross-check)	—	video-sync
sync_offset	Video sync offset δ	engineer	s	s	video frame clock vs session clock	—	video-sync

Definitions

lap_time — Lap time

Time between two consecutive accepted crossings of the start/finish gate. Each crossing time is interpolated between the two GPS samples that straddle the gate.

• Formula: T = t_end − t_start; t_c = t[i−1] + (t[i] − t[i−1])·λ (λ = intersection parameter along the sample segment)
• Algorithm: lap-detect-1.0.0+laps-1.0.0+centerline-1.0.0+projection-1.0.0
• API: GET /sessions/{sid}/laps → laps[].lap_time_s
• Confidence / quality: Crossing confidence = clip(1 − |lateral offset| / gate half-width) × clip(cos heading error); the lap keeps the lower of its two crossings. Resolution of order 5–10 ms (a fraction of a GPS sample interval).
• Limitation: Only complete laps have gate-independent times.
• Limitation: Receiver latency is common to both crossings and cancels.
• Validation: engine/tests/unit/test_laps_geometry.py
• Validation: engine/tests/synthetic (exact lap count and times on a synthetic oval)
• Validation: regression goldens: lap times ±5 ms on both fixtures

delta_to_fastest — vs fastest

Lap time minus the fastest racing lap's time in this session. Positive means slower.

• Formula: ΔT = T − T_fastest
• Algorithm: lap-detect-1.0.0+laps-1.0.0+centerline-1.0.0+projection-1.0.0
• API: GET /sessions/{sid}/laps → laps[].delta_to_fastest_s
• Confidence / quality: Defined for racing and caution laps; partial, pit and invalid laps have no value.

lap_spread — Lap spread

Slowest racing lap time minus fastest racing lap time in the session; a quick measure of consistency.

• Formula: max(T) − min(T) over racing laps; undefined with fewer than two racing laps
• Algorithm: lap-detect-1.0.0+laps-1.0.0+centerline-1.0.0+projection-1.0.0
• API: GET /sessions → lap_spread_s
• Confidence / quality: Uses only laps classified racing.

lap_progress_time — Lap time at position

Seconds since the lap's start/finish crossing when the car reached track position s, from the lap's monotone progress interpolant on the 1 m grid.

• Formula: t_rel(s): PCHIP through the running maximum of projected s, anchored at (0, 0) and (L, T)
• Algorithm: speed-1.0.0
• API: GET /sessions/{sid}/profile/{lap} → t_rel
• Confidence / quality: Shown at the nearest 1 m grid point; low where the lap's projection confidence is low.

final_delta — Lap delta

How much slower (+) or faster (−) the comparison lap is than the reference lap over the whole lap. Equal to the difference of the two lap times by construction.

• Formula: Δt(L) = t_A(L) − t_R(L) = T_A − T_R
• Algorithm: delta-1.0.0
• API: GET /sessions/{sid}/delta?lap=A&ref=R → final_delta_s
• Confidence / quality: Endpoint invariant |Δt(L) − (T_A − T_R)| ≤ delta_invariant_tol_s (1 ms); pairs that fail are not written.
• Validation: engine/tests/unit/test_delta_unit.py
• Validation: property test over real lap pairs
• Validation: regression goldens Δt at fixed s

delta_t — Time delta along the lap

At each track position s, the time the comparison lap needed to get there minus the time the reference lap needed. Rising = losing time, falling = gaining.

• Formula: Δt(s) = t_A(s) − t_R(s); display trace = Savitzky–Golay smoothing over 10 m (order 2) re-anchored at both ends
• Algorithm: delta-1.0.0
• API: GET /sessions/{sid}/delta → delta_t (unsmoothed), delta_t_display (display), loss_rate (dΔt/ds)
• Confidence / quality: Low-confidence where either lap's projection confidence < delta_low_confidence (0.5) or inside a GPS gap > 0.5 s; shaded on the chart. Continuity bound max|ΔΔt| ≤ Δs (1/v_min,A + 1/v_min,R).
• Limitation: Projection jitter of 0.2–0.5 m gives ≈ 15 ms of local texture; the display trace is smoothed for reading only, all numbers use the unsmoothed series.
• Validation: engine/tests/synthetic: prescribed time-difference profile recovered within 5 ms

segment_delta — Segment delta

The share of the lap delta accumulated inside one corner or straight: the delta at the segment's end minus the delta at its start. Segment deltas sum to the lap delta.

• Formula: Δt_seg = Δt(s_end) − Δt(s_start), unwrapped through start/finish by adding Δt(L) per wrap
• Algorithm: segments-1.0.0+segment-results-1.0.0
• API: GET /sessions/{sid}/segments → pairs[].segments[].delta_t_s
• Confidence / quality: Each segment reports the fraction of its grid points that are low-confidence. A delta of 0.05 s or more is 'notable' (plan §19.2).
• Validation: engine/tests/synthetic/test_segments_synthetic.py
• Validation: tests/regression/test_phase10_segments.py

speed — Speed

The receiver's own speed with invalid samples removed, short gaps filled, and a zero-phase low-pass filter applied, resampled onto the track grid.

• Formula: v_analysis = zero-phase Butterworth (order 2 forward+backward = effective order 4, cutoff speed_cutoff_hz) of v_valid
• Algorithm: speed-1.0.0
• API: GET /sessions/{sid}/profile/{lap} → v_analysis (also v_raw)
• Display conversion: mph = m/s × 3600/1609.344
• Confidence / quality: Uses only valid GPS samples; the position-derived speed is an independent witness (must agree within 1.5 m/s over 2 s windows in ≥ 95 % of moving windows).
• Limitation: Receiver speed lags true motion by 0.15–0.40 s (measured gps_lag_s); constant over a session and common to both laps of a comparison.
• Validation: Phase 6 filter selection on real files (docs/proofs/phase-06/filter_selection.md)
• Validation: engine/tests/unit/test_speed_filters.py
• Validation: regression goldens max/min/avg per racing lap

a_long_path — Longitudinal acceleration (path)

Rate of change of the filtered GPS speed along the path. Positive = accelerating. Drives the brake and acceleration points.

• Formula: a_long_path = SG derivative of v_analysis (window sg_window_long_s, order sg_polyorder)
• Algorithm: speed-1.0.0
• API: GET /sessions/{sid}/profile/{lap} → a_long_path
• Display conversion: g = m/s² / 9.80665

cornering_g — Cornering G

How hard the car's path is actually curving: speed times the rate of change of the path heading. Contains no gravity, banking or body roll by construction.

• Formula: a_lat_path = v_analysis × ψ̇; ψ from SG derivatives of ENU position (window 1.0 s, order 2), unwrapped, zero-phase low-passed at 1 Hz; ψ̇ = SG derivative (1.0 s, order 2); masked below 3 m/s
• Algorithm: speed-1.0.0
• API: GET /sessions/{sid}/profile/{lap} → a_lat_path
• Display conversion: g = m/s² / 9.80665
• Confidence / quality: Undefined below heading_min_speed_ms (3 m/s). Noise 0.02–0.04 g (1σ) on straights with no corner bias (Phase 6). Corroborated per lap by the gyro: net rotation ∫r dt vs ∫ψ̇ dt agree within 5 % on every stable lap.
• Limitation: Instantaneous gyro yaw rate differs from the path heading rate on dirt because the car runs at a slip angle; the gyro channel is a distinct 'body-yaw lateral' quantity, not a substitute.
• Validation: Phase 6/8 proofs
• Validation: engine/tests/synthetic: constant-speed circle a_lat = v²/R within 2 %
• Validation: regression goldens cornering_g_sustained per corner ±0.02 g

cornering_g_sustained — Cornering G, sustained

The highest 1-second average of |Cornering G| inside the segment. A single spike cannot move it by more than its energy share.

• Formula: max over t of mean |a| over [t, t + sustained_window_s], evaluated on a uniform 20 ms time axis
• Algorithm: segments-1.0.0+segment-results-1.0.0
• API: GET /sessions/{sid}/segments → laps[].segments[].cornering_g_sustained
• Confidence / quality: Edge-masked (first/last 0.5 s of a run excluded). Window is 8–16 % of a corner's duration on the fixtures.
• Validation: Phase 8 spike test: one 5 g sample changes the sustained value by < 0.01 g
• Validation: regression goldens per corner

chassis_load — Chassis Lateral Load

The sideways load the chassis experiences, in the car's own left axis. Includes the gravity component produced by banking and body roll; banking reduces it, which is what banking is for.

• Formula: f_body_y = (accel_sign × R_{V←C} × f_C,filtered)_y; clipped samples replaced by an 11-sample rolling median, zero-phase Butterworth order 4 at 5 Hz, decimated to 50 Hz
• Algorithm: imu-1.0.0+mount-1.0.0
• API: GET /sessions/{sid}/profile/{lap} → imu.f_body_y
• Display conversion: g = m/s² / 9.80665
• Confidence / quality: Shown only when mount priority ≤ 3 (automatic confidence ≥ 0.5 or a manual override) and the lap is not flagged mount_moved. Confidence = min of stationary, correlation and handedness components.
• Limitation: Depends on a rigid mount; a flexing pole mount gives 0.21 g RMS disagreement with a rigid camera in the same car.
• Limitation: Only bank + roll relative to the parked attitude is observable.
• Validation: Phase 8: stationary f_V = (0,0,g₀) ± 0.05 g; handedness ≥ 95 %; two-camera gyro lateral agreement 0.08–0.10 g RMS
• Validation: engine/tests/unit/test_imu_conventions.py (S1–S5 closed-form cases)

chassis_load_sustained — Chassis Load, sustained

The highest 1-second average of |Chassis Lateral Load| inside the segment.

• Formula: max over t of mean |f_body_y| over [t, t + sustained_window_s]
• Algorithm: segments-1.0.0+segment-results-1.0.0
• API: GET /sessions/{sid}/segments → laps[].segments[].chassis_load_sustained
• Confidence / quality: Same visibility rule as Chassis Lateral Load.

min_speed — Minimum speed

The lowest filtered speed inside the segment and where it occurs.

• Formula: nanmin of v_analysis over the segment's grid points; min_speed_s = its position
• Algorithm: segments-1.0.0+segment-results-1.0.0
• API: GET /sessions/{sid}/segments → laps[].segments[].min_speed_ms, min_speed_s
• Display conversion: mph = m/s × 3600/1609.344

entry_exit_speed — Entry / exit speed

Filtered speed at the first and last grid point of the segment.

• Formula: v[0], v[-1] of the segment's grid values
• Algorithm: segments-1.0.0+segment-results-1.0.0
• API: GET /sessions/{sid}/segments → laps[].segments[].entry_speed_ms, exit_speed_ms
• Display conversion: mph = m/s × 3600/1609.344

brake_point — Brake point

The first track position in the segment where the car decelerates harder than 2 m/s² for at least 0.3 s.

• Formula: first s of the first run with a_long_path < −brake_threshold_ms2 lasting ≥ brake_sustain_s
• Algorithm: segments-1.0.0+segment-results-1.0.0
• API: GET /sessions/{sid}/segments → laps[].segments[].brake_point_s (metres of s, not seconds)
• Limitation: Braking that starts before the segment is reported at the segment start.

accel_point — Acceleration point

The first track position after the minimum speed where the car accelerates harder than 1 m/s² for at least 0.5 s.

• Formula: first s after i_min with a_long_path > accel_threshold_ms2 sustained ≥ accel_sustain_s
• Algorithm: segments-1.0.0+segment-results-1.0.0
• API: GET /sessions/{sid}/segments → laps[].segments[].accel_point_s
• Limitation: Absent ('—') when the threshold is never sustained inside the segment.

line_offset — Line offset

Mean signed distance of the lap's GPS positions from the track centerline inside the segment. Positive = left of the direction of travel (inside on a left-turning oval).

• Formula: nanmean of lat_offset over the segment's grid points
• Algorithm: segments-1.0.0+segment-results-1.0.0
• API: GET /sessions/{sid}/segments → laps[].segments[].lat_offset_mean_m; profile → lat_offset
• Limitation: Absolute consumer-GPS position error is 2–3 m; the difference between two laps of the same session is much better because errors are correlated.

gps_valid_fraction — GPS valid

Share of GPS samples with no invalidating flag (no fix, high DOP, pre-lock, non-monotonic time, position jump, speed spike).

• Formula: valid samples / all samples (session) or inside the lap (lap)
• Algorithm: validate-gps-1.0.0
• API: GET /sessions/{sid}/quality → gps.valid_fraction; laps[].gps_valid_fraction
• Confidence / quality: Session blocked below gps_valid_fraction_min (0.8); lap invalid below lap_gps_valid_fraction_min (0.9).

proj_confidence — Projection confidence

Per sample: how close the GPS point is to the centerline and to its predicted progress; per lap: the mean.

• Formula: c = clip(1 − |n|/proj_n_max_m) × clip(1 − |s − s_pred|/window)
• Algorithm: lap-detect-1.0.0+laps-1.0.0+centerline-1.0.0+projection-1.0.0
• API: GET /sessions/{sid}/laps → laps[].proj_confidence_mean, proj_lost_count; profile → proj_confidence
• Confidence / quality: A lap mean below 0.9 raises a data-quality warning (plan §19.2); grid points below delta_low_confidence (0.5) are low-confidence in the delta.

body_yaw_lateral — Body-yaw lateral (gyro)

Speed times the body yaw rate (corrected for lean). On dirt this leads Cornering G at corner entry because the car runs at a slip angle; the difference is the slip-angle rate.

• Formula: a_lat_gyro = v_analysis × r_V / cos(λ̂), λ̂ = low-passed lean estimate (0.5 Hz)
• Algorithm: imu-1.0.0+mount-1.0.0
• API: GET /sessions/{sid}/profile/{lap} → imu.a_lat_gyro
• Display conversion: g = m/s² / 9.80665
• Confidence / quality: Net rotation per lap ∫r dt agrees with ∫ψ̇_gps dt within 5 % on stable laps; instantaneous RMS vs Cornering G is 0.47–0.74 g on dirt (slip), so it is a corroboration of the lap's rotation, not a point-by-point check.

lean_est — Lean estimate

Bank plus body roll relative to the parked attitude, from the steady-turn inverse. Positive = leaning into a left turn.

• Formula: λ_est = atan2(f_body_z, f_body_y) − atan2(g₀, a_lat_path); undefined below 8 m/s
• Algorithm: imu-1.0.0+mount-1.0.0
• API: GET /sessions/{sid}/profile/{lap} → imu.lean_est; segments → lean_angle_mean_deg; imu → corners[].lean_mean_deg
• Limitation: Exact only for a steady planar turn; transient roll and suspension motion add 6–9° per-sample scatter (lap means are stable to < 1°).

mount_confidence — Mount calibration confidence

The weakest of: stationary evidence (1.0 with ≥ 30 s stationary, else 0.6), lateral-axis correlation (1.0 / 0.7 / 0.4 by corr_lat ≥ 0.8 / ≥ 0.6 / below) and handedness (1.0 pass, 0.3 fail, 0.7 untestable). Manual overrides are fixed at 0.75.

• Formula: confidence = min(conf_stat, conf_corr, conf_hand); method = auto if ≥ 0.8 else auto_low_confidence
• Algorithm: imu-1.0.0+mount-1.0.0
• API: GET /sessions/{sid}/mount-calibration → confidence, method, priority
• Confidence / quality: Priority 1: auto ≥ 0.8. Priority 2: auto 0.5–0.8 (warning). Priority 3: manual. Priority 4: hidden vehicle-frame channels.

gps_lag — GPS lag

How far the GPS-derived channels trail the IMU clock. Applied before any IMU comparison and used in the video-sync model.

• Formula: lag = argmax of the cross-correlation over ±2.5 s in 0.05 s steps
• Algorithm: imu-1.0.0+mount-1.0.0
• API: GET /sessions/{sid}/mount-calibration → gps_lag_s
• Limitation: Measured −0.15 s (HERO11) to −0.40 s (HERO9) on the fixtures.

sync_offset — Video sync offset δ

Per-chapter offset between the video clock and the telemetry clock: t_video = t_session − t_chapter_start + δ. Default 0; measured per camera by matching visible bumps with the vertical accelerometer.

• Formula: t_video = t_session − t_chapter_start + δ_k
• Algorithm: normalize-1.0.0
• API: GET /sessions/{sid}/video-url → sync_offset_s, t_chapter_start_s
• Confidence / quality: Measured median δ: +0.05 s (HERO11, spread 0.33 s), +0.85 s (HERO9, spread 1.3 s, GPS time buffered by the camera). The default of 0 is labelled 'unverified' in the interface.