"""Lock-step episode loop, schedules, logging and outcome classification (NEW CODE). Timing semantics (all in integer 1 ms physics steps; "boundary n" = after n physics iterations, sim time n*1e-3 s): ideal controller tick j at boundary S_j = c0 + j*P (P = 100); observation = true chassis state at boundary S_j; command applied with driver->Set* at boundary S_j + d (d = extra actuation delay, default 0), i.e. it drives iterations S_j+d, S_j+d+1, ... ros_emulated (ChROSManager / ChROSHandler semantics of the image) ChROSHandler::Update accumulator (ChROSHandler.cpp:28-40) replicated with the same double arithmetic for the 25 Hz ChROSBodyHandler and the 10 Hz ChROSDriverInputsHandler. A handler tick in iteration k happens after the physics step of iteration k (demo_ROS_dART.cpp:332-348), i.e. at boundary k+1, with the post-step state. state publication (25 Hz) -> visible to the controller from boundary k+1+sd; controller tick j at boundary S_j = c0 + phase + j*P uses the latest visible publication (state_callback/vel_callback of the released node); its DriverInputs message arrives at boundary b_j = S_j + cd + d (compute delay cd, extra delay d) and overwrites the handler's stored inputs (ChROSDriverInputsHandler::Callback, keep-last); driver tick (10 Hz) in iteration k applies the stored inputs (messages with b <= k) via driver->SetSteering/SetThrottle/SetBraking (ChROSDriverInputsHandler::Tick); the vehicle uses them from iteration k+1 (GetInputs at the top of the loop, demo_ROS_dART.cpp:332). Within one boundary the order is: driver tick, state publication, 100 Hz log, controller tick (ideal: then delayed application). """ import gzip import io import json import math import os import shutil import time import traceback import numpy as np from . import config as cfgmod from .metrics import (SPIN_CRITERION, ProgressTracker, audit_errors, divergence_events, error_state_vec, first_tube_entry, nearest_index, spin_events) from .physics import DEFAULT_BINARY, PhysicsError, PhysicsServer from .references import build_reference from .released import (OSQP_INFO_FIELDS, ReleasedController, classify_controller_exception, load_released_module, make_messages, osqp_diag_take, set_osqp_adaptive_rho_interval, sha256_file) DT = cfgmod.DT COG_OFFSET_XY = (-0.1336, -0.0014) # ARTcar chassis COM in the chassis reference frame (state at step 0) TERRAIN_DEFAULT = '/sbel/Desktop/chrono/build/data/vehicle/terrain/RigidPlane.json' TERRAIN_DEFAULT_FRICTION = 0.9 # RigidPlane.json "Coefficient of Friction" TICK_COLUMNS = ['tick', 'step', 't', 't_ctrl', 'status', 'obs_pub_step', 'obs_age_steps', 'x', 'y', 'z', 'yaw', 'yaw_unwrapped', 'speed', 'vx', 'vy', 'yaw_rate', 'obs_x', 'obs_y', 'obs_theta', 'obs_v', 'e0', 'e1', 'e2', 'e3', 'et0', 'et1', 'et2', 'et3', 'idx_lookahead', 'idx_track', 'arc_s_track', 'raw_throttle', 'raw_steering', 'rl_steering', 'rate_limited', 'published', 'pub_steering', 'pub_throttle', 'pub_braking', 'apply_step', 'applied_steering', 'applied_throttle', 'applied_braking', 'drv_steering', 'drv_throttle', 'drv_braking', 'compute_wall_s'] STATE_COLUMNS = ['step', 't', 'x', 'y', 'z', 'yaw', 'yaw_unwrapped', 'speed', 'vx', 'vy', 'yaw_rate', 'in_steering', 'in_throttle', 'in_braking', 'e_long', 'e_lat', 'e_head', 'e_speed', 'nearest_idx', 'arc_s', 'progress_idx', 'dist_min'] WALL_COLUMNS = {'compute_wall_s'} # excluded from determinism comparisons # Side files, written only when they have rows: # mpc_diag.csv.gz one row per osqp.OSQP.solve() made during a controller tick (released MPC and # MPC-based plug-ins); read-only copy of res.info. Wall-clock columns: MPC_DIAG_WALL_COLUMNS. # obs_noise.csv.gz one row per controller tick that observed a state under observation noise. MPC_DIAG_COLUMNS = (['tick', 'step', 'solve_index'] + list(OSQP_INFO_FIELDS) + ['adaptive_rho_interval_requested', 'setup_max_iter', 'setup_warm_start', 'qp_n', 'qp_m', 'diag_error']) MPC_DIAG_WALL_COLUMNS = {'setup_time', 'solve_time', 'update_time', 'polish_time', 'run_time'} OBS_NOISE_COLUMNS = ['tick', 'step', 'obs_pub_step', 'z_x', 'z_y', 'z_yaw', 'noise_x', 'noise_y', 'noise_yaw'] SUMMARY_H_WINDOWS_S = (15.0, 25.0, 40.0) # H = 15 / 25 / 40 s scored offline from one 40 s log # Observation noise (channel conditions D3/D5). The noise of the state PUBLICATION at physics boundary k (ros_emulated: # a 25 Hz ChROSBodyHandler publication; ideal: the observation boundary = the tick boundary) is # z = numpy.random.default_rng(numpy.random.SeedSequence([7301, seed, k])).standard_normal(3) # (noise_x, noise_y, noise_yaw) = (std_x z[0], std_y z[1], std_yaw z[2]) (exactly 0.0 where std = 0) # All three components are always drawn, so (i) conditions that differ only in the std values see the same z # (common random numbers across noise levels), (ii) every controller of a scenario sees the same noise on the same # publication, and (iii) a publication observed by more than one tick carries the same noise. 7301 is a fixed # domain tag that separates this stream from every campaign scenario seed sequence ([20261019, ...]). OBS_NOISE_DOMAIN = 7301 OBS_NOISE_MODEL = 'per_publication_v2: SeedSequence([7301, obs_noise.seed, obs_pub_step]) -> standard_normal(3) x std' def obs_noise_standard_normals(seed, pub_step): return np.random.default_rng(np.random.SeedSequence([OBS_NOISE_DOMAIN, int(seed), int(pub_step)])).standard_normal(3) # --------------------------------------------------------------------------- def handler_tick_iterations(rate_hz, n_iters, step=DT): """Iterations k (0-based) in which ChROSHandler::Update calls Tick().""" frame_time = 0 if rate_hz == 0 else 1 / rate_hz acc = 0.0 out = [] for k in range(n_iters): acc += step if acc < frame_time: continue acc -= frame_time out.append(k) return out def yaw_released(e0, e1, e2, e3): """path_follower.py:123-127 with the ChROSBodyHandler field mapping.""" return np.arctan2(2 * (e0 * e3 + e1 * e2), e0 ** 2 + e1 ** 2 - e2 ** 2 - e3 ** 2) def yaw_rate_global(st): e0, e1, e2, e3 = st['q_e0'], st['q_e1'], st['q_e2'], st['q_e3'] r20 = 2 * (e1 * e3 - e0 * e2) r21 = 2 * (e2 * e3 + e0 * e1) r22 = e0 * e0 - e1 * e1 - e2 * e2 + e3 * e3 return r20 * st['wloc_x'] + r21 * st['wloc_y'] + r22 * st['wloc_z'] def _fmt(v): if v is None: return '' if isinstance(v, (bool, np.bool_)): return '1' if v else '0' if isinstance(v, (int, np.integer)): return str(int(v)) if isinstance(v, (float, np.floating)): return repr(float(v)) return str(v) def write_csv_gz(path, columns, rows): buf = io.StringIO() buf.write(','.join(columns) + '\n') for r in rows: buf.write(','.join(_fmt(r.get(c)) for c in columns) + '\n') with open(path, 'wb') as raw: with gzip.GzipFile(fileobj=raw, mode='wb', mtime=0, compresslevel=6) as gz: gz.write(buf.getvalue().encode()) def friction_terrain_json(mu, workdir): with open(TERRAIN_DEFAULT) as f: spec = json.load(f) spec['Patches'][0]['Contact Material']['Coefficient of Friction'] = float(mu) path = os.path.join(workdir, f'RigidPlane_mu_{float(mu)!r}.json') with open(path, 'w') as f: json.dump(spec, f, indent=2) return path # --------------------------------------------------------------------------- class ControllerPool: """Per-worker cache: released module and models loaded once; a FRESH ControlNode / plug-in state is constructed for every episode.""" def __init__(self): self.module = None self.released = {} def get(self, name, params): if self.module is None: self.module = load_released_module() if name in cfgmod.RELEASED: if name not in self.released: self.released[name] = ReleasedController(name, self.module) return self.released[name] from .plugins import PluginController, make_plugin return PluginController(make_plugin(name.split(':', 1)[1], params, self.module), self.module) def initial_chassis_pose(pose): x, y, yaw = pose['x'], pose['y'], pose['yaw'] if pose['frame'] == 'cog': c, s = math.cos(yaw), math.sin(yaw) ox, oy = COG_OFFSET_XY x, y = x - (c * ox - s * oy), y - (s * ox + c * oy) return x, y, yaw def run_episode(cfg, pool, workdir, binary=None, server_timeout_s=120.0): """Run one normalized episode config; write logs into workdir. Returns summary dict.""" t_wall0 = time.perf_counter() lat = cfg['latency'] pert = cfg['perturbation'] term = cfg['termination'] N = cfgmod.to_steps(cfg['horizon_s'], 'horizon_s') c0 = cfgmod.to_steps(cfg['control_start_s'], 'control_start_s') P = cfgmod.to_steps(lat['controller_period_s'], 'controller_period_s') d_act = cfgmod.to_steps(pert['actuation_delay_s'], 'actuation_delay_s') ros = lat['model'] == 'ros_emulated' if ros: phase = cfgmod.to_steps(lat['controller_phase_s'], 'controller_phase_s') cd = cfgmod.to_steps(lat['compute_delay_s'], 'compute_delay_s') sd = cfgmod.to_steps(lat['state_delay_s'], 'state_delay_s') else: phase = cd = sd = 0 tick_steps = list(range(c0 + phase, N, P)) tick_set = {s: j for j, s in enumerate(tick_steps)} log_set = set(range(0, N + 1, 10)) pub_set = {k + 1 for k in handler_tick_iterations(lat['state_rate_hz'], N)} if ros else set() drv_set = {k + 1 for k in handler_tick_iterations(lat['driver_rate_hz'], N)} if ros else set() apply_set = {s + d_act: j for j, s in enumerate(tick_steps)} if (not ros and d_act > 0) else {} events = sorted(log_set | set(tick_set) | pub_set | drv_set | {s for s in apply_set if s <= N}) ref = build_reference(cfg['reference']) R = ref.array noise = pert['obs_noise'] noisy = any(noise[k] > 0 for k in ('std_x', 'std_y', 'std_yaw')) bias = pert['steering_bias'] summary = {'episode_id': cfg['episode_id'], 'scenario_id': cfg['scenario_id'], 'controller': cfg['controller'], 'config_hash': cfgmod.config_hash(cfg), 'latency_model': lat['model'], 'reference_sha256': ref.sha256, 'reference_length_m': ref.length} tick_rows, state_rows = [], [] diag_rows, noise_rows = [], [] walls = {'init_s': 0.0, 'stepping_s': 0.0, 'controller_s': 0.0} server = None status, outcome, failure = 'ok', None, None t_init0 = time.perf_counter() try: controller = pool.get(cfg['controller'], cfg['controller_params']) set_osqp_adaptive_rho_interval(cfg['mpc_osqp_adaptive_rho_interval']) summary['mpc_osqp_adaptive_rho_interval'] = cfg['mpc_osqp_adaptive_rho_interval'] controller.reset(ref) if getattr(controller, 'kind', None) == 'plugin': summary['controller_params_effective'] = getattr(controller.plugin, 'p', None) terrain = None if pert['friction'] is not None: terrain = friction_terrain_json(pert['friction'], workdir) x0, y0, yaw0 = initial_chassis_pose(cfg['initial_pose']) boxes = None if cfg['replicate_waypoint_boxes']: if cfg['reference']['type'] != 'released_csv': raise cfgmod.ConfigError('replicate_waypoint_boxes requires a released_csv reference') boxes = list(ref.source_files)[0] server = PhysicsServer(x0, y0, yaw0, binary=binary or DEFAULT_BINARY, terrain_json=terrain, waypoint_boxes=boxes, replicate_vis=cfg['replicate_visual_setters'], timeout_s=server_timeout_s, stderr_path=os.path.join(workdir, 'server_stderr.txt')) walls['init_s'] = time.perf_counter() - t_init0 summary['server_spawn_to_ready_s'] = server.spawn_to_ready_s summary['server_internal_init_s'] = server.server_init_s summary['server_ready_line'] = server.ready_line st = server.state n = 0 tracker = ProgressTracker(R) if term['type'] == 'path_completion' else None pubs = [] # (avail_step, pub_step, state); avail_step is non-decreasing n_visible = 0 m_inputs = (0.0, 0.0, 0.0) # ChROSDriverInputsHandler m_inputs {0,0,0,0} pending = [] # ros: list of [b, (s,t,b), tick] ideal_cmd = {} controller_dead = False diverged_since = None completion_step = None stop_step = None hold_steps = cfgmod.to_steps(term['divergence_hold_s'], 'divergence_hold_s') margin_steps = cfgmod.to_steps(term['completion_margin_s'], 'completion_margin_s') yaw_prev, yaw_unwrapped = None, None tick_yaw_prev, tick_yaw_unw = None, None def apply(steer, thr, brk, at_step, tick_index): s_app, t_app, b_app = server.set_inputs(steer + bias, thr, brk) if tick_index is not None: r = tick_rows[tick_index] if r.get('apply_step') in (None, -1): r.update({'apply_step': at_step, 'applied_steering': s_app, 'applied_throttle': t_app, 'applied_braking': b_app}) return s_app, t_app, b_app for m in events: if stop_step is not None and m > stop_step: break if m > n: ts = time.perf_counter() st = server.step(m - n) walls['stepping_s'] += time.perf_counter() - ts n = m # 1) ros driver tick (iteration m-1) if m in drv_set: still = [] for item in pending: if item[0] <= m - 1: m_inputs = item[1] last_tick = item[2] else: still.append(item) delivered = len(still) != len(pending) pending = still # the tick re-applies the stored inputs every 100 ms (Tick() always calls Set*) cur_tick = last_tick if delivered else None apply(m_inputs[0], m_inputs[1], m_inputs[2], m, cur_tick) # 2) ros state publication (iteration m-1, post-step state) if m in pub_set: pubs.append((m + sd, m, st)) # 3) 100 Hz state log + termination rules if m in log_set: q = (st['q_e0'], st['q_e1'], st['q_e2'], st['q_e3']) yaw = float(yaw_released(*q)) yaw_unwrapped = yaw if yaw_prev is None else yaw_unwrapped + float(np.arctan2(np.sin(yaw - yaw_prev), np.cos(yaw - yaw_prev))) yaw_prev = yaw row = {'step': m, 't': st['time'], 'x': st['cog_x'], 'y': st['cog_y'], 'z': st['cog_z'], 'yaw': yaw, 'yaw_unwrapped': yaw_unwrapped, 'speed': math.sqrt(st['vel_x'] ** 2 + st['vel_y'] ** 2), 'vx': st['vel_x'], 'vy': st['vel_y'], 'yaw_rate': yaw_rate_global(st), 'in_steering': st['applied_steer'], 'in_throttle': st['applied_thr'], 'in_braking': st['applied_brake']} dmin = float(np.sqrt(((R[:, :2] - (st['cog_x'], st['cog_y'])) ** 2).sum(1).min())) row['dist_min'] = dmin if tracker is not None: pidx, _, just = tracker.update(st['cog_x'], st['cog_y']) row['progress_idx'] = pidx if just: completion_step = m stop_step = min(N, m + margin_steps) state_rows.append(row) if dmin > term['divergence_dist_m']: diverged_since = m if diverged_since is None else diverged_since if m - diverged_since >= hold_steps and outcome is None: outcome = 'diverged' summary['divergence_step'] = diverged_since if term['stop_on_divergence']: stop_step = m else: diverged_since = None # 4) controller tick if m in tick_set: j = tick_set[m] yaw = float(yaw_released(st['q_e0'], st['q_e1'], st['q_e2'], st['q_e3'])) tick_yaw_unw = yaw if tick_yaw_prev is None else tick_yaw_unw + float(np.arctan2(np.sin(yaw - tick_yaw_prev), np.cos(yaw - tick_yaw_prev))) tick_yaw_prev = yaw row = {'tick': j, 'step': m, 't': st['time'], 't_ctrl': (m - c0) * DT, 'x': st['cog_x'], 'y': st['cog_y'], 'z': st['cog_z'], 'yaw': yaw, 'yaw_unwrapped': tick_yaw_unw, 'speed': math.sqrt(st['vel_x'] ** 2 + st['vel_y'] ** 2), 'vx': st['vel_x'], 'vy': st['vel_y'], 'yaw_rate': yaw_rate_global(st), 'published': False, 'apply_step': -1, 'drv_steering': st['drv_steer'], 'drv_throttle': st['drv_thr'], 'drv_braking': st['drv_brake']} tick_rows.append(row) if controller_dead: row['status'] = 'controller_dead' continue if ros: while n_visible < len(pubs) and pubs[n_visible][0] <= m: n_visible += 1 obs_state = pubs[n_visible - 1][2] if n_visible else None row['obs_pub_step'] = pubs[n_visible - 1][1] if n_visible else None else: obs_state = st row['obs_pub_step'] = m if obs_state is not None: row['obs_age_steps'] = m - row['obs_pub_step'] if noisy: # noise indexed by the observed publication (see OBS_NOISE_MODEL) z = obs_noise_standard_normals(noise['seed'], row['obs_pub_step']) nz = tuple(float(noise[k] * z[i]) if noise[k] > 0 else 0.0 for i, k in enumerate(('std_x', 'std_y', 'std_yaw'))) noise_rows.append({'tick': j, 'step': m, 'obs_pub_step': row['obs_pub_step'], 'z_x': float(z[0]), 'z_y': float(z[1]), 'z_yaw': float(z[2]), 'noise_x': nz[0], 'noise_y': nz[1], 'noise_yaw': nz[2]}) else: nz = (0.0, 0.0, 0.0) pose_msg, twist_msg = make_messages(obs_state, nz) controller.observe(pose_msg, twist_msg) osqp_diag_take() # discard any record not made by this tick (read-only diagnostics) res = controller.tick() for si, rec in enumerate(osqp_diag_take()): diag_rows.append(dict(rec, tick=j, step=m, solve_index=si)) walls['controller_s'] += res['compute_wall_s'] row['compute_wall_s'] = res['compute_wall_s'] for k in ('obs_x', 'obs_y', 'obs_theta', 'obs_v', 'raw_throttle', 'raw_steering', 'rate_limited'): row[k] = res.get(k) row['rl_steering'] = res.get('ratelimited_steering') if res['e'] is not None: for i in range(4): row[f'e{i}'] = res['e'][i] row[f'et{i}'] = res['e_track'][i] th = row['obs_theta'] row['idx_lookahead'] = int(nearest_index(row['obs_x'], row['obs_y'], th, R, 1.0)[0]) row['idx_track'] = int(nearest_index(row['obs_x'], row['obs_y'], th, R, 0.0)[0]) row['arc_s_track'] = float(ref.arc[row['idx_track']]) if res['exception'] is not None: category, text = classify_controller_exception(res['exception']) if category == 'infrastructure': raise RuntimeError('bridge exception in controller tick:\n' + text) row['status'] = category failure = {'category': category, 'tick': j, 'step': m, 't': st['time'], 'traceback': text} if outcome is None: outcome = category controller_dead = True # released ROS node would crash here (exception escapes the timer callback) if cfg['on_controller_failure'] == 'terminate': stop_step = m continue if not res['published']: row['status'] = 'no_state' # released pub_callback returns before the first pose continue row['status'] = 'ok' row['published'] = True cmd = (res['pub_steering'], res['pub_throttle'], res['pub_braking']) row['pub_steering'], row['pub_throttle'], row['pub_braking'] = cmd if not all(math.isfinite(v) for v in cmd): row['status'] = 'controller_nonfinite_output' failure = {'category': 'controller_nonfinite_output', 'tick': j, 'step': m, 't': st['time']} outcome = outcome or 'controller_nonfinite_output' controller_dead = True if cfg['on_controller_failure'] == 'terminate': stop_step = m continue if ros: pending.append([m + cd + d_act, cmd, len(tick_rows) - 1]) elif d_act == 0: apply(cmd[0], cmd[1], cmd[2], m, len(tick_rows) - 1) else: ideal_cmd[j] = (cmd, len(tick_rows) - 1) # 5) ideal delayed application if m in apply_set and apply_set[m] in ideal_cmd: cmd, ti = ideal_cmd.pop(apply_set[m]) apply(cmd[0], cmd[1], cmd[2], m, ti) final_step = n summary['final_step'] = final_step summary['completion_step'] = completion_step if term['type'] == 'path_completion' and outcome is None: outcome = 'completed' if completion_step is not None else 'timeout' if outcome is None: outcome = 'horizon_reached' except Exception as e: # anything raised by runner/bridge/physics client = INFRASTRUCTURE status = 'infrastructure_error' failure = {'category': 'infrastructure', 'error': f'{type(e).__name__}: {e}', 'traceback': traceback.format_exc()[-6000:]} finally: if server is not None: summary['server_returncode'] = server.close() summary['server_extra_output'] = server.extra_output[-50:] summary['physics_pure_step_wall_s'] = server.state.get('step_wall_s') if server.state else None summary['server_step_calls'] = server.step_calls # ---- post-processing: tracking errors at 100 Hz (released definitions, zero lookahead) ---- if state_rows: S = np.array([[r['x'], r['y'], r['yaw'], r['speed']] for r in state_rows]) E, idx = error_state_vec(S[:, 0], S[:, 1], S[:, 2], S[:, 3], R, 0.0) for r, e, i in zip(state_rows, E, idx): r['e_long'], r['e_lat'], r['e_head'], r['e_speed'] = (float(v) for v in e) r['nearest_idx'] = int(i) r['arc_s'] = float(ref.arc[i]) c0_t = c0 * DT tl, th = term['tube_lat_m'], term['tube_head_rad'] if state_rows: t = np.array([r['step'] for r in state_rows]) * DT - c0_t lat_e = np.array([r['e_lat'] for r in state_rows]) head_e = np.array([r['e_head'] for r in state_rows]) after = t >= 0 te, k = first_tube_entry(t[after], lat_e[after], head_e[after], tl, th) summary['tube_entry_time_100hz_s'] = te if te is not None: ta, la, ha = t[after], lat_e[after], head_e[after] inside = (np.abs(la) < tl) & (np.abs(ha) < th) summary['fraction_inside_tube_after_entry'] = float(inside[k:].mean()) summary['tube_exits_after_entry'] = int(np.sum(np.diff(inside[k:].astype(int)) == -1)) outside = np.flatnonzero(~inside) # time after which the vehicle stays inside the tube until the end of the log (None if it ends outside) summary['stay_in_tube_time_100hz_s'] = (None if not inside[-1] else float(ta[outside[-1] + 1]) if len(outside) else float(ta[0])) summary['max_abs_lat_100hz_m'] = float(np.abs(lat_e).max()) summary['final_e_lat_m'] = float(lat_e[-1]) summary['final_e_head_rad'] = float(head_e[-1]) # ---- OFFLINE diagnostics, summary only (the logs and outcomes are unchanged) ---- # metric variant: the same tube on the controller's 1 m LOOKAHEAD error (released # error_state(1.0), the only error the 2024-02-27 node 763603c computed) of the true 100 Hz COG state. EL, _ = error_state_vec(S[:, 0], S[:, 1], S[:, 2], S[:, 3], R, 1.0) te_la, _ = first_tube_entry(t[after], EL[after, 1], EL[after, 2], tl, th) summary['tube_entry_time_100hz_lookahead_s'] = te_la # spin / sliding diagnostic (criterion in metrics.SPIN_CRITERION) yr = np.array([r['yaw_rate'] for r in state_rows]) k0, nflag, yrmax = spin_events(yr, S[:, 3], **{'yaw_rate_min': SPIN_CRITERION['yaw_rate_min_rad_s'], 'factor': SPIN_CRITERION['kinematic_factor'], 'r_min': SPIN_CRITERION['r_min_m'], 'n_consecutive': SPIN_CRITERION['min_consecutive_samples']}) summary['spin_flag'] = k0 is not None summary['spin_first_step'] = None if k0 is None else int(state_rows[k0]['step']) summary['spin'] = {'flag': k0 is not None, 'first_step': summary['spin_first_step'], 'n_flagged_samples': nflag, 'max_abs_yaw_rate': yrmax, 'criterion': SPIN_CRITERION} summary['max_abs_yaw_rate_100hz'] = yrmax # start transient: step of the lowest COG z in the first 0.5 s (touchdown after the drop from z = 0.25 m) early = [r for r in state_rows if r['step'] <= 500] if early: summary['chassis_touchdown_step'] = int(min(early, key=lambda r: r['z'])['step']) # ---- recovery summary fields, OFFLINE (logs/outcomes unchanged) ---- summary.update(recovery_summary_fields(state_rows, c0, tl, th, term, N, summary.get('divergence_step'))) applied = [r for r in tick_rows if r.get('apply_step') not in (None, -1)] if applied: first = min(applied, key=lambda r: r['apply_step']) summary['first_command_apply_step'] = int(first['apply_step']) prior = [r for r in state_rows if r['step'] <= first['apply_step']] summary['cog_z_at_first_command_apply'] = float(prior[-1]['z']) if prior else None pub_rows = [r for r in tick_rows if r.get('published')] if pub_rows: tt = np.array([r['t_ctrl'] for r in pub_rows]) te, _ = first_tube_entry(tt, np.array([r['et1'] for r in pub_rows]), np.array([r['et2'] for r in pub_rows]), tl, th) summary['tube_entry_time_tick_s'] = te # metric variant on the 10 Hz ticks: the controller's own lookahead error e[1], e[2] te_la, _ = first_tube_entry(tt, np.array([r['e1'] for r in pub_rows]), np.array([r['e2'] for r in pub_rows]), tl, th) summary['tube_entry_time_tick_lookahead_s'] = te_la # run MAE on the released-logger quantities (observed pose at published ticks), same definitions as the physical runs end_step = summary.get('completion_step') or (tick_rows[-1]['step'] if tick_rows else 0) rows = [r for r in pub_rows if r['step'] <= end_step] if rows: A, _ = audit_errors([r['obs_x'] for r in rows], [r['obs_y'] for r in rows], [r['obs_theta'] for r in rows], R) summary['run_mae_lateral_m'] = float(np.abs(A[:, 0]).mean()) summary['run_mae_heading_rad'] = float(np.abs(A[:, 1]).mean()) summary['run_mae_samples'] = len(rows) summary['n_ticks'] = len(tick_rows) summary['n_published'] = len(pub_rows) summary['n_rate_limited'] = int(sum(1 for r in pub_rows if r.get('rate_limited'))) summary['n_state_rows'] = len(state_rows) summary['status'] = status summary['outcome'] = outcome if status == 'ok' else None summary['failure'] = failure walls['total_s'] = time.perf_counter() - t_wall0 walls['other_s'] = walls['total_s'] - walls['init_s'] - walls['stepping_s'] - walls['controller_s'] summary['obs_noise_model'] = OBS_NOISE_MODEL if noisy else None if diag_rows: summary['mpc_osqp'] = mpc_osqp_summary(diag_rows) walls['osqp_run_s'] = float(sum(r.get('run_time') or 0.0 for r in diag_rows)) summary['wall'] = walls summary['sim_s'] = (summary.get('final_step') or 0) * DT write_csv_gz(os.path.join(workdir, 'ticks.csv.gz'), TICK_COLUMNS, tick_rows) write_csv_gz(os.path.join(workdir, 'state100.csv.gz'), STATE_COLUMNS, state_rows) names = ['ticks.csv.gz', 'state100.csv.gz'] if diag_rows: write_csv_gz(os.path.join(workdir, 'mpc_diag.csv.gz'), MPC_DIAG_COLUMNS, diag_rows) names.append('mpc_diag.csv.gz') if noise_rows: write_csv_gz(os.path.join(workdir, 'obs_noise.csv.gz'), OBS_NOISE_COLUMNS, noise_rows) names.append('obs_noise.csv.gz') summary['files'] = {name: sha256_file(os.path.join(workdir, name)) for name in names} return summary def mpc_osqp_summary(rows): """Deterministic aggregate of the per-solve OSQP records (no wall-clock field; those stay in mpc_diag.csv.gz and summary.wall.osqp_run_s).""" status = {} for r in rows: status[str(r.get('status'))] = status.get(str(r.get('status')), 0) + 1 its = [int(r['iter']) for r in rows if r.get('iter') is not None] rhou = [int(r['rho_updates']) for r in rows if r.get('rho_updates') is not None] rhoe = [float(r['rho_estimate']) for r in rows if r.get('rho_estimate') is not None] return {'n_solves': len(rows), 'status_counts': status, 'n_not_solved': sum(v for k, v in status.items() if k != 'solved'), 'iter_total': int(sum(its)), 'iter_mean': float(np.mean(its)) if its else None, 'iter_max': max(its) if its else None, 'rho_updates_total': int(sum(rhou)), 'n_solves_with_rho_update': int(sum(1 for v in rhou if v > 0)), 'rho_estimate_min': min(rhoe) if rhoe else None, 'rho_estimate_max': max(rhoe) if rhoe else None, 'adaptive_rho_interval_requested': sorted({str(r.get('adaptive_rho_interval_requested')) for r in rows}), 'qp_dims': sorted({f"{r.get('qp_n')}x{r.get('qp_m')}" for r in rows}), 'n_diag_errors': int(sum(1 for r in rows if r.get('diag_error')))} def recovery_summary_fields(state_rows, c0, tube_lat, tube_head, term, n_steps, online_divergence_step): """All from the 100 Hz true-state log (released error_state(0.0) e_lat / e_head; t relative to control start c0). Keys: horizon_mean_abs_e_lat_m / _head_rad mean |e| over every 100 Hz sample from control start (t = 0) to the end of the log (the full simulated horizon); n = horizon_mean_n_samples horizon_mean_from_sim0_abs_e_lat_m / _head_rad same over every sample from sim time 0 (differs only if c0 > 0) horizon_mean_covers_horizon True if the log reaches the configured horizon (no early stop) by_H[H] for H in 15 / 25 / 40 s (if H <= horizon - c0): mean |e_lat|, |e_head| over 0 <= t <= H, first tube entry within [0, H], exits after entry within [0, H], covered (log reaches c0 + H) divergence_events offline replay of the ONLINE rule (dist_min > divergence_dist_m for >= divergence_hold_s on consecutive 100 Hz samples): start_step, fire_step, end_step (last sample beyond the distance; None if the run lasts to the end of the log); n_divergence_events; divergence_flag diverged_then_recovered fired, and a tube entry occurs after the first fire step first_tube_entry_after_divergence_s t of that entry (None otherwise) entered_then_diverged first tube entry happened before the first divergence run started returned_within_divergence_dist the first divergence run ended before the end of the log divergence_offline_matches_online online divergence_step == first offline start_step (None if no online) The post-entry exit count over the whole log is tube_exits_after_entry (unchanged).""" steps = np.array([r['step'] for r in state_rows], dtype=np.int64) lat = np.abs(np.array([r['e_lat'] for r in state_rows], dtype=float)) head = np.abs(np.array([r['e_head'] for r in state_rows], dtype=float)) dist = np.array([r['dist_min'] for r in state_rows], dtype=float) rel = steps - c0 after = rel >= 0 out = {} out['horizon_mean_abs_e_lat_m'] = float(lat[after].mean()) if after.any() else None out['horizon_mean_abs_e_head_rad'] = float(head[after].mean()) if after.any() else None out['horizon_mean_n_samples'] = int(after.sum()) out['horizon_mean_from_sim0_abs_e_lat_m'] = float(lat.mean()) out['horizon_mean_from_sim0_abs_e_head_rad'] = float(head.mean()) out['horizon_mean_covers_horizon'] = bool(steps[-1] >= n_steps) inside = (lat < tube_lat) & (head < tube_head) by_h = {} for H in SUMMARY_H_WINDOWS_S: hs = int(round(H / DT)) if c0 + hs > n_steps: continue w = after & (rel <= hs) if not w.any(): continue ins = inside[w] k = np.flatnonzero(ins) by_h[f'{H:g}'] = {'abs_e_lat_m': float(lat[w].mean()), 'abs_e_head_rad': float(head[w].mean()), 'n_samples': int(w.sum()), 'covered': bool(steps[-1] >= c0 + hs), 'tube_entry_s': float(rel[w][k[0]] * DT) if len(k) else None, 'tube_exits_after_entry': (int(np.sum(np.diff(ins[k[0]:].astype(int)) == -1)) if len(k) else None)} out['by_H'] = by_h ev = divergence_events(steps, dist, term['divergence_dist_m'], int(round(term['divergence_hold_s'] / DT))) out['divergence_events'] = ev[:20] out['n_divergence_events'] = len(ev) out['divergence_flag'] = bool(ev) k_in = np.flatnonzero(after & inside) first_entry_step = int(steps[k_in[0]]) if len(k_in) else None if ev: fire = ev[0]['fire_step'] later = np.flatnonzero(after & inside & (steps > fire)) out['diverged_then_recovered'] = bool(len(later)) out['first_tube_entry_after_divergence_s'] = float(rel[later[0]] * DT) if len(later) else None out['entered_then_diverged'] = bool(first_entry_step is not None and first_entry_step < ev[0]['start_step']) out['returned_within_divergence_dist'] = ev[0]['end_step'] is not None else: out['diverged_then_recovered'] = False out['first_tube_entry_after_divergence_s'] = None out['entered_then_diverged'] = False out['returned_within_divergence_dist'] = None out['divergence_offline_matches_online'] = (None if online_divergence_step is None else bool(ev and ev[0]['start_step'] == online_divergence_step)) return out def run_episode_to_dir(cfg, pool, out_root, binary=None, server_timeout_s=120.0, provenance=None): """Atomic, never-overwriting wrapper: episodes// appears only when complete. `provenance`: code digest, host fingerprint, run_id and attempt, written into summary.json; an existing summary with a different code digest or host fingerprint is never reused.""" final = os.path.join(out_root, 'episodes', cfg['episode_id']) if os.path.exists(os.path.join(final, 'summary.json')): with open(os.path.join(final, 'summary.json')) as f: old = json.load(f) if old.get('config_hash') != cfgmod.config_hash(cfg): raise RuntimeError(f"episode {cfg['episode_id']} exists with a different config hash; refusing to overwrite") if provenance is not None: op = old.get('provenance') or {} for k in ('code_digest', 'host_fingerprint'): if op.get(k) != provenance.get(k): raise RuntimeError(f"episode {cfg['episode_id']} exists with a different {k}; refusing to reuse it") old['_skipped_existing'] = True return old tmp = os.path.join(out_root, 'episodes', f".tmp_{cfg['episode_id']}_{os.getpid()}") if os.path.exists(tmp): shutil.rmtree(tmp) os.makedirs(tmp) with open(os.path.join(tmp, 'episode_config.json'), 'w') as f: json.dump(cfg, f, indent=1, sort_keys=True) summary = run_episode(cfg, pool, tmp, binary=binary, server_timeout_s=server_timeout_s) if provenance is not None: summary['provenance'] = dict(provenance) summary['run_id'] = provenance.get('run_id') with open(os.path.join(tmp, 'summary.json'), 'w') as f: json.dump(summary, f, indent=1, sort_keys=True, default=str) if summary['status'] != 'ok': # infrastructure errors are kept apart and can be retried; never mixed with outcomes errdir = os.path.join(out_root, 'infrastructure_errors', f"{cfg['episode_id']}_{int(time.time() * 1e3)}_{os.getpid()}") os.makedirs(os.path.dirname(errdir), exist_ok=True) os.rename(tmp, errdir) return summary os.rename(tmp, final) return summary