| # Case 1 (ART scale vehicle): reproduction package |
|
|
| This folder reproduces the Case 1 results of the paper: the recovery tests (test randomization, TR) of four |
| controllers (MPC, NN-MPC, PID, NN-HD) in the Chrono digital twin of the 1/6-scale ART vehicle, and their comparison |
| with 60 physical runs (Sim2Real). |
|
|
| | Stage | Folder | What it does | Needs the 20 GB logs? | |
| |---|---|---|---| |
| | 0 | `runner/` | Lock-step simulation runner and the batch (episode-list) generator | runs only in the Docker image | |
| | 1 | `extract/` | Simulation logs -> one row of metrics per episode (`data/per_start/`) | yes | |
| | 2 | `physical/` | Physical and nominal-simulation logs -> per-run MAE, Tables II-III | no (14 MB, GitHub) | |
| | 3 | `analysis/` | Baseline orders; Tables I, IV, V, sensitivity, pair tests, Hoeffding | no | |
| | 4 | `mpc_failures/` | MPC failures from large heading errors | stage 4a only | |
|
|
| `data/` holds the small intermediate files, so stages 3 and 4b run in seconds without the raw logs. |
| `results/` holds the outputs that these commands produce. |
|
|
| ## Environment |
|
|
| - Python 3.12.14 with `numpy==2.5.2` and `matplotlib==3.11.1` (`requirements.txt`; matplotlib only for the |
| figure of stage 4). Stages 1-4 are plain scripts; all inputs and outputs are given as arguments. |
| - The runner (stage 0) runs inside the Docker image `uwsbel/ros:iros2024` |
| (`uwsbel/ros@sha256:60118a64d8e751c1adafef1abebebbc504a5814d63eae5bb46120de5f7b4554c`, image Id |
| `sha256:73882e33184a5e9a586b5ce5167731ce0c569337104b273b05709a607730fa29`; controller commit `af8585558aab`, |
| Chrono fork commit `9d26ff7`). The released batches were run with 12 workers on one AMD Ryzen 7 5800X host. |
|
|
| ```bash |
| python3.12 -m venv .venv && .venv/bin/pip install -r requirements.txt |
| PY=.venv/bin/python # all commands below are run from this folder (code/case1) |
| ``` |
|
|
| ## Inputs |
|
|
| - Simulation logs: `simulation_logs/case1_<batch>.tar.gz` of this dataset (layout |
| `<batch>/episodes/<episode_id>/{episode_config.json, summary.json, ticks.csv.gz, state100.csv.gz, ...}`). |
| The paper uses B01, B03, B04, B05, B06 and B07. Unpack them so that the batch folders sit under `logs/runs/`: |
| `mkdir -p logs/runs && tar xzf case1_B01_main_tr.tar.gz -C logs/runs` (and the same for the other five). |
| - Physical runs and nominal-simulation logs: folder `2024/PathFollowingSim2real/TestingData` of |
| https://github.com/uwsbel/sbel-reproducibility (commit `1a098f37b6cdc69643bed9d9bf223ee2268e9fbc`): |
| `rd_path` (Path 1), `syn_path` (Path 2), `lot17` (Path 3); five runs per controller and path, and one nominal |
| simulation `sim_<controller>.csv` per path. The SHA256 of every physical log is in `data/physical_runs.csv` |
| (`log_sha256`). |
| - Reference waypoints of the Docker image (`/sbel/Desktop/waypoints_paths`): `data/waypoints/`. |
|
|
| ## Stage 0: runner and batch definitions (`runner/`) |
|
|
| Not runnable without the Docker image; the released logs are the output of this code. |
|
|
| - `src/art_lockstep.cpp`: lock-step physics server. Vehicle and terrain setup are copied from the released |
| `demo_ROS_dART.cpp` and linked against the Chrono libraries of the image. `build.sh` builds it inside the image |
| (`build/art_lockstep`). |
| - `art_runner/`: episode loop with the ros_emulated latency schedule (25 Hz state publication, 10 Hz controller and |
| driver handlers, per-controller compute delay), bridge that runs the released controller code |
| (`path_follower.py`, `mpc_wpts.py`, NN checkpoints) unchanged with stubbed rclpy executors, plug-ins (the NN-HD |
| variants use `plugin:wrapped_released` with a steering scale), metrics and logging. Log columns: |
| `schemas/log_schema.md`; config fields: `schemas/episode_config.schema.json`. |
| - `campaign.py` + `run_campaign.sh`: batch driver (supervised worker pool, resume, provenance digest) and its |
| network-isolated container launcher: `bash runner/run_campaign.sh EPISODES.json OUTDIR 12`. |
| - `default_config.json` + `default_episode.py`: runner defaults and episode builders. |
| - `batches/generate_lists.py`: builds the episode lists of B01, B03-B07 (seeds, scenario tables, CRN mapping; |
| see its docstring). `python3 runner/batches/generate_lists.py --out-root lists` writes |
| `lists/<batch>/episodes.json`, the scenario tables and `generation_meta.json` (about 2 s; numpy only). |
| `batches/steering_bias.json` holds the steering-bias levels of D2a/D2b (0.013, 0.026). |
|
|
| Why the omitted modules of the original demo do not change the dynamics: the sensor manager (GPU camera, lidar), |
| the ROS manager and its read-only handlers, the soft-real-time busy wait and the visual assets (waypoint boxes |
| without collision) read the state but write no force or state; the only writer is the driver-inputs handler, which |
| the runner reproduces. As a check, the original binary driven by an open-loop ROS publisher produced 263 pose messages |
| that are bitwise identical to the server's states. |
|
|
| Batches used by the paper (episode counts as in the archives; V6 = MPC, NN-MPC, PID and NN-HD with |
| `ctrl_label` nnhdx175, nnhdx150, nnhdx100; V5 = V6 without nnhdx100): |
|
|
| | Batch | Content | Episodes | |
| |---|---|---| |
| | B01 | S2 recovery tests, 400 starts x V6, logged 40 s, scored at H = 15/25/40 s | 2,400 | |
| | B03 | Nominal simulation on Paths 1-3 x V6, controller phase {0, 20, 40, 60, 80} ms (phase 0 = `nominal_role` primary) | 90 | |
| | B04 | Monte Carlo (RF-A): start jitter dx, dy in [-0.2, 0.2] m, dyaw in [-0.067, 0.067] rad, random phase; 20 runs per path x V5 | 300 | |
| | B05 | RF-B: B04 runs plus D5 (delay 0.10 s, steering bias 0.013, pose noise 0.02 m / 0.01 rad) | 300 | |
| | B06 | Offset ranges S0, S1, S3, S4 (+ lateral-only, heading-only, Beta(3,3) shape), 200 starts each x V5, 25 s | 9,000 | |
| | B07 | Channel conditions D1a-D5 on the first 200 S2 starts x V5, 25 s | 9,000 | |
|
|
| The other archives (B02, B04w, B08-B13) are not used for the paper's results; their list generator is not included. |
|
|
| Note on `default_config.json`: the released episode configurations carry `tags.default_config_sha256 = |
| c63a5bab...f980`, the hash of the original version of this file. The copy here has the same values for every field |
| that the builders read and shorter descriptive text, so lists generated with it carry a different |
| `default_config_sha256`. Any change to the runner files also changes the runner code digest in `summary.json`. |
|
|
| ## Stage 1: extract per-episode metrics (`extract/extract_metrics.py`) |
| |
| ```bash |
| for b in B01_main_tr B03_nominal B04_rf_a B05_rf_b B06_severity_shape B07_dist_recovery; do |
| $PY extract/extract_metrics.py --out data/per_start --batch $b --workers 14 --run-label-root logs logs/runs/$b |
| done |
| $PY extract/extract_metrics.py --selftest |
| ``` |
| |
| - Inputs: unpacked batch folders; `data/waypoints/` (default waypoint directory). |
| - Outputs: `data/per_start/<batch>/recovery_part*.csv.gz` (B01, B06, B07) and `fullpath_part*.csv.gz` (B03-B05), |
| one row per episode, plus `MANIFEST.json` and, if an episode cannot be read, `errors_part*.jsonl`. Column |
| definitions are in the module docstring. The rank analysis uses `T25_trk100_L010H010_first` (bounded first entry |
| into the 0.10 m / 0.10 rad tube, H = 25 s) and the other tube and horizon columns for the sensitivity; the |
| baselines use `mae_lat_m`, `mae_head_rad`. |
| - Runtime (14 workers): B01 71 s, B06 163 s, B07 157 s, B03-B05 3-10 s each. Unpacking the six archives needs |
| about 10 GB of disk. |
| - `data/per_start/` in this package was produced by exactly these commands from the released archives |
| (`MANIFEST.json` files are not included). Rows are written in shards of 2000 as the workers finish, so a rerun |
| can put a row into a different shard; the set of rows and every value are the same. |
|
|
| ## Stage 2: physical runs and nominal simulations (`physical/physical_runs.py`) |
| |
| ```bash |
| $PY physical/physical_runs.py <sbel-reproducibility>/2024/PathFollowingSim2real/TestingData data/waypoints results |
| cp results/physical_runs.csv results/nominal_sim_runs.csv data/ |
| ``` |
| |
| - Outputs: `physical_runs.csv` (60 runs: run MAEs and start quantities), `nominal_sim_runs.csv` (12 nominal runs), |
| `tables_II_III.json` / `.tex` (mean and SD of the five run MAEs, nominal-simulation MAE), |
| `physical_pair_bootstrap.json` (run-bootstrap interval of each pair difference), `physical_summary.json` |
| (start spread). In this package, the two CSV files are in `data/` and the other outputs in `results/`. |
| - Runtime: about 3 s. |
|
|
| ## Stage 3: analysis (`analysis/`) |
|
|
| ```bash |
| $PY analysis/baseline_orders.py data/per_start data/nominal_sim_runs.csv data/baseline_orders.json |
| $PY analysis/case1_rank_analysis.py data/per_start data/physical_runs.csv data/baseline_orders.json results \ |
| > results/case1_rank_analysis_console.txt |
| ``` |
|
|
| - `baseline_orders.py` (about 1 s): predicted order of each baseline per path and metric (ascending run MAE): |
| `M-NOM` (B03, phase 0), `NOM-archived-2024` (nominal simulations of Tables II-III), `RF-A` (B04, mean of 20 runs), |
| `RF-B` (B05). For the Chrono batches, the NN-HD column is `ctrl_label` nnhdx175 on Paths 1-2 and nnhdx150 on |
| Path 3. |
| - `case1_rank_analysis.py` (about 4 s): per-start ranks of the settling times (ties shared, failures = H), TR order |
| by ascending mean rank, Kendall tau against the six physical orders, 2000 bootstrap replicates (seed 20261105), |
| exact permutation tests (252 allocations) with Holm adjustment, sensitivity and ablation. Output: |
| `results/case1_rank_analysis.json`. The TR order of Path 1-2 targets uses the nnhdx175 column and that of Path 3 |
| targets the nnhdx150 column; the rank percentages of Table I use nnhdx175. |
|
|
| ## Stage 4: MPC failures (`mpc_failures/`) |
| |
| ```bash |
| $PY mpc_failures/first_tick.py logs/runs/B01_main_tr data/b01_mpc_first_tick.csv # 4a, needs B01 logs |
| $PY mpc_failures/d3_range.py data/per_start data/b01_mpc_first_tick.csv \ |
| results/mpc_failures.json results/mpc_failure_geometry.png # 4b |
| ``` |
| |
| - 4a (under 1 s on the unpacked B01): first controller tick of each of the 400 MPC episodes (`e0`, `et0`-`et2`). |
| - 4b (about 1 s): classifies the 400 MPC starts (divergence / no entry / reached the tube) and counts the starts |
| beyond the e_long = 0 boundary and beyond the ridge of the released MPC stage cost; writes a two-panel figure. |
| |
| ## Paper item -> script -> output |
| |
| | Paper item | Script | Output file : key | |
| |---|---|---| |
| | Table I (rank %, mean rank, failed %, mean ST, tau per offset range S0-S4) | `analysis/case1_rank_analysis.py` | `case1_rank_analysis.json` : `offset_sweep` (`rank_pct`, `mean_rank`, `fail_pct`, `n_all_recover`, `mean_st_all_recover`, `mean_tau_vs_physical`) | |
| | Text on Table I: S2 pairwise win rates 0.90-0.91, NN-MPC beats PID 0.75 [0.71, 0.80] | same | `offset_sweep[S2].pairwise_win_rate_ci95` | |
| | Tables II-III (mean +- SD of five run MAEs; nominal simulation) | `physical/physical_runs.py` | `tables_II_III.tex`, `tables_II_III.json` | |
| | Physical starts within 0.28 m, initial lateral error <= 0.24 m | same | `physical_summary.json` | |
| | Point orders of Tables II-III (physical orders) | `analysis/case1_rank_analysis.py` | `physical_order` | |
| | Table IV (tau per path and metric, mean tau [95 % CI], best selected, resolved pairs correct) | same (+ `analysis/baseline_orders.py`) | `method_comparison` (rows `TR (rank rule, S2)`, `Nominal simulation (2024 archive)` = nominal simulation of Tables II-III, `Monte Carlo, start jitter (RF-A)`, `Monte Carlo, jitter + disturbances (RF-B)`; row `Nominal simulation` = B03) | |
| | NN-MPC physical MAE 1.95-2.65 x MPC on Paths 1-2 | same | `method_comparison[...].selected_error_ratio_to_best` | |
| | TR minus nominal simulation +0.56, all 2000 replicates | same | `tr_minus_nominal_tables_II_III` | |
| | 32 of 36 pairs resolved; adjusted p = 0.294 and 0.056; TR orders 30/32 | same | `physical_pairwise_tests` (`p_perm`, `p_holm`), `method_comparison[TR...].resolved_pairs_correct` | |
| | Path 3 NN-MPC - PID lateral: 0.0249 m, [-0.0101, 0.0615] m | `physical/physical_runs.py` | `physical_pair_bootstrap.json` : `pairs.P3_lateral` | |
| | Sensitivity: horizons 15/25/40 s and nine tubes | `analysis/case1_rank_analysis.py` | `tube_horizon_sensitivity` | |
| | Number of starts: 94.2 % (10), 99.9 % (25), 100 % (>= 50) | same | `trial_number_sensitivity` | |
| | Hoeffding: smallest adjacent mean-rank gap 0.511 (n bound 350) | same | `hoeffding` | |
| | Hoeffding: epsilon_n = 0.239 for K = 4, n = 400, alpha = 0.05 | formula | `$PY -c "import math; print(3*math.sqrt(math.log(2*4/0.05)/(2*400)))"` -> 0.2389 | |
| | Table V (ablation by channel, D1a-D5) and "MPC fails from 8.5-10.5 %" | `analysis/case1_rank_analysis.py` | `ablation_by_channel` (`order`, `mpc_first_pct`, `mean_tau_vs_physical`, `fail_pct`) | |
| | MPC failures: 33/400 (29 divergences + 4 wheel-lock), boundary about 20-30 deg, 318 starts inside the boundary, none diverges | `mpc_failures/d3_range.py` | `mpc_failures.json` : `summary` (`div`, `noentry`, `all.beyond_ridge` = 82, `boundaries_deg_away`, `divergence_rate_inside`) | |
| |
| ## Verification of this package |
| |
| The package was run in a fresh copy and compared with the outputs that the paper was produced from: |
| |
| - `results/case1_rank_analysis.json`: every number equal (926 numeric leaves); only the free-text `label` differs. |
| - `data/physical_runs.csv`: all 60 rows equal in all 21 columns; nominal-simulation MAEs, Tables II-III and the 36 |
| pair-bootstrap intervals bit-identical. |
| - `data/baseline_orders.json`: orders and scores bit-identical for all four baselines and six targets. |
| - `data/per_start/`: extracted from the released archives; all 21,090 rows of the six batches equal in every metric |
| column. Differences are only in identity fields that the release changed: `tags_json` (`ctrl_desc` text, internal |
| tags removed), `config_hash` (recomputed for the released config) and `summary_sha256` (rewritten `summary.json`). |
| All rows have `chk_all = 1` (extractor values agree with the runner summaries). |
| - `runner/batches/generate_lists.py` regenerates all 21,090 released episode configurations of B01 and B03-B07 |
| exactly (after the runner's `config.normalize`), except `tags.default_config_sha256` (see Stage 0). |
| - `results/mpc_failures.json`: every number equal (2024 numeric leaves). |
|
|
| ## Notes |
|
|
| - The steering-bias level 0.013 of D2a enters as a constant (`runner/batches/steering_bias.json`); the script that |
| estimated it from the archived logs is not part of this package. |
| - The physical and nominal-simulation logs are not copied here; they are public in the GitHub repository above. |
|
|
