| # 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). |
|
|
