# Case 2: HMMWV goal reaching, test randomization versus nominal ROM (Sim2Sim)

This folder reproduces Case 2 of the paper *Screening Ground Vehicle Controllers via Test Randomization: Sim2Real
and Sim2Sim Studies*. PPO goal-reaching policies are trained on a reduced-order model (ROM) of the HMMWV. They
are evaluated in the ROM (nominal and test-randomized, TR) and in a high-fidelity Chrono HMMWV model. The ROM
policy orders are compared with the Chrono order. All results are Sim2Sim; Case 2 has no physical data.

The folder contains the training script and commands, the 24 trained policies, the four checkpoints of the
secondary pool, the ROM and Chrono evaluation code, the test conditions, goal sets A and B, every per-episode
ROM and Chrono record, and the analysis scripts with their outputs.

## Quick start: paper numbers from the released records (under 2 min)

```bash
pip install -r requirements.txt
python analyze.py --set A --pool explore
python report_explore.py
python analyze_confirm.py --set B --rom-dir results/rom_B_confirm16 --chrono-dir results/chrono_B_confirm16 \
    --primary confirm --secondary confirm16 --out results/confirm_analysis.json
python behavior_stats.py B confirm16
python posthoc_confirm.py
python report_confirm.py
python paper_numbers.py          # prints every Case 2 number of the paper; writes results/paper_numbers.json
```

Run all commands from this folder. These steps read only the released records (`results/rom_*`,
`results/chrono_*`) and the policies, and overwrite the released analysis outputs with identical files.

## Contents

```
README_case2.md, requirements.txt
common.py             paths, goal sets A/B, policy registry, actor (SB3 PPO weights, clipped), observation
train_ppo.py          PPO training on the ROM (environment, reward and hyperparameters of the original training script)
train_all.sh          exact training commands of the 24 policies
register_policies.py  writes policies/registry.json (config, seed, SHA-256 of the 2 M-step checkpoint)
rom_batch.py          batched ROM (original GoalEnv.step) with perturbation parameters
variants.py           all exploration conditions on goal set A (nominal + 35 test conditions)
fixed_design.py       fixed TR design for the held-out evaluation on goal set B (primary TR = tr_rate)
run_rom.py            ROM evaluation of a policy pool on a goal set
make_chrono_jobs.py   Chrono job list (policy x goal)
chrono_runner.py      Chrono HMMWV evaluation (copy of the original evaluation loop)
merge_chrono_parts.py merges Chrono output directories of a split run
rankstats.py          rank rule, win rates, Kendall tau-b, goal bootstrap
analyze.py, report_explore.py                      exploration analysis (goal set A)
analyze_confirm.py                                 held-out analysis (goal set B), primary test and secondary outcomes
behavior_stats.py                                  throttle and steering behavior of each policy in nominal ROM
posthoc_confirm.py, report_confirm.py              post hoc summaries and held-out report
paper_numbers.py                                   collects the Case 2 numbers of the paper
verify_rom_parity.py                               optional: batched ROM versus the original training environment
policies/             24 trained policies, registry.json, released/ (4 checkpoints of the original repository)
results/              per-episode records and analysis outputs (see below)
```

## Environment

- Python 3.12.14, Linux x86_64. Pinned packages: `requirements.txt` (NumPy 2.5.2, SciPy 1.18.1, PyTorch 2.13.0,
  Stable-Baselines3 2.7.0, Gymnasium 1.2.2).
- PyChrono 10.0.0 for the Chrono stages only (conda package): `conda install -c projectchrono pychrono=10.0.0`.
- `verify_rom_parity.py` also needs `gym==0.26.2` and a checkout of the original repository (see below).
- All computation runs on the CPU. Runtimes below are for an AMD Ryzen 7 5800X (8 cores, 16 threads).

## Policies

