code/case1/runner/schemas/log_schema.md

Episode output schema (tr-c1-episode/1)

Each completed episode is a directory OUT/episodes/<episode_id>/ that appears atomically (written as .tmp_<id>_<pid> and renamed). Infrastructure failures go to OUT/infrastructure_errors/<episode_id>_<ms>/ instead and are retried by the next campaign.py invocation. Files:

File	Content
episode_config.json	normalized config (defaults filled); its SHA256 over canonical JSON is config_hash
ticks.csv.gz	one row per 10 Hz controller tick
state100.csv.gz	100 Hz true-state log (every 10 physics steps, from step 0)
summary.json	outcome, metrics, wall-time split, file hashes
server_stderr.txt	physics-server stderr
mpc_diag.csv.gz	only for the released MPC and MPC-based plug-ins: one row per OSQP solve, see below
obs_noise.csv.gz	only when observation noise is on: one row per tick that observed a state

CSV: gzip (mtime 0, deterministic bytes), header row, floats written with Python repr (exact round trip), empty field = not applicable. Units: m, rad, s, m/s. Angles CCW positive; yaw from the released formula atan2(2(e0 e3 + e1 e2), e0^2 + e1^2 - e2^2 - e3^2) on the Chrono chassis quaternion (e0 = w). Position = chassis COG (what ChROSBodyHandler publishes).

ticks.csv.gz

