| """Chrono HMMWV evaluation = high-fidelity truth for Case 2 (Sim2Sim). Copy of the release loop. |
| |
| Mirrors hmmwv_goal_reach/simulation/sim_testing.py: HMMWV_Full, NSC contact, SHAFTS engine, automatic shafts |
| transmission, AWD, TMEASY tires, Bullet collision, 500 m x 500 m rigid patch, start at (0,0,0.9) with yaw 0, |
| 1 ms step, 10 Hz policy, brake hold while t <= 1 s, normalized steering change limited to 0.1 per control step, |
| success when the distance to the goal is < 3 m at a control step. Horizon 40 s (as in the ROM tests). |
| Changes: no visualization, no CSV append (in-memory log), PyChrono 10 data-path call, actor = common.Actor. |
| |
| Usage: python chrono_runner.py jobs.jsonl out_dir --workers 10 |
| (Resumes: episodes already in out_dir/episodes.jsonl are skipped. Use a new out_dir to re-run.) |
| jobs.jsonl lines: {"policy": name, "policy_path": path, "goal_id": id, "x": gx, "y": gy} |
| Output: out_dir/episodes.jsonl (one summary per episode), out_dir/traj/<policy>.npz (10 Hz trajectories). |
| """ |
| import argparse |
| import json |
| import math |
| import multiprocessing as mp |
| import os |
| import time |
| from pathlib import Path |
|
|
| import numpy as np |
|
|
| HORIZON = 40.0 |
| _ACTORS = {} |
|
|
|
|
| def _setup(): |
| import pychrono.core as chrono |
| import pychrono.vehicle as veh |
| import torch |
| torch.set_num_threads(1) |
| chrono.SetChronoDataPath(chrono.GetChronoDataPath()) |
| veh.SetVehicleDataPath(chrono.GetChronoDataPath() + 'vehicle/') |
| return chrono, veh |
|
|
|
|
| def run_episode(job, horizon=HORIZON): |
| from common import Actor, relative_obs |
| chrono, veh = _setup() |
| if job['policy_path'] not in _ACTORS: |
| _ACTORS[job['policy_path']] = Actor(job['policy_path']) |
| actor = _ACTORS[job['policy_path']] |
| goal_x, goal_y = float(job['x']), float(job['y']) |
| t_wall = time.time() |
| contact_material = chrono.ChContactMaterialNSC() |
| hmmwv = veh.HMMWV_Full() |
| hmmwv.SetContactMethod(chrono.ChContactMethod_NSC) |
| hmmwv.SetInitPosition(chrono.ChCoordsysd(chrono.ChVector3d(0.0, 0, 0.9), chrono.QuatFromAngleZ(0))) |
| hmmwv.SetEngineType(veh.EngineModelType_SHAFTS) |
| hmmwv.SetTransmissionType(veh.TransmissionModelType_AUTOMATIC_SHAFTS) |
| hmmwv.SetDriveType(veh.DrivelineTypeWV_AWD) |
| hmmwv.SetTireType(veh.TireModelType_TMEASY) |
| hmmwv.Initialize() |
| for f in ('SetChassisVisualizationType', 'SetSuspensionVisualizationType', 'SetSteeringVisualizationType', |
| 'SetWheelVisualizationType', 'SetTireVisualizationType'): |
| getattr(hmmwv, f)(chrono.VisualizationType_PRIMITIVES) |
| hmmwv.GetSystem().SetCollisionSystemType(chrono.ChCollisionSystem.Type_BULLET) |
| system = hmmwv.GetSystem() |
| terrain = veh.RigidTerrain(system) |
| terrain.AddPatch(contact_material, chrono.ChCoordsysd(chrono.ChVector3d(0, 0, 0), chrono.QUNIT), 500.0, 500.0) |
| terrain.Initialize() |
| goal_body = chrono.ChBodyEasyCylinder(chrono.ChAxis_Z, 0.75, 0.125, 40, True, False, contact_material) |
| goal_body.SetPos(chrono.ChVector3d(goal_x, goal_y, 0.1)) |
| goal_body.SetFixed(True) |
| system.Add(goal_body) |
| driver = veh.ChDriver(hmmwv.GetVehicle()) |
| driver.Initialize() |
| step_size = 1e-3 |
| control_step = math.ceil(0.1 / step_size) |
| prev_steering, step_number, t = 0.0, 0, 0.0 |
| log, reached, hit_time = [], False, None |
| vehicle = hmmwv.GetVehicle() |
| while t < horizon: |
| t = system.GetChTime() |
| if step_number % control_step == 0: |
| vx, vy = vehicle.GetPos().x, vehicle.GetPos().y |
| yaw = vehicle.GetRot().GetCardanAnglesXYZ().z |
| v = vehicle.GetSpeed() |
| dist = math.sqrt((vx - goal_x) ** 2 + (vy - goal_y) ** 2) |
| row = [t, vx, vy, yaw, v, np.nan, np.nan] |
| if dist < 3.0: |
| log.append(row) |
| reached, hit_time = True, t |
| break |
| obs = relative_obs(vx, vy, yaw, v, goal_x, goal_y) |
| throttle, steering = (float(u) for u in actor(obs[None])[0]) |
| delta = steering - prev_steering |
| prev_steering = prev_steering + 0.1 * delta / abs(delta) if abs(delta) > 0.1 else steering |
| if t > 1.0: |
| driver.SetSteering(prev_steering); driver.SetThrottle(throttle); driver.SetBraking(0.0) |
| else: |
| driver.SetSteering(0.0); driver.SetThrottle(0.0); driver.SetBraking(1.0) |
| row[5], row[6] = throttle, prev_steering |
| log.append(row) |
| inputs = driver.GetInputs() |
| driver.Synchronize(t); terrain.Synchronize(t); hmmwv.Synchronize(t, inputs, terrain) |
| driver.Advance(step_size); terrain.Advance(step_size); hmmwv.Advance(step_size) |
| step_number += 1 |
| log = np.array(log, dtype=np.float64) |
| d = np.hypot(log[:, 1] - goal_x, log[:, 2] - goal_y) |
| summary = dict(policy=job['policy'], goal_id=job['goal_id'], x=goal_x, y=goal_y, success=reached, |
| time_s=hit_time, terminal_distance_m=float(d[-1]), min_distance_m=float(d.min()), |
| max_speed_mps=float(log[:, 4].max()), mean_throttle=float(np.nanmean(log[:, 5])) if len(log) > 1 else None, |
| rows=len(log), finite=bool(np.isfinite(log[:, :5]).all()), wall_s=time.time() - t_wall) |
| return summary, log.astype(np.float32) |
|
|
|
|
| def _work(job): |
| try: |
| s, log = run_episode(job) |
| return s, log |
| except Exception as e: |
| import traceback |
| return dict(policy=job['policy'], goal_id=job['goal_id'], status='runtime_error', error=traceback.format_exc()), None |
|
|
|
|
| def main(): |
| p = argparse.ArgumentParser() |
| p.add_argument('jobs') |
| p.add_argument('out') |
| p.add_argument('--workers', type=int, default=10) |
| a = p.parse_args() |
| out = Path(a.out) |
| (out / 'traj').mkdir(parents=True, exist_ok=True) |
| jobs = [json.loads(l) for l in open(a.jobs)] |
| done_path = out / 'episodes.jsonl' |
| done = set() |
| if done_path.exists(): |
| for l in open(done_path): |
| r = json.loads(l) |
| if r.get('status') != 'runtime_error': |
| done.add((r['policy'], r['goal_id'])) |
| todo = [j for j in jobs if (j['policy'], j['goal_id']) not in done] |
| print(f'{len(jobs)} jobs, {len(done)} done, {len(todo)} to run', flush=True) |
| trajs = {} |
| t0 = time.time() |
| os.environ.setdefault('OMP_NUM_THREADS', '1') |
| with mp.get_context('spawn').Pool(a.workers, maxtasksperchild=50) as pool, open(done_path, 'a') as f: |
| for i, (s, log) in enumerate(pool.imap_unordered(_work, todo, chunksize=1)): |
| s.setdefault('status', 'ok') |
| f.write(json.dumps(s) + '\n'); f.flush() |
| if log is not None: |
| trajs.setdefault(s['policy'], {})[s['goal_id']] = log |
| if (i + 1) % 50 == 0 or i + 1 == len(todo): |
| print(f'{i + 1}/{len(todo)} elapsed {time.time() - t0:.0f}s', flush=True) |
| if (i + 1) % 200 == 0: |
| flush_traj(out, trajs) |
| trajs = {} |
| flush_traj(out, trajs) |
|
|
|
|
| def flush_traj(out, trajs): |
| for pol, d in trajs.items(): |
| path = out / 'traj' / f'{pol}.npz' |
| old = dict(np.load(path)) if path.exists() else {} |
| old.update(d) |
| np.savez_compressed(path, **old) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