| Pool name | Policies | Use |
|---|---|---|
| `explore` | `rel1`-`rel4` + 12 design policies (seeds 1001-1004) | exploration on goal set A (16 policies) |
| `confirm` | 12 held-out policies (seeds 2001-2004) | primary pool on goal set B |
| `confirm16` | `confirm` + `rel1`-`rel4` | secondary pool on goal set B (16 policies) |

Trained policies: `policies/<config>_s<seed>/ckpt_4.zip` (2 M steps), with `train_meta.json` (config values, seeds,
hyperparameters, wall time, package versions) and `episode_returns.npy` (training episode returns).
`policies/registry.json` lists config, seed and SHA-256 of each `ckpt_4.zip`. Intermediate checkpoints
(0.5, 1.0, 1.5 M steps) are not included; no result uses them.

| Config | Action noise sd (throttle, steering) | Powertrain sd (tau0, omega0) | Powertrain draw | Actuation delay |
|---|---|---|---|---|
| `nonoise` | 0 | 0, 0 (tau0 = 1000 N m, omega0 = 2600 rad/s) | fixed | 0 |
| `release` | 0.05 | 50, 100 | once per environment (default of the original script) | 0 |
| `robust` | 0.10 | 100, 200 | every episode | 0, 1 or 2 steps (0-0.2 s), every episode |

PPO (Stable-Baselines3): learning rate 3e-4, n_steps 1200, batch 64, 20 epochs, gamma 0.99, clip 0.2, policy and
value networks [64, 128, 128, 64] with ReLU, 2e6 steps. PPO seed = `--seed`, environment seed = `--seed` + 7.

Released checkpoints `rel1`-`rel4` = `policies/released/ppo_<k>.zip`: copies of
`2024/PathFollowingSim2real/hmmwv_goal_reach/data/rl_model/ppo_<k>.zip` of
<https://github.com/uwsbel/sbel-reproducibility>, four checkpoints of one training run at 0.5, 1.0, 1.5 and 2.0 M steps.
BSD-3-Clause; the license text is in `policies/released/LICENSE`.

| Policy | SHA-256 |
|---|---|
| `rel1` (ppo_1.zip) | `2d7e38353d82d64a95ca011f0eed550d75ea1c94a6239104277bba567b971972` |
| `rel2` (ppo_2.zip) | `98793edc940c271b886bb8583cabe5aa9e6daee5cb108a6f8c03617a3e096241` |
| `rel3` (ppo_3.zip) | `372440b4c691eca0b4916e431283f4fa720ea53d36af4d13016038ec6e779bc2` |
| `rel4` (ppo_4.zip) | `831e518be7321006289789a0b7c42c70acc349c298394775d126053a6171b2eb` |

## Goal sets

Uniform radius and uniform bearing around the start point (0, 0), `common.make_goal_set`:

| Set | Seed | Goals | Use | File |
|---|---|---|---|---|
| A | 2026110401 | 50 ID (10-20 m) + 50 OOD (20-40 m) | exploration (TR design) | `results/rom_A_explore/goals.json` |
| B | 2026110499 | 75 ID (10-20 m) + 75 OOD (20-40 m) | held-out evaluation | `results/rom_B_confirm16/goals.json` |

## Test conditions

`variants.py` (`EXPLORE`) lists every condition tried on goal set A: nominal ROM and 35 test conditions in 11
families. `fixed_design.py` lists the nine conditions of the held-out evaluation; it was fixed before any
goal-set-B run. Each condition is a set of per-trial parameter distributions and a number of trials per goal
(20 for random conditions, 1 for deterministic ones). All policies see the same parameter draws and noise
(common random numbers). The condition names seed the random streams (`run_rom.seed_of`); do not rename them.

| Paper | Condition name |
|---|---|
| Nominal ROM | `nominal` |
| Noise-only TR | `paper_tr` |
| TR, random steering rate | `tr_rate` (goal set B); same specification as `rate_rand_paper` (goal set A) |
| rate range halved / doubled / uniform rate | `tr_rate_half` / `tr_rate_double` / `tr_rate_uniform` |
| random delay, no rate | `tr_delay` |
| Fixed rate limit 0.1 | `det_rate_0.1` |
| Fixed ROM, HMMWV values | `det_calibrated` |
| Exploration: random steering-rate limit (0.82), random actuation delay (0.80) | `rate_rand_paper`, `delay_rand03` |