Column	Meaning
tick, step, t, t_ctrl	tick index; physics boundary (steps completed); ChSystem time; t - control_start_s
status	ok, no_state (released pub_callback returned before the first pose, ros_emulated start-up), controller_dead (after a controller failure), controller_solver_failure, controller_exception, controller_nonfinite_output
obs_pub_step, obs_age_steps	boundary of the state the controller saw (ideal: = step) and its age
x y z yaw yaw_unwrapped speed vx vy yaw_rate	TRUE chassis state at the tick boundary (yaw_unwrapped over ticks; speed = planar norm of COG velocity; yaw_rate = world-z angular rate)
obs_x obs_y obs_theta obs_v	what the released node stored (state_callback/vel_callback; includes observation noise) - these are the released logger's x, y, theta
e0..e3	controller input error_state(1.0) (1 m lookahead) captured from pub_callback
et0..et3	error_state(0.0) (= released e_tracking): et1 lateral, et2 heading error
idx_lookahead, idx_track, arc_s_track	nearest-waypoint indices of the two error states; arc length of idx_track
raw_throttle, raw_steering	controller law output before the rate limit (MPC steering already x1.6667)
rl_steering, rate_limited	self.steering after the 0.25/tick limiter; whether the limiter acted
published, pub_steering, pub_throttle, pub_braking	published DriverInputs (clipped)
apply_step, applied_*	boundary at which THIS tick's command reached driver->Set* and the stored driver values (after steering bias, ChDriver clamp); -1 = superseded before any driver tick (ros_emulated) or never applied
drv_steering, drv_throttle, drv_braking	driver inputs in effect at the tick boundary (before this tick's command)
compute_wall_s	wall time of pub_callback (excluded from determinism comparisons)

state100.csv.gz

step, t, x, y, z, yaw, yaw_unwrapped, speed, vx, vy, yaw_rate (true state), in_steering, in_throttle, in_braking (inputs used by the last physics step), e_long, e_lat, e_head, e_speed, nearest_idx, arc_s (released error_state(0.0) definitions evaluated on the true state, vectorised and checked against the released function), progress_idx (path_completion tracker), dist_min (distance to nearest waypoint, divergence rule).

summary.json (selected keys)

• status: ok | infrastructure_error. outcome (only when ok): horizon_reached, completed, timeout, diverged, controller_solver_failure, controller_exception, controller_nonfinite_output.
• failure: category, tick, step, t, traceback (controller failures and infrastructure errors).
• tube_entry_time_100hz_s: first 100 Hz sample (t relative to control start) with |e_lat| < tube_lat_m and |e_head| < tube_head_rad (true state); tube_entry_time_tick_s: same on published ticks (et1, et2); stay_in_tube_time_100hz_s, fraction_inside_tube_after_entry, tube_exits_after_entry; max_abs_lat_100hz_m, final_e_*.
• completion_step (path_completion), run_mae_lateral_m, run_mae_heading_rad, run_mae_samples: definitions of physical/physical_runs.py on published ticks' observed pose up to completion (or the last tick).
• wall: init_s (controller reset + server spawn/initialisation), stepping_s (physics round trips), controller_s (sum of pub_callback), other_s, total_s; physics_pure_step_wall_s (inside the server); server_spawn_to_ready_s.
• files: SHA256 of the two CSV files; config_hash; reference_sha256; mpc_osqp_adaptive_rho_interval used.

mpc_diag.csv.gz (READ-ONLY OSQP diagnostics)

One row per osqp.OSQP.solve() made during a controller tick (released MPC, plugin:wrapped_released with base mpc, plugin:mpc_n5). Recorded by a wrapper around osqp.OSQP.solve that returns the solver's results object unchanged; commands are bitwise identical with and without it.

Column	Meaning
tick, step, solve_index	controller tick, its boundary, index of the solve within the tick (always 0 for nsim = 1)
status, status_val, status_polish	OSQP res.info status text / code / polish status (solved = 1)
iter, rho_updates, rho_estimate	ADMM iterations, number of rho updates, final rho estimate
obj_val, pri_res, dua_res	objective, primal and dual residuals
setup_time, solve_time, update_time, polish_time, run_time	OSQP's own WALL-CLOCK timings in s (excluded from determinism comparisons)
adaptive_rho_interval_requested	value passed to setup (25 = the runner pin; empty = OSQP automatic, chosen from wall-clock time inside the solver and not readable safely through the osqp 0.6.5 Python API)
setup_max_iter, setup_warm_start	values the released code passed to setup (10000, true)
qp_n, qp_m	QP size from OSQP.dimensions() (N = 10: 64 x 108; N = 5: 34 x 58)
diag_error	empty unless reading the diagnostics failed (never changes an outcome)

Summary key mpc_osqp: n_solves, status_counts, n_not_solved, iter_total / mean / max, rho_updates_total, n_solves_with_rho_update, rho_estimate_min / max, adaptive_rho_interval_requested, qp_dims, n_diag_errors (all deterministic); wall.osqp_run_s = sum of run_time.

obs_noise.csv.gz

tick, step, obs_pub_step, z_x, z_y, z_yaw, noise_x, noise_y, noise_yaw: the standard normals of the observed publication (SeedSequence([7301, obs_noise.seed, obs_pub_step])) and the noise actually added (std x z; exactly 0 where std = 0). Summary key obs_noise_model names the model (null without noise).

Recovery summary fields

horizon_mean_abs_e_lat_m, horizon_mean_abs_e_head_rad (100 Hz true-state tracking error, every sample from control start t = 0 to the end of the log), horizon_mean_n_samples, horizon_mean_from_sim0_* (from sim time 0), horizon_mean_covers_horizon; by_H = {"15", "25", "40"} (windows 0 <= t <= H inside the horizon): abs_e_lat_m, abs_e_head_rad, n_samples, covered, tube_entry_s, tube_exits_after_entry; divergence_events (offline replay of the online rule: start_step, fire_step, end_step), n_divergence_events, divergence_flag, diverged_then_recovered, first_tube_entry_after_divergence_s, entered_then_diverged, returned_within_divergence_dist, divergence_offline_matches_online; controller_params_effective (plug-ins: parameters with defaults filled in). With termination.stop_on_divergence = false the episode always runs to horizon_s; the online outcome is still diverged once the rule fires. The post-entry exit count is tube_exits_after_entry.

Run level

OUT/summary.jsonl (append-only, one flattened row per finished episode per invocation), OUT/summary.csv (rebuilt from all summary.json, sorted by episode_id), OUT/manifest_<run_id>.json (input hashes, environment, config hashes, counts, per-episode wall times).