## Stages

| Stage | Command | Inputs | Outputs | Runtime |
|---|---|---|---|---|
| 1. Training (optional) | `./train_all.sh 10 policies_retrained` | - | `policies_retrained/<config>_s<seed>/` (ckpt_1-4.zip, train_meta.json, episode_returns.npy) | 39-56 min per run on one core; 24 runs |
| 2. Registry | `python register_policies.py` | `policies/*/train_meta.json`, `ckpt_4.zip` | `policies/registry.json` | < 1 s |
| 3. ROM, goal set A | `python run_rom.py --set A --pool explore --variants all` | policies, `variants.py` | `results/rom_A_explore/` | 4 min |
| 4. Chrono, goal set A | `python make_chrono_jobs.py A explore results/chrono_A_jobs.jsonl`<br>`python chrono_runner.py results/chrono_A_jobs.jsonl results/chrono_A_explore --workers 12` | policies, goal set A | `results/chrono_A_explore/` | 1600 episodes, about 1 h with 10-12 workers |
| 5. Exploration analysis | `python analyze.py --set A --pool explore`<br>`python report_explore.py` | stages 3, 4 | `results/analysis_A_explore.json`, `results/exploration_tau_table.json`, `results/exploration_report.md` | < 1 min |
| 6. ROM, goal set B | `python run_rom.py --set B --pool confirm16 --table fixed` | policies, `fixed_design.py` | `results/rom_B_confirm16/` | 1 min |
| 7. Chrono, goal set B | `python make_chrono_jobs.py B confirm16 results/chrono_B_jobs.jsonl`<br>`python chrono_runner.py results/chrono_B_jobs.jsonl results/chrono_B_confirm16 --workers 12` | policies, goal set B | `results/chrono_B_confirm16/` | 2400 episodes, about 1.3 h with 12 workers |
| 8. Held-out analysis | `python analyze_confirm.py --set B --rom-dir results/rom_B_confirm16 --chrono-dir results/chrono_B_confirm16 --primary confirm --secondary confirm16 --out results/confirm_analysis.json` | stages 6, 7 | `results/confirm_analysis.json` | < 1 min |
| 9. Steering behavior | `python behavior_stats.py B confirm16` | policies, goal set B (nominal ROM) | `results/behavior_B_confirm16.json` | < 10 s |
| 10. Post hoc summaries, report | `python posthoc_confirm.py`<br>`python report_confirm.py` | stages 8, 9 | `results/posthoc_confirm.json`, `results/heldout_report.md` | < 20 s |
| 11. Paper numbers | `python paper_numbers.py` | stages 5, 8-10 | `results/paper_numbers.json` | < 10 s |
| Optional: ROM parity | `python verify_rom_parity.py <checkout>/2024/PathFollowingSim2real/hmmwv_goal_reach` | released checkpoints, original training script | `results/rom_parity.json` | < 1 min |

Notes on re-running:

- `run_rom.py` overwrites `results/rom_<set>_<pool>/`. Add `--tag _rerun` to write `results/rom_<set>_<pool>_rerun/`
  instead and compare with the released records.
- `chrono_runner.py` resumes: it skips episodes that are already in `<out_dir>/episodes.jsonl`. Use a new output
  directory to re-run episodes. A job list can be split into parts and the part directories merged with
  `python merge_chrono_parts.py <out_dir> <part_dir> ...`. The Chrono episodes of both goal sets were run in parts
  and merged in this way; the runner is deterministic, so the split does not change any result.
- The analysis scripts read the directory names above (`rom_A_explore`, `chrono_A_explore`, `rom_B_confirm16`,
  `chrono_B_confirm16`).
- To retrain, `train_all.sh` writes to a new directory and does not touch `policies/`. To evaluate retrained
  policies, put their directories in `policies/` and run `register_policies.py`. Bitwise identical retraining
  on other hardware or software is not guaranteed; compare SHA-256 values with `policies/registry.json`.

## Paper item, script and output

`paper_numbers.py` collects all items below in `results/paper_numbers.json`. P = `pools.primary` (12 held-out
policies) and S = `pools.secondary` (16 policies) of `results/confirm_analysis.json`; PH = `pools.primary` of
`results/posthoc_confirm.json`.

| Paper item | Script | Output |
|---|---|---|
| Exploration: nominal ROM and the test conditions on goal set A, 1600 Chrono episodes | `variants.py`, `run_rom.py`, `chrono_runner.py` | `results/rom_A_explore/`, `results/chrono_A_explore/episodes.jsonl` |
| Exploration tau_b: noise-only TR 0.55 vs nominal 0.53; random steering-rate limit 0.82; random delay 0.80 | `analyze.py`, `report_explore.py` | `exploration_tau_table.json`: `all16.<paper_tr, nominal, rate_rand_paper, delay_rand03>.all`; `exploration_report.md` |
| Nominal ROM: every held-out policy 100 % success; Chrono 60-65 % ID, 67-97 % OOD | `analyze_confirm.py` | P`.conditions.nominal.rom.success_rate`, P`.chrono.success_rate` |
| Held-out table: tau_b [95 % CI], ID, OOD for all nine conditions | `analyze_confirm.py` | P`.conditions.<name>.vs_chrono.<all, id, ood>.kendall_tau_b`, `.all.kendall_ci95` |
| Held-out table: Same / reversed (of the 48 Chrono-resolved pairs) | `posthoc_confirm.py` | PH`.pair_resolution_vs_chrono.<name>` |
| Primary test: difference +0.52 [0.33, 0.73] | `analyze_confirm.py` | `primary_test` |
| Chrono resolves 48 of 66 pairs; TR 45 same / 3 reversed; nominal 26 / 14 / 8 unresolved | `analyze_confirm.py`, `posthoc_confirm.py` | P`.chrono.resolved_pairs`; PH`.pair_resolution_vs_chrono` |
| Bang-bang steering: 8 policies 0.25-0.93, others 0.03-0.07 per step | `behavior_stats.py` | `behavior_B_confirm16.json`: `<policy>.mean_abs_steer_change` |
| Steering change vs Chrono OOD success: Spearman -0.76, p = 0.004 | `posthoc_confirm.py` | PH`.chatter_vs_chrono_success.ood` |
| Two smoothest policies: Chrono 1st/2nd, nominal ROM 11th/6th, TR 2nd/1st | `analyze_confirm.py`, `behavior_stats.py` | P`.chrono.order`, P`.conditions.<nominal, tr_rate>.rom.order` |
| Random delay tau_b 0.70; rate range halved/doubled barely changes the result | `analyze_confirm.py` | P`.conditions.<tr_delay, tr_rate_half, tr_rate_double>.vs_chrono.all` |
| Calibrated ROM tau_b 0.82; TR minus calibrated -0.09 [-0.21, 0.15] | `analyze_confirm.py`, `posthoc_confirm.py` | P`.conditions.det_calibrated.vs_chrono.all`; PH`.delta_tau_primary_tr_minus.det_calibrated` |
| OOD tau_b 0.64 (TR) vs 0.15 (nominal) | `analyze_confirm.py` | P`.conditions.<tr_rate, nominal>.vs_chrono.ood.kendall_tau_b` |
| Every held-out policy succeeds on more than half of the goals in Chrono | `analyze_confirm.py` | P`.chrono.success_rate.all` |
| Chrono / nominal ROM time 1.3-1.5 (held-out), up to 3.5 (checkpoints) | `analyze_confirm.py` | P and S `.conditions.nominal.chrono_over_rom_time_ratio` |
| Checkpoints: Chrono success 49/87/97/95 % ID, 69/99/97/99 % OOD | `analyze_confirm.py` | S`.chrono.success_rate.<id, ood>.rel<k>` |
| Checkpoints: nominal ROM order 4, 3, 2, 1 as Chrono; TR reverses 4 vs 3 and 4 vs 2, leaves 2 vs 3 unresolved | `analyze_confirm.py` | S`.chrono.pairs`, S`.conditions.<nominal, tr_rate>.rom.pairs` (summary: `paper_numbers.json`: `checkpoints`) |
| 16-policy pool: tau_b 0.70 vs 0.55, difference +0.15 [-0.03, 0.25]; rate range halved 0.13, doubled 0.87 | `analyze_confirm.py` | S`.conditions.<tr_rate, nominal, tr_rate_half, tr_rate_double>.vs_chrono.all` |
| All 24 policies reach every goal in nominal ROM | `run_rom.py` | `results/rom_A_explore/nominal.npz`, `results/rom_B_confirm16/nominal.npz`: `success` |

`results/exploration_report.md` and `results/heldout_report.md` show the same results as readable tables
(all conditions, both pools, per-policy success, mean ranks and orders).

## Result records

| Path | Content |
|---|---|
| `results/rom_<set>_<pool>/<condition>.npz` | `policies` [P], `goal_ids` [G]; `success`, `time_s` (NaN if no success), `terminal_distance_m`, `min_distance_m` [P, G, K]; `param_<name>` [G, K]: sampled parameters of each trial |
| `results/rom_<set>_<pool>/<condition>.json` | condition specification, trials per goal, goal set, parameter and noise seeds, policy paths and SHA-256, wall time of the original run |
| `results/chrono_<set>_<pool>/episodes.jsonl` | one line per episode: `policy`, `goal_id`, goal `x`, `y`, `success`, `time_s` (null if no success), `terminal_distance_m`, `min_distance_m`, `max_speed_mps`, `mean_throttle`, `rows`, `finite`, `wall_s`, `status` |
| `results/chrono_<set>_<pool>/traj/<policy>.npz` | one float32 array per goal id, 10 Hz rows: time (s), x, y, yaw, speed, policy throttle, rate-limited steering command (the vehicle is braked with zero inputs while t <= 1 s; the last row of a success has NaN commands). No paper number uses these trajectories. |

Scoring: a ROM trial succeeds at the first step after which the distance to the goal is below 3 m; its time is
(step index + 1) x 0.1 s. A Chrono episode succeeds when the distance is below 3 m at a control step; its time is
that control-step time, rounded to 0.1 s in the analysis. Failures score the 40 s horizon.

## Verification of this package

In a fresh copy of this folder (Python 3.12.14, PyTorch 2.13.0, PyChrono 10.0.0):

- The analysis stages 5 and 8-11 reproduce every released analysis output byte for byte from the released records.
- A full ROM re-evaluation (all 36 goal-set-A conditions incl. nominal and all 9 goal-set-B conditions, `--tag _rerun`)
  reproduces every array of the released ROM records exactly.
- 48 Chrono episodes (first goal of set A and first two goals of set B, all 16 policies each) re-run with
  identical summaries and identical 10 Hz trajectories.
- `verify_rom_parity.py`: 0 first-entry mismatches between the batched ROM and the original training environment
  for the 4 released checkpoints on 64 seeded goals.
- `register_policies.py` regenerates `policies/registry.json` byte for byte; every SHA-256 in the registry and in
  the ROM manifests matches the released checkpoint files.

## Provenance

`train_ppo.py` and `rom_batch.py` copy the environment, dynamics, reward and PPO hyperparameters of
`rl_script/rl_train_goal_reach.py`, and `chrono_runner.py` mirrors `simulation/sim_testing.py` of the original
`hmmwv_goal_reach` repository (changes are listed in the docstring of each file).