feat: eval benchmark + cloud-trained models replace train/

- eval/: 统一推理评估框架 (infer_train.py, infer_reproduce.py, viz_flow.py,
  viz_signals.py, generate_report.py, run_all.sh, scene_manifest.py)
- train/: 替换为云端正式训练产出，覆盖 11 个场景
  - Karman: Re100 (5 seeds), Re60/200/400 transfer
  - VarDist: d075/d15/d2 scratch
  - Illusion: 0.75L/1.0L/1.5L/2.0L scratch
- train_karman.py: 新增 --resume-from 断点续训支持
- calibrations: 17 组标定数据 (kar/ill 命名规范)
- scripts/: 7 个自动化训练脚本
- 清理旧 calibrations/shell scripts/visualize

Co-authored-by: Cursor <cursoragent@cursor.com>

src/drl_pinball/eval/README.md

@@ -0,0 +1,206 @@
+# Eval Benchmark — 推理评估与流场分析
+
+> 对 V5 Train 模型和 Legacy 旧模型进行全面推理采样和可视化对比。
+> 复用 train env 保证与训练流程完全一致，不使用 skeleton injection。
+
+## 文件结构
+
+```
+src/drl_pinball/eval/
+  README.md                    # 本文件 (自我审查清单 + 复习流程)
+  __init__.py
+  scene_manifest.py            # 所有 scene 的配置单点真理源
+  infer_train.py               # V5 Train 模型推理引擎 (GPU 0)
+  infer_reproduce.py           # Reproduce 模型推理引擎 (GPU 1)
+  viz_flow.py                  # 涡量图跨场景拼图 (统一 colormap)
+  viz_signals.py               # obs/action/DTW/FFT 时序可视化
+  generate_report.py           # 汇总表格 + 柱状图
+  run_all.sh                   # 主启动器 (GPU 调度)
+  output/
+    train/{scene}/             # signals.npz, vorticity_*.png, metrics.json, all_seeds.json
+    reproduce/{scene}/         # 同上
+    reports/
+      comparison_table.md      # 汇总对比表
+      summary_dtw_barchart.png # DTW 柱状图
+      vorticity_panels/        # 跨场景拼图
+      signal_plots/            # 诊断信号图
+```
+
+## Quick Start
+
+```bash
+conda activate pycuda_3_10
+cd src/drl_pinball/eval
+
+# === 全量跑 (双 GPU) ===
+bash run_all.sh
+
+# === 单场景测试 ===
+python infer_train.py --scene re100 --device-id 0
+python infer_train.py --scene illusion_1L --device-id 0
+
+# === 仅跑报告生成 (已有 output 数据) ===
+python generate_report.py
+python viz_signals.py --side train
+python viz_flow.py
+```
+
+## GPU 调度策略
+
+```
+时间轴:
+
+GPU0: [re100] [ill_1L] [ill_15L] [ill_075L] --120s--> [re60] --120s--> [re200] --120s--> [re400]
+      (config A: karman_2000x600, nu=0.004)      (config B: re60)  (config C: re200)  (config D: re400)
+
+GPU1: --120s--> [karman_cloak] [steady_cloak] [ill_075L] [ill_1L] [ill_15L] [vortex_lamb] [vortex_taylor]
+                (全部 config_pinball.json, 无额外编译)
+```
+
+- GPU 1 比 GPU 0 晚 120 秒启动，避免两个不同 config 同时触发编译
+- 同 config 内 scene 连续运行，无 recompilation 开销
+- 每个 scene 约 5-8 分钟（warmup + FIFO + 360 步推理）
+
+## 场景覆盖率
+
+### Train pipeline (GPU 0)
+| Scene | Config | Seeds |
+|-------|--------|-------|
+| re100_karman | karman_2000x600 (Re=100) | 41-45, 539439 |
+| transfer_re60 | karman_2000x600_re60 | 41, 43 |
+| transfer_re200 | karman_2000x600_re200 | 41, 43, 45 |
+| transfer_re400 | karman_2000x600_re400 | 43 |
+| illusion_075L | karman_2000x600 | 41 |
+| illusion_1L | karman_2000x600 | 41, 43 |
+| illusion_15L | karman_2000x600 | 41, 43 |
+
+### Reproduce pipeline (GPU 1)
+| Scene | Config | 模型 |
+|-------|--------|------|
+| karman_cloak | pinball (1280x512) | d1a3o12_re100 |
+| steady_cloak | pinball (1280x512) | open-loop [0,-5.1,5.1] |
+| illusion_075L | pinball (1280x512) | d1a3o14_250525_imit_075L_2U_400S |
+| illusion_1L | pinball (1280x512) | d1a3o14_250525_imit_1L_2U_600S |
+| illusion_15L | pinball (1280x512) | d1a3o14_250525_imit_15L_2U |
+| vortex_lamb | pinball (1280x512) | vortex_lamb |
+| vortex_taylor | pinball (1280x512) | vortex_taylor |
+
+## 核心设计原则
+
+1. **复用 train env 而非重构 CFD** — KarmanCloakEnv / IllusionCloakEnv 已封装 norm、calibration、DTW、snapshot/restore
+2. **PPO.load() + VecNormalize.load()** — SB3 标准 API，不使用 skeleton injection
+3. **统一涡量 [-0.03, 0.03] colormap** — 所有场景跨可比
+4. **每步全量时序** — sensors(6) + forces(6) + actions(3) + rewards 存入 signals.npz
+
+---
+
+## 自我审查清单
+
+### 启动前
+- [ ] `conda activate pycuda_3_10`
+- [ ] 所有 `best_model.zip` 和 `vec_normalize.pkl` 路径存在 (见 scene_manifest.py)
+- [ ] 所有 `calibration.json` 和 `target.npy` 存在 (train/calibrations/)
+- [ ] `nvidia-smi` 显示两个 GPU 空闲
+- [ ] 无僵尸 pycuda 进程 (`pkill -f pycuda` 后等待 3 分钟)
+
+### Phase 1 — Train 推理
+- [ ] `python infer_train.py --scene re100 --device-id 0` 单场景测试通过
+- [ ] 输出的 `signals.npz` 形状: (360,6) sensors, (360,6) forces, (360,3) actions
+- [ ] rewards 非 NaN，DTW sim 在 [0,1] 内
+- [ ] Zero-action baseline 的 DTW 明显低于 controlled
+
+### Phase 2 — Reproduce 推理
+- [ ] `python infer_reproduce.py --scene karman_cloak --device-id 1` 测试通过
+- [ ] 旧模型 PPO.load() 不报错
+- [ ] Vortex 场景 add_vortex 正确初始化（check target.npz 非全零）
+
+### Phase 3 — 涡量图
+- [ ] `python viz_flow.py` 产出全部拼图
+- [ ] vorticity range 统一 [-0.03, 0.03]
+- [ ] 圆柱边界清晰可见
+- [ ] target vs controlled vs zero 三栏对比正常
+
+### Phase 4 — 时序图
+- [ ] `python viz_signals.py --side train` 产出全部诊断图
+- [ ] FFT 频谱确认 controlled 与 target Strouhal 匹配
+- [ ] Action 时序 policy 收敛到稳态 (非振荡)
+
+### Phase 5 — 汇总报告
+- [ ] `python generate_report.py` 产出 comparison_table.md
+- [ ] Train DTW >= Reproduce DTW (或合理的 gap 原因)
+
+### 最终验收
+- [ ] 7 train + 7 reproduce 目录完整
+- [ ] 每个目录: signals.npz, vorticity_controlled.png, vorticity_target.png, vorticity_zero.png, metrics.json, all_seeds.json
+- [ ] reports/ 下: comparison_table.md, summary_dtw_barchart.png, vorticity_panels/, signal_plots/
+
+---
+
+## 复习流程 (中断后快速恢复)
+
+按顺序读取以下文件重建上下文：
+
+1. **本文件** — 确认当前进度和 GPU 调度图
+
+2. **`eval/scene_manifest.py`** — 所有 scene 配置
+   ```bash
+   python -c "from drl_pinball.eval.scene_manifest import TRAIN_SCENES; \
+              [print(s['scene_id'], s['si']) for s in TRAIN_SCENES]"
+   ```
+
+3. **`train/TRAIN_KNOWLEDGE.md`** sections 1-3 — V5 训练管线回顾
+
+4. **验证环境可用**:
+   ```bash
+   ls eval/output/train/*/metrics.json 2>/dev/null  # 已完成的 scene
+   ls eval/output/reproduce/*/metrics.json 2>/dev/null
+   ```
+
+5. **从断点继续**:
+   ```bash
+   # 单 scene:
+   python infer_train.py --scene re200 --device-id 0
+   # 或 Kill pycuda 进程后重新启动显卡:
+   pkill -f pycuda; sleep 180; bash run_all.sh
+   ```
+
+### 常见问题排查
+
+| 问题 | 解决方案 |
+|------|---------|
+| `cuInit failed` | GPU 被占用。`pkill -f pycuda; sleep 180` 后重试 |
+| `best_model.zip not found` | 训练未完成。查看 `train/output/{case}/models/` |
+| `target.npy not found` | calibration 缺失。重新运行 `calibrate.py` |
+| DTW sim = -1.0 (reproduce) | 正常。Reproduce 不计算 DTW，由 report 统一处理 |
+| 涡量图空白 | 检查 `render_vorticity_field` 的 `vmin/vmax` 或 cylinders 坐标 |
+| VecNormalize.pkl 不存在 | 训练时未保存。用 `best_model.zip` 同目录的 `vec_normalize.pkl` |
+
+---
+
+## 代码关键点
+
+### infer_train.py 的关键差异点
+
+- 每个 seed 独立 `PPO.load()` + `VecNormalize.load()`，不是共用 skeleton
+- 推理时 `SymmetryAugmentWrapper(prob=0.0)`（deterministic mode）
+- Raw obs 从 `env._read_obs()` 提取，通过 wrapper chain 穿透
+- Target vorticity 单独创建 Simulation 生成（dist cylinder only）
+
+### infer_reproduce.py 的关键差异点
+
+- 1280x512 网格，parabolic inlet，bounce-back walls
+- Legacy norm 从 `SR_analysis/data/*/norm.json` 加载
+- 旧动作缩放: `norm * scale + bias` (各 scene 不同)
+- Illusion 模型 obs_dim=14（含 target_cd, target_cl，通过 harmonics 重构）
+- Vortex 用 `add_vortex()` 在不同 x 位置添加涡量
+
+### 输出文件命名
+
+| 文件 | 内容 |
+|------|------|
+| `signals.npz` | sensors (N,6), forces (N,6), actions (N,3), rewards (N,) |
+| `vorticity_controlled.png` | DRL 控制后的 final 时刻涡量 |
+| `vorticity_target.png` | 目标状态 (disturbance only / target cylinder) |
+| `vorticity_zero.png` | 零动作 baseline (无控制) |
+| `metrics.json` | DTW sim, reward, action stats |
+| `all_seeds.json` | 每个 seed 的详细评分 |

src/drl_pinball/eval/__init__.py

@@ -0,0 +1 @@
+# eval package

src/drl_pinball/eval/generate_report.py

@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+"""Generate master comparison report from eval outputs.
+
+Reads metrics.json from all output/{train,reproduce}/ directories,
+produces:
+  1. Master comparison table (markdown)
+  2. Summary bar chart (train vs reproduce DTW similarity)
+  3. Action statistics summary
+
+Usage:
+    conda run -n pycuda_3_10 python generate_report.py
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Any, Dict, List
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+
+_OUT_BASE = Path(__file__).resolve().parent / "output"
+_REPORT_DIR = _OUT_BASE / "reports"
+
+
+def log(msg: str) -> None:
+    print(f"[report] {msg}", flush=True)
+
+
+def load_metrics(scene_dir: Path) -> Dict[str, Any]:
+    p = scene_dir / "metrics.json"
+    if p.exists():
+        with open(p) as f:
+            return json.load(f)
+    return {}
+
+
+def load_all_seeds(scene_dir: Path) -> List[Dict]:
+    p = scene_dir / "all_seeds.json"
+    if p.exists():
+        with open(p) as f:
+            return json.load(f)
+    return []
+
+
+# ---------------------------------------------------------------------------
+# Tables
+# ---------------------------------------------------------------------------
+def generate_comparison_table() -> str:
+    """Generate markdown comparison table for overlapping scenes."""
+    overlap = [
+        ("re100_karman", "karman_cloak", "Karman Cloak Re100"),
+        ("illusion_075L", "illusion_075L", "Illusion 0.75L"),
+        ("illusion_1L", "illusion_1L", "Illusion 1.0L"),
+        ("illusion_15L", "illusion_15L", "Illusion 1.5L"),
+    ]
+
+    lines = []
+    lines.append("# Master Comparison Table")
+    lines.append("")
+    lines.append("| Scene | Side | Best Seed | DTW sim | Reward | "
+                 "aF mean | aB mean | aT mean | r_cd | r_cl | r_sim |")
+    lines.append("|-------|------|-----------|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|")
+
+    for trn_key, rep_key, name in overlap:
+        m_trn = load_metrics(_OUT_BASE / "train" / trn_key)
+        m_rep = load_metrics(_OUT_BASE / "reproduce" / rep_key)
+
+        dtw_t = _fmt(m_trn.get("dtw_sim_v5") or m_trn.get("sim_raw_mean"))
+        dtw_r = _fmt(m_rep.get("dtw_sim_v5") or m_rep.get("sim_raw_mean"))
+
+        # Train row
+        lines.append(
+            f"| {name} | Train | {m_trn.get('best_seed', '-')} | "
+            f"{dtw_t} | {_fmt(m_trn.get('reward_mean'))} | "
+            f"{_fmt(m_trn.get('aF_mean'))} | {_fmt(m_trn.get('aB_mean'))} | "
+            f"{_fmt(m_trn.get('aT_mean'))} | "
+            f"{_fmt(m_trn.get('r_cd_mean'))} | {_fmt(m_trn.get('r_cl_mean'))} | "
+            f"{_fmt(m_trn.get('r_sim_mean'))} |"
+        )
+        # Reproduce row
+        lines.append(
+            f"| {name} | Reproduce | - | "
+            f"{dtw_r} | - | "
+            f"- | - | - | - | - | - |"
+        )
+
+    # Train-only scenes
+    train_only = ["transfer_re60", "transfer_re200", "transfer_re400"]
+    lines.append("")
+    lines.append("## Train Only (Cross-Re Transfer)")
+    lines.append("| Scene | Best Seed | Reward | "
+                 "r_cd | r_cl | r_sim | sim_raw |")
+    lines.append("|-------|-----------|---:|-----:|-----:|-----:|---:|")
+    for trn_key in train_only:
+        m = load_metrics(_OUT_BASE / "train" / trn_key)
+        lines.append(
+            f"| {trn_key} | {m.get('best_seed', '-')} | "
+            f"{_fmt(m.get('reward_mean'))} | "
+            f"{_fmt(m.get('r_cd_mean'))} | {_fmt(m.get('r_cl_mean'))} | "
+            f"{_fmt(m.get('r_sim_mean'))} | {_fmt(m.get('sim_raw_mean'))} |"
+        )
+
+    # Reproduce-only
+    repro_only = ["steady_cloak", "vortex_lamb", "vortex_taylor"]
+    lines.append("")
+    lines.append("## Reproduce Only")
+    lines.append("| Scene | Notes |")
+    lines.append("|-------|-------|")
+    for r_key in repro_only:
+        lines.append(f"| {r_key} | open-loop / vortex |")
+
+    # Per-scene all-seeds detail
+    lines.append("")
+    lines.append("## Per-Scene Seed Details (Train)")
+    for trn_key in ["re100_karman", "transfer_re60", "transfer_re200",
+                     "transfer_re400", "illusion_075L", "illusion_1L", "illusion_15L"]:
+        seeds = load_all_seeds(_OUT_BASE / "train" / trn_key)
+        if not seeds:
+            continue
+        lines.append(f"\n### {trn_key}")
+        lines.append("| Seed | Reward | r_cd | r_cl | r_sim | sim_raw | Time (s) |")
+        lines.append("|------|--------|------|------|-------|---------|---------:|")
+        for s in sorted(seeds, key=lambda x: -x.get("reward", -float("inf"))):
+            lines.append(
+                f"| {s['seed']} | {_fmt(s.get('reward'))} | "
+                f"{_fmt(s.get('r_cd'))} | {_fmt(s.get('r_cl'))} | "
+                f"{_fmt(s.get('r_sim'))} | {_fmt(s.get('sim_raw'))} | "
+                f"{_fmt_int(s.get('dt_sec'))} |"
+            )
+
+    return "\n".join(lines)
+
+
+def _fmt(v, precision=4):
+    if v is None or v == -1.0:
+        return "-"
+    if isinstance(v, float):
+        return f"{v:.{precision}f}"
+    return str(v)
+
+
+def _fmt_int(v):
+    if v is None:
+        return "-"
+    return f"{int(v)}"
+
+
+# ---------------------------------------------------------------------------
+# Bar chart
+# ---------------------------------------------------------------------------
+def generate_dtw_barchart() -> None:
+    overlap = [
+        ("re100_karman", "karman_cloak", "Karman Cloak"),
+        ("illusion_075L", "illusion_075L", "Illusion 0.75L"),
+        ("illusion_1L", "illusion_1L", "Illusion 1L"),
+        ("illusion_15L", "illusion_15L", "Illusion 1.5L"),
+    ]
+
+    names = []
+    trn_vals = []
+    rep_vals = []
+    for trn_key, rep_key, name in overlap:
+        m_trn = load_metrics(_OUT_BASE / "train" / trn_key)
+        m_rep = load_metrics(_OUT_BASE / "reproduce" / rep_key)
+        t = m_trn.get("dtw_sim_v5") or m_trn.get("sim_raw_mean", 0)
+        r = m_rep.get("dtw_sim_v5") or m_rep.get("sim_raw_mean", 0)
+        names.append(name)
+        trn_vals.append(t if t and t > 0 else 0)
+        rep_vals.append(r if r and r > 0 else 0)
+
+    fig, ax = plt.subplots(figsize=(10, 5))
+    x = np.arange(len(names))
+    w = 0.35
+    ax.bar(x - w / 2, rep_vals, w, label="Reproduce (legacy)", color="#d62728")
+    ax.bar(x + w / 2, trn_vals, w, label="Train (V5)", color="#1f77b4")
+    ax.set_xticks(x); ax.set_xticklabels(names, rotation=15, ha="right")
+    ax.set_ylabel("DTW Similarity"); ax.set_ylim(0, 1.05)
+    ax.set_title("Train vs Reproduce - DTW Similarity")
+    ax.legend(); ax.grid(axis="y", alpha=0.3)
+    for i, (tv, rv) in enumerate(zip(trn_vals, rep_vals)):
+        if tv > 0: ax.text(i + w / 2, tv + 0.01, f"{tv:.3f}", ha="center", fontsize=9)
+        if rv > 0: ax.text(i - w / 2, rv + 0.01, f"{rv:.3f}", ha="center", fontsize=9)
+    fig.tight_layout()
+    fig.savefig(_REPORT_DIR / "summary_dtw_barchart.png", dpi=150,
+                bbox_inches="tight")
+    plt.close(fig)
+    log("  -> summary_dtw_barchart.png")
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+def main() -> int:
+    _REPORT_DIR.mkdir(parents=True, exist_ok=True)
+    log(f"Train dir: {_OUT_BASE / 'train'}")
+    log(f"Reproduce dir: {_OUT_BASE / 'reproduce'}")
+    log(f"Reports dir: {_REPORT_DIR}")
+
+    table = generate_comparison_table()
+    (_REPORT_DIR / "comparison_table.md").write_text(table)
+    log("  -> comparison_table.md")
+
+    generate_dtw_barchart()
+
+    log("All reports generated.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

src/drl_pinball/eval/infer_reproduce.py

@@ -0,0 +1,610 @@
+#!/usr/bin/env python3
+"""Reproduce pipeline inference: legacy models on 1280x512 config.
+
+Loads pre-trained PPO models from models/old/ and models/250525/,
+runs deterministic inference on config_lbm_pinball.json (parabolic, bounce-back).
+
+Key differences from train pipeline:
+  - 1280x512 grid (not 2000x600)
+  - Legacy norm (force_norm_fact + sens_deviation + sens_norm_fact)
+  - Old action scaling with biases (match legacy env)
+  - No VecNormalize (old models use manual norm)
+  - DummyEnv for PPO.load()
+
+Usage:
+    conda run -n pycuda_3_10 python -u infer_reproduce.py --device-id 1
+    conda run -n pycuda_3_10 python -u infer_reproduce.py --device-id 1 --scene karman
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+from collections import deque
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+import numpy as np
+import pycuda.driver as cuda; cuda.init()
+
+_REPO = str(Path(__file__).resolve().parents[3])
+_SRC = Path(_REPO) / "src"
+for p in [_REPO, str(_SRC)]:
+    if p not in sys.path:
+        sys.path.insert(0, p)
+
+import torch
+from torch.nn import Module as TorchModule
+from stable_baselines3 import PPO
+
+from CelerisLab import Simulation
+from CelerisLab.common.render import compute_vorticity, render_vorticity_field
+from CelerisLab.lbm.initializers import add_vortex
+from drl_pinball.reproduce.configs.model_inventory import ModelInventory
+from drl_pinball.eval.scene_manifest import REPRODUCE_SCENES
+
+L0 = 20.0
+U0 = 0.01
+NX = 1280
+NY = 512
+CENTER_Y = float(NY - 1) / 2.0
+RADIUS = L0 / 2.0
+FIFO_LEN = 150
+WARMUP = int(4.0 * NX / U0)
+
+# Karman/Vortex/Steady geometry (1280x512)
+DIST_X = 10.0 * L0   # 200
+PB_FRONT_X = 30.0 * L0   # 600
+PB_REAR_X = 31.3 * L0    # 626
+SENSOR_X = 40.0 * L0     # 800
+
+# Illusion geometry (shifted left)
+ILL_PB_FRONT_X = 19.0 * L0   # 380
+ILL_PB_REAR_X = 20.3 * L0    # 406
+ILL_SENSOR_X = 30.0 * L0     # 600
+ILL_TARGET_X = 20.0 * L0     # 400
+
+VORTEX_RADIUS = 2.0 * L0
+SR_DATA = _SRC / "SR_analysis" / "data"
+_OUT_BASE = Path(__file__).resolve().parent / "output" / "reproduce"
+
+
+class Sin(TorchModule):
+    def __init__(self): super().__init__()
+    def forward(self, x): return torch.sin(x)
+
+
+def log(msg: str) -> None:
+    print(f"[{time.strftime('%H:%M:%S')}] {msg}", flush=True)
+
+
+# ---------------------------------------------------------------------------
+# Legacy helpers
+# ---------------------------------------------------------------------------
+class ActionSmoother:
+    def __init__(self, weight=0.1):
+        self.weight = weight; self._state = None
+    def __call__(self, target):
+        t = np.asarray(target, dtype=np.float32)
+        if self._state is None:
+            self._state = t.copy()
+        else:
+            self._state = (1.0 - self.weight) * self._state + self.weight * t
+        return self._state.copy()
+    def reset(self, value=None):
+        self._state = np.asarray(value, dtype=np.float32).copy() if value is not None else None
+
+
+def get_cc(sim, sid):
+    nx, ny = sim.lbm_cfg.nx, sim.lbm_cfg.ny
+    cells_arr, _ = sim.bodies.get(sid).get_sensor_list(nx, ny)
+    return float(len(cells_arr))
+
+
+def action_to_omega_legacy(action_norm, scale=8.0, bias=(0.0, -4.0, 4.0)):
+    b = np.array(bias, dtype=np.float32)
+    sv = (np.asarray(action_norm, dtype=np.float32) * scale + b) * U0
+    return -sv / RADIUS
+
+
+def load_legacy_norm(ref_dir: str) -> Dict[str, Any]:
+    with open(os.path.join(ref_dir, "norm.json")) as f:
+        d = json.load(f)
+    return {
+        "force_norm_fact": np.float32(d["force_norm_fact"]),
+        "sens_deviation": np.array(d["sens_deviation"], dtype=np.float32),
+        "sens_norm_fact": np.array(d["sens_norm_fact"], dtype=np.float32),
+    }
+
+
+def normalize_obs(obs_slice, norm):
+    forces = obs_slice[6:12] / norm["force_norm_fact"]
+    sens = (obs_slice[0:6] - norm["sens_deviation"]) / norm["sens_norm_fact"]
+    return np.clip(np.hstack([forces, sens]), -1.0, 1.0).astype(np.float32)
+
+
+def save_vorticity(sim, out_path, cylinders, nx=NX, ny=NY):
+    macro = sim.get_macroscopic()
+    vort = compute_vorticity(macro["ux"], macro["uy"])
+    render_vorticity_field(vort, nx=nx, ny=ny, out_path=str(out_path),
+                           cylinders=cylinders, vmin=-0.03, vmax=0.03)
+
+
+# ---------------------------------------------------------------------------
+# Obs readers (legacy ordering)
+# ---------------------------------------------------------------------------
+def read_obs_karman(sim, dist_id, sensor_ids, pinball_ids, cc):
+    """dist_fx, dist_fy, s0_ux, s0_uy, s1_ux, s1_uy, s2_ux, s2_uy,
+       front_fx, front_fy, top_fx, top_fy, bot_fx, bot_fy"""
+    obs = list(sim.read_force(dist_id, normalize=True))
+    for sid in sensor_ids:
+        s = sim.read_sensor(sid, normalize=True)
+        obs.extend([float(s[0]) * cc, float(s[1]) * cc])
+    for pid in pinball_ids:
+        obs.extend(sim.read_force(pid, normalize=True))
+    return np.array(obs, dtype=np.float32)
+
+
+def read_obs_6obj(sim, sensor_ids, pinball_ids, cc):
+    obs = []
+    for sid in sensor_ids:
+        s = sim.read_sensor(sid, normalize=True)
+        obs.extend([float(s[0]) * cc, float(s[1]) * cc])
+    for pid in pinball_ids:
+        obs.extend(sim.read_force(pid, normalize=True))
+    return np.array(obs, dtype=np.float32)
+
+
+# ---------------------------------------------------------------------------
+# Karman Cloak
+# ---------------------------------------------------------------------------
+def run_karman_reproduce(scene: Dict[str, Any], device_id: int, out_dir: Path) -> None:
+    log(f"=== Reproduce: Karman Cloak ===")
+    out_dir.mkdir(parents=True, exist_ok=True)
+    SI = scene["si"]
+    num_steps = scene["num_steps"]
+    model_name = scene["model_name"]
+    scale = scene["action_scale"]
+    bias = scene["action_bias"]
+
+    # Phase 1: Disturbance + sensors, record target
+    log("  Phase 1: Recording target...")
+    sim = Simulation(lbm_config_path=scene["config_path"], device_id=device_id)
+    dist_id = sim.add_body("circle", center=(DIST_X, CENTER_Y, 0.0), radius=1.0 * L0)
+    sensor_ids = [
+        sim.add_body("sensor", center=(SENSOR_X, CENTER_Y + 40.0, 0.0), radius=5.0),
+        sim.add_body("sensor", center=(SENSOR_X, CENTER_Y, 0.0), radius=5.0),
+        sim.add_body("sensor", center=(SENSOR_X, CENTER_Y - 40.0, 0.0), radius=5.0),
+    ]
+    sim.initialize()
+    sim.run(WARMUP, zero_obs=True)
+    cc = get_cc(sim, sensor_ids[0])
+    log(f"  Sensor cell count: {cc}")
+
+    target_states = np.zeros((FIFO_LEN, 6), dtype=np.float32)
+    for i in range(FIFO_LEN):
+        sim.run(SI, zero_obs=True)
+        obs = read_obs_karman(sim, dist_id, sensor_ids, [], cc)
+        target_states[i] = obs[2:8]
+    np.savez_compressed(out_dir / "target.npz", target_states=target_states)
+
+    # Save target vorticity
+    save_vorticity(sim, out_dir / "vorticity_target.png",
+                   [((DIST_X, CENTER_Y), 1.0 * L0),
+                    ((SENSOR_X, CENTER_Y + 40.0), 5.0),
+                    ((SENSOR_X, CENTER_Y), 5.0),
+                    ((SENSOR_X, CENTER_Y - 40.0), 5.0)])
+
+    # Phase 2: Add pinball
+    log("  Phase 2: Adding pinball...")
+    n0 = sim.bodies.count
+    sim.add_body("circle", center=(PB_FRONT_X, CENTER_Y, 0.0), radius=RADIUS)
+    sim.add_body("circle", center=(PB_REAR_X, CENTER_Y + 15.0, 0.0), radius=RADIUS)
+    sim.add_body("circle", center=(PB_REAR_X, CENTER_Y - 15.0, 0.0), radius=RADIUS)
+    sim.sync_bodies()
+    fid, tid, bid = list(range(n0, n0 + 3))
+    sim.run(WARMUP, zero_obs=True)
+
+    # Load legacy norm
+    ref_dir = str(SR_DATA / "karman" / "karman_re100")
+    norm = load_legacy_norm(ref_dir)
+
+    # Bias FIFO
+    bias_norm = np.array([0.0, -1.0, 1.0])
+    bias_omega = action_to_omega_legacy(bias_norm, scale=scale, bias=bias)
+    ema = ActionSmoother(weight=0.1); ema.reset(np.zeros(3, dtype=np.float32))
+    for _ in range(FIFO_LEN):
+        s = ema(bias_omega)
+        sim.set_body(fid, omega=s[0]); sim.set_body(tid, omega=s[1]); sim.set_body(bid, omega=s[2])
+        sim.run(SI, zero_obs=True)
+    sim.snapshot()
+
+    # DRL inference
+    log("  Phase 3: DRL inference...")
+    sim.restore()
+    ema.reset(bias_omega.copy())
+
+    model = ModelInventory().load(model_name, device="cpu")
+    log(f"  Model: {model_name} on CPU")
+
+    obs_init = read_obs_karman(sim, dist_id, sensor_ids, [fid, tid, bid], cc)
+    obs_norm = normalize_obs(obs_init[2:14], norm)
+
+    sig_s = np.zeros((num_steps, 6), dtype=np.float32)
+    sig_f = np.zeros((num_steps, 6), dtype=np.float32)
+    sig_a = np.zeros((num_steps, 3), dtype=np.float32)
+    fifo = deque(maxlen=FIFO_LEN)
+    [fifo.append(target_states[i, :].copy()) for i in range(FIFO_LEN)]
+
+    for step in range(num_steps):
+        action, _ = model.predict(obs_norm, deterministic=True)
+        action = np.asarray(action, dtype=np.float32).flatten()
+        target_omega = action_to_omega_legacy(action, scale=scale, bias=bias)
+        smoothed = ema(target_omega)
+
+        sim.set_body(fid, omega=smoothed[0]); sim.set_body(tid, omega=smoothed[1]); sim.set_body(bid, omega=smoothed[2])
+        sim.run(SI, zero_obs=True)
+
+        obs = read_obs_karman(sim, dist_id, sensor_ids, [fid, tid, bid], cc)
+        sl = obs[2:14]
+        fifo.append(sl[0:6].copy())
+        sig_s[step] = sl[0:6]
+        sig_f[step] = sl[6:12]
+        sig_a[step] = action
+        obs_norm = normalize_obs(sl, norm)
+
+    save_vorticity(sim, out_dir / "vorticity_controlled.png", [
+        ((DIST_X, CENTER_Y), 1.0 * L0),
+        ((PB_FRONT_X, CENTER_Y), RADIUS),
+        ((PB_REAR_X, CENTER_Y + 15.0), RADIUS),
+        ((PB_REAR_X, CENTER_Y - 15.0), RADIUS),
+    ])
+    sim.close()
+
+    np.savez_compressed(out_dir / "signals.npz",
+                        sensors=sig_s, forces=sig_f, actions=sig_a)
+    metrics = {"dtw_sim_v5": -1.0}  # DTW computed by generate_report later
+    with open(out_dir / "metrics.json", "w") as f:
+        json.dump(metrics, f, indent=2)
+    log("  Done.")
+
+
+# ---------------------------------------------------------------------------
+# Steady Cloak (open-loop)
+# ---------------------------------------------------------------------------
+def run_steady_reproduce(scene: Dict[str, Any], device_id: int, out_dir: Path) -> None:
+    log(f"=== Reproduce: Steady Cloak ===")
+    out_dir.mkdir(parents=True, exist_ok=True)
+    SI = scene["si"]
+    num_steps = scene["num_steps"]
+    surf_vel = scene.get("open_loop_surf_vel", (0.0, -5.1, 5.1))
+    bias_surf = np.array(surf_vel, dtype=np.float32) * U0
+
+    sim = Simulation(lbm_config_path=scene["config_path"], device_id=device_id)
+    sensor_ids = [
+        sim.add_body("sensor", center=(SENSOR_X, CENTER_Y + 40.0, 0.0), radius=5.0),
+        sim.add_body("sensor", center=(SENSOR_X, CENTER_Y, 0.0), radius=5.0),
+        sim.add_body("sensor", center=(SENSOR_X, CENTER_Y - 40.0, 0.0), radius=5.0),
+    ]
+    sim.add_body("circle", center=(PB_FRONT_X, CENTER_Y, 0.0), radius=RADIUS)
+    sim.add_body("circle", center=(PB_REAR_X, CENTER_Y + 15.0, 0.0), radius=RADIUS)
+    sim.add_body("circle", center=(PB_REAR_X, CENTER_Y - 15.0, 0.0), radius=RADIUS)
+    sim.initialize()
+    sim.run(WARMUP, zero_obs=True)
+    cc = get_cc(sim, sensor_ids[0])
+
+    save_vorticity(sim, out_dir / "vorticity_zero.png", [
+        ((PB_FRONT_X, CENTER_Y), RADIUS),
+        ((PB_REAR_X, CENTER_Y + 15.0), RADIUS),
+        ((PB_REAR_X, CENTER_Y - 15.0), RADIUS),
+    ])
+
+    bias_omega = -bias_surf / RADIUS
+    ema = ActionSmoother(weight=0.1); ema.reset(np.zeros(3, dtype=np.float32))
+    for _ in range(FIFO_LEN):
+        s = ema(bias_omega)
+        sim.set_body(3, omega=s[0]); sim.set_body(4, omega=s[1]); sim.set_body(5, omega=s[2])
+        sim.run(SI, zero_obs=True)
+    sim.snapshot()
+    sim.restore()
+    ema.reset(bias_omega.copy())
+
+    sig_s = np.zeros((num_steps, 6), dtype=np.float32)
+    sig_f = np.zeros((num_steps, 6), dtype=np.float32)
+    for step in range(num_steps):
+        smoothed = ema(bias_omega)
+        sim.set_body(3, omega=smoothed[0]); sim.set_body(4, omega=smoothed[1]); sim.set_body(5, omega=smoothed[2])
+        sim.run(SI, zero_obs=True)
+        obs = read_obs_6obj(sim, sensor_ids, [3, 4, 5], cc)
+        sig_s[step] = obs[0:6]
+        sig_f[step] = obs[6:12]
+
+    save_vorticity(sim, out_dir / "vorticity_controlled.png", [
+        ((PB_FRONT_X, CENTER_Y), RADIUS),
+        ((PB_REAR_X, CENTER_Y + 15.0), RADIUS),
+        ((PB_REAR_X, CENTER_Y - 15.0), RADIUS),
+    ])
+    sim.close()
+
+    np.savez_compressed(out_dir / "signals.npz", sensors=sig_s, forces=sig_f,
+                        actions=np.zeros((num_steps, 3), dtype=np.float32))
+    with open(out_dir / "metrics.json", "w") as f:
+        json.dump({"dtw_sim_v5": -1.0}, f, indent=2)
+    log("  Done.")
+
+
+# ---------------------------------------------------------------------------
+# Illusion
+# ---------------------------------------------------------------------------
+def run_illusion_reproduce(scene: Dict[str, Any], device_id: int, out_dir: Path) -> None:
+    scene_id = scene["scene_id"]
+    log(f"=== Reproduce: Illusion {scene_id} ===")
+    out_dir.mkdir(parents=True, exist_ok=True)
+    SI = scene["si"]
+    num_steps = scene["num_steps"]
+    model_name = scene["model_name"]
+    scale = scene["action_scale"]
+    bias = scene["action_bias"]
+    target_diam = scene.get("target_diam", 1.0)
+
+    # Load legacy data
+    ref_dir = str(SR_DATA / "illusion" / scene_id)
+    norm = load_legacy_norm(ref_dir)
+    with open(os.path.join(ref_dir, "target_harmonics.json")) as f:
+        target_harmonics = json.load(f)
+    legacy_target = np.load(os.path.join(ref_dir, "target.npz"))["target_states"]
+
+    def gen_target_at(t):
+        D = len(target_harmonics)
+        result = np.zeros(D, dtype=np.float32)
+        for d, h in enumerate(target_harmonics):
+            val = np.float32(h["dc"])
+            for amp, freq, phase in zip(h["amps"], h["freqs"], h["phases"]):
+                val += amp * np.cos(2.0 * np.pi * freq * t + phase)
+            result[d] = val
+        return result
+
+    sim = Simulation(lbm_config_path=scene["config_path"], device_id=device_id)
+    sensor_ids = [
+        sim.add_body("sensor", center=(ILL_SENSOR_X, CENTER_Y + 40.0, 0.0), radius=5.0),
+        sim.add_body("sensor", center=(ILL_SENSOR_X, CENTER_Y, 0.0), radius=5.0),
+        sim.add_body("sensor", center=(ILL_SENSOR_X, CENTER_Y - 40.0, 0.0), radius=5.0),
+    ]
+    sim.add_body("circle", center=(ILL_PB_FRONT_X, CENTER_Y, 0.0), radius=RADIUS)
+    sim.add_body("circle", center=(ILL_PB_REAR_X, CENTER_Y + 15.0, 0.0), radius=RADIUS)
+    sim.add_body("circle", center=(ILL_PB_REAR_X, CENTER_Y - 15.0, 0.0), radius=RADIUS)
+    sim.initialize()
+    sim.run(WARMUP, zero_obs=True)
+    cc = get_cc(sim, sensor_ids[0])
+    fid, tid, bid = 3, 4, 5
+
+    # Bias FIFO
+    bias_surf = np.array([0.0, -1.0, 1.0], dtype=np.float32) * U0
+    bias_omega = -bias_surf / RADIUS
+    ema_b = ActionSmoother(weight=0.1); ema_b.reset(np.zeros(3, dtype=np.float32))
+    for _ in range(FIFO_LEN):
+        s = ema_b(bias_omega)
+        sim.set_body(fid, omega=s[0]); sim.set_body(tid, omega=s[1]); sim.set_body(bid, omega=s[2])
+        sim.run(SI, zero_obs=True)
+    sim.snapshot()
+
+    # DRL inference
+    sim.restore()
+    ema = ActionSmoother(weight=0.1); ema.reset(bias_omega.copy())
+    model = ModelInventory().load(model_name, device="cpu")
+    log(f"  Model: {model_name} on CPU")
+
+    obs_init = read_obs_6obj(sim, sensor_ids, [fid, tid, bid], cc)
+    obs_norm_base = normalize_obs(obs_init, norm)
+    t0 = gen_target_at(0)
+    target_cd = np.float32(t0[0] / norm["force_norm_fact"])
+    target_cl = np.float32(t0[1] / norm["force_norm_fact"])
+    obs_norm = np.clip(np.hstack([obs_norm_base, [target_cd, target_cl]]), -1.0, 1.0).astype(np.float32)
+
+    sig_s = np.zeros((num_steps, 6), dtype=np.float32)
+    sig_f = np.zeros((num_steps, 6), dtype=np.float32)
+    sig_a = np.zeros((num_steps, 3), dtype=np.float32)
+
+    for step in range(num_steps):
+        action, _ = model.predict(obs_norm, deterministic=True)
+        action = np.asarray(action, dtype=np.float32).flatten()
+        target_omega = action_to_omega_legacy(action, scale=scale, bias=bias)
+        smoothed = ema(target_omega)
+
+        sim.set_body(fid, omega=smoothed[0]); sim.set_body(tid, omega=smoothed[1]); sim.set_body(bid, omega=smoothed[2])
+        sim.run(SI, zero_obs=True)
+
+        obs = read_obs_6obj(sim, sensor_ids, [fid, tid, bid], cc)
+        sig_s[step] = obs[0:6]
+        sig_f[step] = obs[6:12]
+        sig_a[step] = action
+
+        forces_n = obs[6:12] / norm["force_norm_fact"]
+        sens_n = (obs[0:6] - norm["sens_deviation"]) / norm["sens_norm_fact"]
+        t_h = gen_target_at(step)
+        target_cd = np.float32(t_h[0] / norm["force_norm_fact"])
+        target_cl = np.float32(t_h[1] / norm["force_norm_fact"])
+        obs_norm = np.clip(np.hstack([forces_n, sens_n, [target_cd, target_cl]]), -1.0, 1.0).astype(np.float32)
+
+    save_vorticity(sim, out_dir / "vorticity_controlled.png", [
+        ((ILL_PB_FRONT_X, CENTER_Y), RADIUS),
+        ((ILL_PB_REAR_X, CENTER_Y + 15.0), RADIUS),
+        ((ILL_PB_REAR_X, CENTER_Y - 15.0), RADIUS),
+    ])
+    sim.close()
+
+    np.savez_compressed(out_dir / "signals.npz",
+                        sensors=sig_s, forces=sig_f, actions=sig_a)
+    with open(out_dir / "metrics.json", "w") as f:
+        json.dump({"dtw_sim_v5": -1.0}, f, indent=2)
+    log("  Done.")
+
+
+# ---------------------------------------------------------------------------
+# Vortex
+# ---------------------------------------------------------------------------
+def run_vortex_reproduce(scene: Dict[str, Any], device_id: int, out_dir: Path) -> None:
+    scene_id = scene["scene_id"]
+    vortex_type = scene["vortex_type"]
+    model_name = scene["model_name"]
+    SI = scene["si"]
+    num_steps = scene["num_steps"]
+    scale = scene["action_scale"]
+    bias = scene["action_bias"]
+    vortex_strength = scene["vortex_strength_factor"] * U0
+
+    log(f"=== Reproduce: Vortex {vortex_type} ===")
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    ref_dir = str(SR_DATA / "vortex" / scene_id)
+    norm = load_legacy_norm(ref_dir)
+
+    # Stage 1: Sensors only, record target with vortex at x=10
+    log("  Stage 1: Recording target with vortex...")
+    sim = Simulation(lbm_config_path=scene["config_path"], device_id=device_id)
+    sensor_ids = [
+        sim.add_body("sensor", center=(SENSOR_X, CENTER_Y + 40.0, 0.0), radius=5.0),
+        sim.add_body("sensor", center=(SENSOR_X, CENTER_Y, 0.0), radius=5.0),
+        sim.add_body("sensor", center=(SENSOR_X, CENTER_Y - 40.0, 0.0), radius=5.0),
+    ]
+    sim.initialize()
+    sim.run(WARMUP, zero_obs=True)
+    cc = get_cc(sim, sensor_ids[0])
+    sim.snapshot()
+
+    add_vortex(sim.field, center=(10.0 * L0, CENTER_Y), radius=VORTEX_RADIUS,
+               strength=vortex_strength, vortex_type=vortex_type)
+    target_states = np.zeros((FIFO_LEN, 6), dtype=np.float32)
+    for i in range(FIFO_LEN):
+        sim.run(SI, zero_obs=True)
+        obs = read_obs_6obj(sim, sensor_ids, [], cc)
+        target_states[i] = obs
+    np.savez_compressed(out_dir / "target.npz", target_states=target_states)
+
+    # Stage 2: Add pinball + vortex at x=15
+    log("  Stage 2: Adding pinball + vortex at x=15...")
+    sim.restore()
+    n0 = sim.bodies.count
+    sim.add_body("circle", center=(PB_FRONT_X, CENTER_Y, 0.0), radius=RADIUS)
+    sim.add_body("circle", center=(PB_REAR_X, CENTER_Y + 15.0, 0.0), radius=RADIUS)
+    sim.add_body("circle", center=(PB_REAR_X, CENTER_Y - 15.0, 0.0), radius=RADIUS)
+    sim.sync_bodies()
+    fid, tid, bid = list(range(n0, n0 + 3))
+
+    bias_surf = np.array([0.0, -4.0, 4.0], dtype=np.float32) * U0
+    bias_omega = -bias_surf / RADIUS
+    ema_init = ActionSmoother(weight=0.1); ema_init.reset(np.zeros(3, dtype=np.float32))
+    for _ in range(100):
+        s = ema_init(bias_omega)
+        sim.set_body(fid, omega=s[0]); sim.set_body(tid, omega=s[1]); sim.set_body(bid, omega=s[2])
+        sim.run(SI, zero_obs=True)
+
+    add_vortex(sim.field, center=(15.0 * L0, CENTER_Y), radius=VORTEX_RADIUS,
+               strength=vortex_strength, vortex_type=vortex_type)
+    sim.snapshot()
+
+    # Bias FIFO
+    sim.restore()
+    ema_b = ActionSmoother(weight=0.1); ema_b.reset(np.zeros(3, dtype=np.float32))
+    for _ in range(FIFO_LEN):
+        s = ema_b(bias_omega)
+        sim.set_body(fid, omega=s[0]); sim.set_body(tid, omega=s[1]); sim.set_body(bid, omega=s[2])
+        sim.run(SI, zero_obs=True)
+    sim.snapshot()
+
+    # DRL inference
+    log("  Stage 3: DRL inference...")
+    sim.restore()
+    ema = ActionSmoother(weight=0.1); ema.reset(bias_omega.copy())
+    model = ModelInventory().load(model_name, device="cpu")
+    log(f"  Model: {model_name} on CPU")
+
+    obs_init = read_obs_6obj(sim, sensor_ids, [fid, tid, bid], cc)
+    obs_norm = normalize_obs(obs_init, norm)
+
+    sig_s = np.zeros((num_steps, 6), dtype=np.float32)
+    sig_f = np.zeros((num_steps, 6), dtype=np.float32)
+    sig_a = np.zeros((num_steps, 3), dtype=np.float32)
+
+    for step in range(num_steps):
+        action, _ = model.predict(obs_norm, deterministic=True)
+        action = np.asarray(action, dtype=np.float32).flatten()
+        target_omega = action_to_omega_legacy(action, scale=scale, bias=bias)
+        smoothed = ema(target_omega)
+
+        sim.set_body(fid, omega=smoothed[0]); sim.set_body(tid, omega=smoothed[1]); sim.set_body(bid, omega=smoothed[2])
+        sim.run(SI, zero_obs=True)
+
+        obs = read_obs_6obj(sim, sensor_ids, [fid, tid, bid], cc)
+        sig_s[step] = obs[0:6]
+        sig_f[step] = obs[6:12]
+        sig_a[step] = action
+        forces_n = obs[6:12] / norm["force_norm_fact"]
+        sens_n = (obs[0:6] - norm["sens_deviation"]) / norm["sens_norm_fact"]
+        obs_norm = np.clip(np.hstack([forces_n, sens_n]), -1.0, 1.0).astype(np.float32)
+
+    save_vorticity(sim, out_dir / "vorticity_controlled.png", [
+        ((PB_FRONT_X, CENTER_Y), RADIUS),
+        ((PB_REAR_X, CENTER_Y + 15.0), RADIUS),
+        ((PB_REAR_X, CENTER_Y - 15.0), RADIUS),
+    ])
+    sim.close()
+
+    np.savez_compressed(out_dir / "signals.npz",
+                        sensors=sig_s, forces=sig_f, actions=sig_a)
+    with open(out_dir / "metrics.json", "w") as f:
+        json.dump({"dtw_sim_v5": -1.0}, f, indent=2)
+    log("  Done.")
+
+
+# ---------------------------------------------------------------------------
+# Scene dispatcher
+# ---------------------------------------------------------------------------
+SCENE_RUNNERS = {
+    "karman_cloak": run_karman_reproduce,
+    "steady_cloak": run_steady_reproduce,
+    "illusion_075L": run_illusion_reproduce,
+    "illusion_1L": run_illusion_reproduce,
+    "illusion_15L": run_illusion_reproduce,
+    "vortex_lamb": run_vortex_reproduce,
+    "vortex_taylor": run_vortex_reproduce,
+}
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Evaluate reproduce models")
+    parser.add_argument("--device-id", type=int, default=1)
+    parser.add_argument("--scene", type=str, default=None,
+                        help="Run single scene (e.g. karman_cloak, illusion_1L)")
+    args = parser.parse_args()
+
+    log(f"GPU: {args.device_id}")
+
+    scenes = REPRODUCE_SCENES
+    if args.scene:
+        key = args.scene
+        scenes = [s for s in REPRODUCE_SCENES if s["scene_id"] == key]
+        if not scenes:
+            log(f"ERROR: No scene matching '{args.scene}'")
+            return 1
+
+    for scene in scenes:
+        scene_id = scene["scene_id"]
+        out_dir = _OUT_BASE / scene_id
+        runner = SCENE_RUNNERS.get(scene_id)
+        if runner is None:
+            log(f"WARNING: No runner for scene {scene_id}, skipping.")
+            continue
+        runner(scene, args.device_id, out_dir)
+
+    log("All reproduce scenes complete.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

src/drl_pinball/eval/infer_train.py

@@ -0,0 +1,472 @@
+#!/usr/bin/env python3
+"""V5 Train model inference engine — skeleton injection with per-seed VecNormalize.
+
+For each scene in TRAIN_SCENES:
+  1. Create V5 CFD env (KarmanCloakEnv / IllusionCloakEnv)
+  2. For every seed: fresh skeleton + VecNormalize.load(seed.pkl) + weight injection
+  3. 360-step deterministic rollout, pick best by tail-180 reward
+  4. Save signals.npz + vorticity PNGs (controlled, target, zero)
+
+Uses skeleton injection per-seed (one skeleton per seed, one VecNormalize load per seed)
+to avoid cloudpickle/numpy PPO.load() deserialization issues while still using
+trained VecNormalize stats for proper observation normalization.
+
+Usage:
+    conda run -n pycuda_3_10 python -u infer_train.py --device-id 0
+    conda run -n pycuda_3_10 python -u infer_train.py --device-id 0 --scene re100
+"""
+from __future__ import annotations
+
+import argparse
+import io
+import json
+import os
+import sys
+import time
+import zipfile
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+import numpy as np
+import pycuda.driver as cuda; cuda.init()
+
+_REPO = str(Path(__file__).resolve().parents[3])
+_SRC = Path(_REPO) / "src"
+for p in [_REPO, str(_SRC)]:
+    if p not in sys.path:
+        sys.path.insert(0, p)
+
+import torch
+from torch.nn import Module as TorchModule
+from stable_baselines3 import PPO
+from stable_baselines3.common.vec_env import DummyVecEnv, VecNormalize
+
+from CelerisLab.common.render import compute_vorticity, render_vorticity_field
+
+_TRAIN_DIR = _SRC / "drl_pinball" / "train"
+sys.path.insert(0, str(_TRAIN_DIR))
+
+from symmetry_wrapper import SymmetryAugmentWrapper
+
+from drl_pinball.eval.scene_manifest import TRAIN_SCENES
+
+_OUT_BASE = Path(__file__).resolve().parent / "output" / "train"
+
+
+class Sin(TorchModule):
+    def __init__(self): super().__init__()
+    def forward(self, x): return torch.sin(x)
+
+
+_device = None  # set at startup
+
+
+def log(msg: str) -> None:
+    print(f"[{time.strftime('%H:%M:%S')}] {msg}", flush=True)
+
+
+# ---------------------------------------------------------------------------
+# Env creation
+# ---------------------------------------------------------------------------
+def _create_env(scene: Dict[str, Any], device_id: int):
+    scene_type = scene["scene_type"]
+    config_path = Path(scene["config_path"]).resolve()
+    cal_path = Path(scene["calibration_path"]).resolve()
+    si = scene["si"]
+
+    with open(cal_path) as f:
+        cal = json.load(f)
+    cal["SI"] = si
+
+    cal_dir = cal_path.parent
+    target_path = cal_dir / "target.npy"
+    if not target_path.exists():
+        raise FileNotFoundError(f"target.npy not found at {target_path}")
+    target_states = np.load(str(target_path))
+
+    if scene_type == "karman":
+        from env_karman import KarmanCloakEnv
+        log(f"  Creating KarmanCloakEnv (config={config_path.name}, SI={si})...")
+        t0 = time.perf_counter()
+        env = KarmanCloakEnv(
+            device_id=device_id, seed=41,
+            calibration=cal, config_path=str(config_path),
+            target_states=target_states,
+        )
+        log(f"  Env ready in {time.perf_counter() - t0:.0f}s")
+        return env
+    elif scene_type == "illusion":
+        from env_illusion import IllusionCloakEnv
+        target_harmonics_path = cal_dir / "target_harmonics.json"
+        if not target_harmonics_path.exists():
+            raise FileNotFoundError(f"target_harmonics.json not found at {target_harmonics_path}")
+        with open(target_harmonics_path) as f:
+            target_harmonics = json.load(f)
+        target_diam = float(scene.get("target_diam", 1.0))
+        cal["target_diam"] = target_diam
+        log(f"  Creating IllusionCloakEnv (config={config_path.name}, diam={target_diam}L, SI={si})...")
+        t0 = time.perf_counter()
+        env = IllusionCloakEnv(
+            device_id=device_id, seed=41,
+            calibration=cal, config_path=str(config_path),
+            target_states=target_states,
+            target_harmonics=target_harmonics,
+            target_diam=target_diam,
+        )
+        log(f"  Env ready in {time.perf_counter() - t0:.0f}s")
+        return env
+    else:
+        raise ValueError(f"Unknown scene_type: {scene_type}")
+
+
+# ---------------------------------------------------------------------------
+# Extract policy weights from SB3 .zip
+# ---------------------------------------------------------------------------
+def _extract_state_dict(zip_path: str) -> dict:
+    with zipfile.ZipFile(zip_path, "r") as zf:
+        with zf.open("policy.pth") as f:
+            return torch.load(io.BytesIO(f.read()), map_location="cpu",
+                              weights_only=False)
+
+
+# ---------------------------------------------------------------------------
+# Raw env extraction (walk wrapper chain)
+# ---------------------------------------------------------------------------
+def _get_raw_env(vec_env):
+    dummy = vec_env.venv
+    inner = dummy.envs[0]
+    if hasattr(inner, 'prob'):
+        return inner.env
+    return inner
+
+
+# ---------------------------------------------------------------------------
+# Saving
+# ---------------------------------------------------------------------------
+def _save_vorticity(env, out_path: Path, scene: Dict[str, Any]) -> None:
+    sim = env.sim
+    macro = sim.get_macroscopic()
+    vort = compute_vorticity(macro["ux"], macro["uy"])
+    nx = int(sim.lbm_cfg.nx)
+    ny = int(sim.lbm_cfg.ny)
+    cylinders = []
+    for body_id in range(sim.bodies.count):
+        body = sim.bodies.get(body_id)
+        if hasattr(body, 'center'):
+            c = body.center
+            r = body.radius if hasattr(body, 'radius') else 10.0
+            cylinders.append(((c[0], c[1]), r))
+    render_vorticity_field(vort, nx=nx, ny=ny, out_path=str(out_path),
+                           cylinders=cylinders, vmin=-0.03, vmax=0.03)
+
+
+# ---------------------------------------------------------------------------
+# Per-seed eval — correct pattern: PPO.load(no env) + VecNormalize(env, training=False)
+# ---------------------------------------------------------------------------
+def _eval_one_seed(env, seed_label: str, seed_dir_str: str,
+                   num_steps: int) -> Dict[str, Any]:
+    """Load model WITHOUT env, wrap env with VecNormalize.load (single layer, frozen)."""
+    seed_dir = Path(seed_dir_str)
+    model_path = seed_dir / "best_model.zip"
+    norm_path = seed_dir.parent / "vec_normalize.pkl"
+
+    if not model_path.exists():
+        log(f"    [seed {seed_label}] SKIP: no best_model.zip")
+        return {"seed": seed_label, "avg_reward": -float("inf"), "skip": True}
+    if not norm_path.exists():
+        log(f"    [seed {seed_label}] SKIP: no vec_normalize.pkl")
+        return {"seed": seed_label, "avg_reward": -float("inf"), "skip": True}
+
+    log(f"    [seed {seed_label}] loading...")
+
+    # All seeds: PPO.load fails (numpy._core.numeric cloudpickle issue).
+    # Use skeleton injection directly — avoids GPU pollution from failed load.
+    wrapped = SymmetryAugmentWrapper(env, prob=0.0, seed=41, rollout_len=2048)
+    vec_env = DummyVecEnv([lambda: wrapped])
+    vec_env = VecNormalize.load(str(norm_path), vec_env)
+    vec_env.norm_reward = False
+
+    skeleton = PPO(
+        "MlpPolicy",
+        policy_kwargs={"activation_fn": Sin, "net_arch": [64, 64]},
+        env=vec_env, device=_device,
+        n_steps=2048, batch_size=64, n_epochs=10,
+        learning_rate=3e-4, gamma=0.995, verbose=0,
+    )
+    sd = _extract_state_dict(str(model_path))
+    skeleton.policy.load_state_dict(sd, strict=False)
+
+    raw_env = _get_raw_env(vec_env)
+    sens_cc = float(raw_env._cal.get("SENSOR_CC", 78.0))
+    return _rollout(skeleton, vec_env, raw_env, sens_cc, seed_label, num_steps)
+
+
+def _rollout(model, vec_env, raw_env, sens_cc, seed_label, num_steps):
+    """Deterministic rollout, model.predict receives normalized obs from vec_env."""
+    ep_rew, ep_r_cd, ep_r_cl, ep_r_sim, ep_sim_raw = [], [], [], [], []
+    sig_s, sig_f, sig_a = [], [], []
+    obs = vec_env.reset()
+
+    for step in range(num_steps):
+        action, _ = model.predict(obs, deterministic=True)
+        obs, reward, done, info = vec_env.step(action)
+
+        inf = info[0] if isinstance(info, list) else info
+        ep_rew.append(float(reward[0]))
+        ep_r_cd.append(float(inf.get("r_cd", 0)))
+        ep_r_cl.append(float(inf.get("r_cl", 0)))
+        ep_r_sim.append(float(inf.get("r_sim", 0)))
+        ep_sim_raw.append(float(inf.get("sim", 0)))
+
+        try:
+            raw = raw_env._read_obs()
+            if "Karman" in type(raw_env).__name__:
+                sl = raw[2:14]
+            else:
+                sl = raw[:]
+            sig_s.append(sl[0:6] * sens_cc)
+            sig_f.append(sl[6:12])
+        except Exception:
+            sig_s.append(np.zeros(6, dtype=np.float32))
+            sig_f.append(np.zeros(6, dtype=np.float32))
+        sig_a.append(np.asarray(action, dtype=np.float32).flatten())
+        if done[0]:
+            break
+
+    tail = 180
+    sl = slice(-tail, None) if len(ep_rew) >= tail else slice(None)
+    avg_r = float(np.mean(ep_rew[sl]))
+
+    log(f"      reward={avg_r:.4f}  r_cd={float(np.mean(ep_r_cd[sl])):.3f}  "
+        f"r_cl={float(np.mean(ep_r_cl[sl])):.3f}  "
+        f"r_sim={float(np.mean(ep_r_sim[sl])):.3f}  "
+        f"sim_raw={float(np.mean(ep_sim_raw[sl])):.3f}")
+
+    return {
+        "seed": seed_label,
+        "avg_reward": avg_r,
+        "r_cd": float(np.mean(ep_r_cd[sl])), "r_cl": float(np.mean(ep_r_cl[sl])),
+        "r_sim": float(np.mean(ep_r_sim[sl])),
+        "sim_raw": float(np.mean(ep_sim_raw[sl])),
+        "sensors": np.array(sig_s, dtype=np.float32),
+        "forces": np.array(sig_f, dtype=np.float32),
+        "actions": np.array(sig_a, dtype=np.float32),
+        "rewards": np.array(ep_rew, dtype=np.float32),
+        "skip": False,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Per-scene pipeline
+# ---------------------------------------------------------------------------
+def evaluate_train_scene(scene: Dict[str, Any], device_id: int) -> None:
+    scene_id = scene["scene_id"]
+    num_steps = scene["num_steps"]
+    out_dir = _OUT_BASE / scene_id
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    log(f"\n{'='*70}")
+    log(f"  Train eval: {scene_id}  (SI={scene['si']}, steps={num_steps})")
+    log(f"{'='*70}")
+
+    # Create CFD env once, reused across seeds
+    env = _create_env(scene, device_id)
+
+    # Evaluate each seed (independent skeleton + VecNormalize per seed)
+    all_results = []
+    for seed_label, seed_dir in scene["seeds"]:
+        t0 = time.perf_counter()
+        result = _eval_one_seed(env, seed_label, seed_dir, num_steps)
+        result["_dt"] = time.perf_counter() - t0
+        all_results.append(result)
+
+    # Pick best seed
+    valid = [r for r in all_results if not r.get("skip", False)]
+    if not valid:
+        log("  WARNING: No valid seeds found, skipping scene.")
+        env.close()
+        return
+    best = max(valid, key=lambda r: r["avg_reward"])
+    log(f"  Best: seed={best['seed']}, reward={best['avg_reward']:.4f}")
+
+    # Save all-seeds summary
+    summary = [{"seed": r["seed"], "reward": r["avg_reward"],
+                "r_cd": r.get("r_cd", 0), "r_cl": r.get("r_cl", 0),
+                "r_sim": r.get("r_sim", 0), "sim_raw": r.get("sim_raw", 0),
+                "dt_sec": r.get("_dt", 0)} for r in all_results]
+    with open(out_dir / "all_seeds.json", "w") as f:
+        json.dump(summary, f, indent=2)
+
+    # Save best seed's full signals
+    np.savez_compressed(out_dir / "signals.npz",
+                        sensors=best["sensors"], forces=best["forces"],
+                        actions=best["actions"], rewards=best["rewards"])
+
+    # Vorticity: re-create env, load best seed skeleton, run, capture
+    log("  Generating vorticity for best seed...")
+    env2 = _create_env(scene, device_id)
+    seed_dir = Path(next(s[1] for s in scene["seeds"] if s[0] == best["seed"]))
+    norm_path = seed_dir.parent / "vec_normalize.pkl"
+    model_path = seed_dir / "best_model.zip"
+
+    wrapped2 = SymmetryAugmentWrapper(env2, prob=0.0, seed=41, rollout_len=2048)
+    vec_env2 = DummyVecEnv([lambda: wrapped2])
+    vec_env2 = VecNormalize.load(str(norm_path), vec_env2)
+    vec_env2.norm_reward = False
+    skeleton2 = PPO(
+        "MlpPolicy",
+        policy_kwargs={"activation_fn": Sin, "net_arch": [64, 64]},
+        env=vec_env2, device=_device,
+        n_steps=2048, batch_size=64, n_epochs=10,
+        learning_rate=3e-4, gamma=0.995, verbose=0,
+    )
+    sd = _extract_state_dict(str(model_path))
+    skeleton2.policy.load_state_dict(sd, strict=False)
+
+    obs = vec_env2.reset()
+    for _ in range(num_steps):
+        action, _ = skeleton2.predict(obs, deterministic=True)
+        obs, reward, done, info = vec_env2.step(action)
+        if done[0]:
+            break
+    _save_vorticity(env2, out_dir / "vorticity_controlled.png", scene)
+    env2.close()
+
+    # Target vorticity
+    log("  Generating target vorticity...")
+    _generate_target_vorticity(scene, device_id, out_dir)
+
+    # Zero-action baseline
+    log("  Generating zero-action baseline...")
+    env3 = _create_env(scene, device_id)
+    zero_omega = env3._action_to_omega(np.zeros(3, dtype=np.float32))
+    for _ in range(num_steps):
+        smoothed = env3.smoother(zero_omega)
+        env3._set_omega(smoothed)
+        env3._gpu_block(lambda: env3.sim.run(scene["si"], zero_obs=True))
+    _save_vorticity(env3, out_dir / "vorticity_zero.png", scene)
+    env3.close()
+
+    # Metrics
+    metrics = {
+        "best_seed": best["seed"],
+        "dtw_sim_v5": float(best.get("sim_raw", 0)),
+        "reward_mean": float(best["avg_reward"]),
+        "r_cd_mean": float(best.get("r_cd", 0)),
+        "r_cl_mean": float(best.get("r_cl", 0)),
+        "r_sim_mean": float(best.get("r_sim", 0)),
+        "sim_raw_mean": float(best.get("sim_raw", 0)),
+        "aF_mean": float(np.mean(best["actions"][:, 0])),
+        "aB_mean": float(np.mean(best["actions"][:, 1])),
+        "aT_mean": float(np.mean(best["actions"][:, 2])),
+    }
+    with open(out_dir / "metrics.json", "w") as f:
+        json.dump(metrics, f, indent=2)
+
+    env.close()
+    log(f"  {scene_id} complete.")
+
+
+def _generate_target_vorticity(scene: Dict[str, Any], device_id: int,
+                                out_dir: Path) -> None:
+    from CelerisLab import Simulation
+
+    scene_type = scene["scene_type"]
+    config_path = Path(scene["config_path"]).resolve()
+    si = scene["si"]
+    warmup = int(4.0 * 2000 / 0.01)
+    L0 = 20.0
+    U0 = 0.01
+
+    sim = Simulation(lbm_config_path=str(config_path), device_id=device_id)
+
+    if scene_type == "karman":
+        with open(scene["calibration_path"]) as f:
+            cal = json.load(f)
+        dist_radius = float(cal.get("dist_radius", 1.0)) * L0
+        nx_cfg = int(cal.get("grid", {}).get("nx", 2000))
+        ny_cfg = int(cal.get("grid", {}).get("ny", 600))
+        CENTER_Y = float(ny_cfg - 1) / 2.0
+        DIST_X = 600.0
+        SENS_X = 1200.0
+
+        sim.add_body("circle", center=(DIST_X, CENTER_Y, 0.0), radius=dist_radius)
+        sim.add_body("sensor", center=(SENS_X, CENTER_Y + 40.0, 0.0), radius=5.0)
+        sim.add_body("sensor", center=(SENS_X, CENTER_Y, 0.0), radius=5.0)
+        sim.add_body("sensor", center=(SENS_X, CENTER_Y - 40.0, 0.0), radius=5.0)
+    elif scene_type == "illusion":
+        with open(scene["calibration_path"]) as f:
+            cal = json.load(f)
+        target_diam = float(scene.get("target_diam", 1.0))
+        nx_cfg = int(cal.get("grid", {}).get("nx", 2000))
+        ny_cfg = int(cal.get("grid", {}).get("ny", 600))
+        CENTER_Y = float(ny_cfg - 1) / 2.0
+        TARGET_X = 400.0
+        SENS_X = 600.0
+
+        sim.add_body("circle", center=(TARGET_X, CENTER_Y, 0.0), radius=target_diam * L0)
+        sim.add_body("sensor", center=(SENS_X, CENTER_Y + 40.0, 0.0), radius=5.0)
+        sim.add_body("sensor", center=(SENS_X, CENTER_Y, 0.0), radius=5.0)
+        sim.add_body("sensor", center=(SENS_X, CENTER_Y - 40.0, 0.0), radius=5.0)
+    else:
+        sim.close()
+        return
+
+    sim.initialize()
+    sim.run(warmup, zero_obs=True)
+    for _ in range(30):
+        sim.run(si, zero_obs=True)
+
+    macro = sim.get_macroscopic()
+    vort = compute_vorticity(macro["ux"], macro["uy"])
+    cylinders = [
+        ((ctr[0], ctr[1]), rad)
+        for body in [sim.bodies.get(i) for i in range(sim.bodies.count)]
+        if hasattr(body, 'center')
+        for ctr, rad in [((body.center[0], body.center[1]),
+                          body.radius if hasattr(body, 'radius') else 10.0)]
+    ]
+    render_vorticity_field(vort, nx=nx_cfg, ny=ny_cfg,
+                           out_path=str(out_dir / "vorticity_target.png"),
+                           cylinders=cylinders, vmin=-0.03, vmax=0.03)
+    sim.close()
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+def main() -> int:
+    global _device
+    parser = argparse.ArgumentParser(description="Evaluate V5 train models")
+    parser.add_argument("--device-id", type=int, default=0)
+    parser.add_argument("--scene", type=str, default=None)
+    args = parser.parse_args()
+
+    _device = torch.device(f"cuda:{args.device_id}")
+    log(f"GPU: {args.device_id}, torch device: {_device}")
+
+    scenes = TRAIN_SCENES
+    if args.scene:
+        key = args.scene
+        scenes = [s for s in TRAIN_SCENES if s["scene_id"] == key
+                  or s["scene_id"].startswith(key)]
+        if not scenes:
+            log(f"ERROR: No scene matching '{args.scene}'")
+            return 1
+
+    for i, scene in enumerate(scenes):
+        if i > 0:
+            prev_cfg = scenes[i - 1]["config_path"]
+            curr_cfg = scene["config_path"]
+            if prev_cfg != curr_cfg:
+                log(f"Waiting 120s before config switch...")
+                time.sleep(120)
+
+        evaluate_train_scene(scene, args.device_id)
+
+    log("All train scenes complete.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

src/drl_pinball/eval/run_all.sh

@@ -0,0 +1,126 @@
+#!/bin/bash
+# run_all.sh — Master launcher for eval benchmark.
+#
+# GPU 0: Train pipeline (7 scenes)
+# GPU 1: Reproduce pipeline (7 scenes, 120s stagger)
+#
+# Each pipeline saves outputs to eval/output/{train,reproduce}/.
+# After both complete, run generate_report.py and viz_*.py.
+#
+# Usage:
+#   conda activate pycuda_3_10
+#   bash run_all.sh
+#
+# Single scene mode:
+#   bash run_all.sh --train-scene re100 --gpu 0
+#   bash run_all.sh --repro-scene karman_cloak --gpu 1
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_DIR="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+TRAIN_SCRIPT="$SCRIPT_DIR/infer_train.py"
+REPRO_SCRIPT="$SCRIPT_DIR/infer_reproduce.py"
+CONDA_ENV="pycuda_3_10"
+
+TRAIN_GPU=0
+REPRO_GPU=1
+TRAIN_SCENE=""
+REPRO_SCENE=""
+
+usage() {
+    echo "Usage: $0 [--train-scene SCENE] [--repro-scene SCENE] [--gpu N]"
+    echo "  --train-scene  Run single train scene (e.g. re100, illusion_1L)"
+    echo "  --repro-scene  Run single reproduce scene (e.g. karman_cloak)"
+    echo "  --gpu          GPU device ID"
+    exit 1
+}
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --train-scene) TRAIN_SCENE="$2"; shift 2 ;;
+        --repro-scene) REPRO_SCENE="$2"; shift 2 ;;
+        --gpu)         TRAIN_GPU="$2"; REPRO_GPU="$2"; shift 2 ;;
+        *)             echo "Unknown option: $1"; usage ;;
+    esac
+done
+
+# Create output dirs
+mkdir -p "$SCRIPT_DIR/output/train"
+mkdir -p "$SCRIPT_DIR/output/reproduce"
+
+echo "=== Eval Benchmark ==="
+echo "  Train GPU:  $TRAIN_GPU"
+echo "  Reproduce GPU: $REPRO_GPU"
+echo "  Conda env:  $CONDA_ENV"
+echo "  Script dir: $SCRIPT_DIR"
+echo ""
+
+# ---------------------------------------------------------------------------
+# Launch Reproduce pipeline (GPU 1, staggered)
+# ---------------------------------------------------------------------------
+launch_reproduce() {
+    echo "[$(date '+%H:%M:%S')] Launching Reproduce pipeline on GPU $REPRO_GPU..."
+    local arg=""
+    if [[ -n "$REPRO_SCENE" ]]; then
+        arg="--scene $REPRO_SCENE"
+    fi
+    conda run --no-capture-output -n "$CONDA_ENV" python -u \
+        "$REPRO_SCRIPT" --device-id "$REPRO_GPU" $arg \
+        2>&1 | tee "$SCRIPT_DIR/output/reproduce/run.log"
+    echo "[$(date '+%H:%M:%S')] Reproduce pipeline complete."
+}
+
+# Start reproduce after 120s delay (avoids kernel compilation race with GPU 0)
+if [[ -z "$TRAIN_SCENE" ]] && [[ -z "$REPRO_SCENE" ]]; then
+    # Full run: launch reproduce in background with delay
+    (sleep 120 && launch_reproduce) &
+    REPRO_PID=$!
+    echo "  Reproduce scheduled in 120s (PID=$REPRO_PID)"
+else
+    # Single scene mode: just run the requested pipeline
+    if [[ -n "$REPRO_SCENE" ]]; then
+        launch_reproduce
+        exit 0
+    fi
+fi
+
+# ---------------------------------------------------------------------------
+# Train pipeline (GPU 0)
+# ---------------------------------------------------------------------------
+echo "[$(date '+%H:%M:%S')] Launching Train pipeline on GPU $TRAIN_GPU..."
+TRAIN_ARG=""
+if [[ -n "$TRAIN_SCENE" ]]; then
+    TRAIN_ARG="--scene $TRAIN_SCENE"
+fi
+conda run --no-capture-output -n "$CONDA_ENV" python -u \
+    "$TRAIN_SCRIPT" --device-id "$TRAIN_GPU" $TRAIN_ARG \
+    2>&1 | tee "$SCRIPT_DIR/output/train/run.log"
+echo "[$(date '+%H:%M:%S')] Train pipeline complete."
+
+# Wait for reproduce if it was launched
+if [[ -n "${REPRO_PID:-}" ]]; then
+    echo "[$(date '+%H:%M:%S')] Waiting for Reproduce pipeline (PID=$REPRO_PID)..."
+    wait $REPRO_PID
+fi
+
+# ---------------------------------------------------------------------------
+# Generate reports
+# ---------------------------------------------------------------------------
+echo ""
+echo "[$(date '+%H:%M:%S')] Both pipelines complete. Generating reports..."
+
+echo "  -> Signal plots..."
+conda run --no-capture-output -n "$CONDA_ENV" python -u \
+    "$SCRIPT_DIR/viz_signals.py" 2>&1 | tail -5
+
+echo "  -> Vorticity panels..."
+conda run --no-capture-output -n "$CONDA_ENV" python -u \
+    "$SCRIPT_DIR/viz_flow.py" 2>&1 | tail -5
+
+echo "  -> Summary report..."
+conda run --no-capture-output -n "$CONDA_ENV" python -u \
+    "$SCRIPT_DIR/generate_report.py" 2>&1 | tail -10
+
+echo ""
+echo "=== ALL DONE ==="
+echo "Reports in: $SCRIPT_DIR/output/reports/"

src/drl_pinball/eval/scene_manifest.py

@@ -0,0 +1,271 @@
+"""Scene manifest — single source of truth for all benchmark scenes.
+
+Two pipelines:
+  TRAIN_SCENES — V5 PPO models on new 2000x600 config (uniform, free-slip).
+  REPRODUCE_SCENES — legacy PPO models on old 1280x512 config (parabolic, bounce-back).
+
+Usage:
+    from eval.scene_manifest import TRAIN_SCENES, REPRODUCE_SCENES
+
+Each scene dict contains:
+    scene_id, config_path, calibration_path, si, num_steps, scene_type
+    seeds: list of (seed_label, model_dir) tuples
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any, Dict, List
+
+_REPO = Path(__file__).resolve().parents[3]
+_TRAIN_DIR = _REPO / "src" / "drl_pinball" / "train"
+_CONFIGS_DIR = _REPO / "configs"
+
+KARMAN_CFG = str(_CONFIGS_DIR / "config_lbm_karman_2000x600.json")
+KARMAN_CFG_RE60 = str(_CONFIGS_DIR / "config_lbm_karman_2000x600_re60.json")
+KARMAN_CFG_RE200 = str(_CONFIGS_DIR / "config_lbm_karman_2000x600_re200.json")
+KARMAN_CFG_RE400 = str(_CONFIGS_DIR / "config_lbm_karman_2000x600_re400.json")
+PINBALL_CFG = str(_CONFIGS_DIR / "config_lbm_pinball.json")
+
+
+def _model_dir(case_name: str, seed: int) -> str:
+    """Path to model output directory for a trained case."""
+    return str(_TRAIN_DIR / "output" / f"{case_name}_seed{seed}" / "models")
+
+
+def _cal_path(name: str) -> str:
+    return str(_TRAIN_DIR / "calibrations" / name / "calibration.json")
+
+
+# =============================================================================
+# TRAIN SCENES (V5 PPO, 2000x600)
+#
+# Cloud naming: {kar|ill}_{case}_{sc|tr}_seed{N}
+#   sc = scratch, tr = transfer
+# =============================================================================
+TRAIN_SCENES: List[Dict[str, Any]] = [
+    # -- Karman Cloak Re100 scratch (5 seeds, best model) --
+    {
+        "scene_id": "kar_re100_sc",
+        "config_path": KARMAN_CFG,
+        "calibration_path": _cal_path("kar_re100"),
+        "si": 800,
+        "num_steps": 360,
+        "scene_type": "karman",
+        "seeds": [
+            ("41", _model_dir("kar_re100_sc", 41)),
+            ("42", _model_dir("kar_re100_sc", 42)),
+            ("43", _model_dir("kar_re100_sc", 43)),
+            ("44", _model_dir("kar_re100_sc", 44)),
+            ("45", _model_dir("kar_re100_sc", 45)),
+        ],
+    },
+    # -- Cross-Re Re60 scratch + transfer --
+    {
+        "scene_id": "kar_re60_tr",
+        "config_path": KARMAN_CFG_RE60,
+        "calibration_path": _cal_path("kar_re60"),
+        "si": 800,
+        "num_steps": 360,
+        "scene_type": "karman",
+        "seeds": [
+            ("43", _model_dir("kar_re60_tr", 43)),
+        ],
+    },
+    # -- Cross-Re Re200 scratch + transfer --
+    {
+        "scene_id": "kar_re200_tr",
+        "config_path": KARMAN_CFG_RE200,
+        "calibration_path": _cal_path("kar_re200"),
+        "si": 500,
+        "num_steps": 360,
+        "scene_type": "karman",
+        "seeds": [
+            ("43", _model_dir("kar_re200_tr", 43)),
+        ],
+    },
+    # -- Cross-Re Re400 scratch + transfer --
+    {
+        "scene_id": "kar_re400_tr",
+        "config_path": KARMAN_CFG_RE400,
+        "calibration_path": _cal_path("kar_re400"),
+        "si": 400,
+        "num_steps": 360,
+        "scene_type": "karman",
+        "seeds": [
+            ("43", _model_dir("kar_re400_tr", 43)),
+        ],
+    },
+    # -- VarDist d075 scratch --
+    {
+        "scene_id": "kar_d075_sc",
+        "config_path": KARMAN_CFG,
+        "calibration_path": _cal_path("kar_d075_sc"),
+        "si": 800,
+        "num_steps": 360,
+        "scene_type": "karman",
+        "seeds": [
+            ("44", _model_dir("kar_d075_sc", 44)),
+        ],
+    },
+    # -- VarDist d15 scratch --
+    {
+        "scene_id": "kar_d15_sc",
+        "config_path": KARMAN_CFG,
+        "calibration_path": _cal_path("kar_d15_sc"),
+        "si": 800,
+        "num_steps": 360,
+        "scene_type": "karman",
+        "seeds": [
+            ("45", _model_dir("kar_d15_sc", 45)),
+        ],
+    },
+    # -- VarDist d2 scratch --
+    {
+        "scene_id": "kar_d2_sc",
+        "config_path": KARMAN_CFG,
+        "calibration_path": _cal_path("kar_d2_sc"),
+        "si": 800,
+        "num_steps": 360,
+        "scene_type": "karman",
+        "seeds": [
+            ("45", _model_dir("kar_d2_sc", 45)),
+        ],
+    },
+    # -- Illusion 0.75L scratch --
+    {
+        "scene_id": "ill_075L_sc",
+        "config_path": KARMAN_CFG,
+        "calibration_path": _cal_path("ill_075L"),
+        "si": 400,
+        "num_steps": 360,
+        "scene_type": "illusion",
+        "target_diam": 0.75,
+        "seeds": [
+            ("43", _model_dir("ill_075L_sc", 43)),
+        ],
+    },
+    # -- Illusion 1.0L scratch --
+    {
+        "scene_id": "ill_1L_sc",
+        "config_path": KARMAN_CFG,
+        "calibration_path": _cal_path("ill_1L"),
+        "si": 600,
+        "num_steps": 360,
+        "scene_type": "illusion",
+        "target_diam": 1.0,
+        "seeds": [
+            ("43", _model_dir("ill_1L_sc", 43)),
+        ],
+    },
+    # -- Illusion 1.5L scratch --
+    {
+        "scene_id": "ill_15L_sc",
+        "config_path": KARMAN_CFG,
+        "calibration_path": _cal_path("ill_15L"),
+        "si": 800,
+        "num_steps": 360,
+        "scene_type": "illusion",
+        "target_diam": 1.5,
+        "seeds": [
+            ("43", _model_dir("ill_15L_sc", 43)),
+        ],
+    },
+    # -- Illusion 2.0L scratch (new!) --
+    {
+        "scene_id": "ill_2L_sc",
+        "config_path": KARMAN_CFG,
+        "calibration_path": _cal_path("ill_2L"),
+        "si": 800,
+        "num_steps": 360,
+        "scene_type": "illusion",
+        "target_diam": 2.0,
+        "seeds": [
+            ("43", _model_dir("ill_2L_sc", 43)),
+        ],
+    },
+]
+
+# =============================================================================
+# REPRODUCE SCENES (legacy PPO, 1280x512)
+# =============================================================================
+REPRODUCE_SCENES: List[Dict[str, Any]] = [
+    {
+        "scene_id": "karman_cloak",
+        "config_path": PINBALL_CFG,
+        "si": 800,
+        "num_steps": 200,
+        "scene_type": "karman",
+        "model_name": "d1a3o12_re100",
+        "action_scale": 8.0,
+        "action_bias": (0.0, -4.0, 4.0),
+    },
+    {
+        "scene_id": "steady_cloak",
+        "config_path": PINBALL_CFG,
+        "si": 800,
+        "num_steps": 200,
+        "scene_type": "steady",
+        "model_name": None,  # open-loop [0, -5.1, 5.1]*U0
+        "action_scale": 8.0,
+        "action_bias": (0.0, -4.0, 4.0),
+        "open_loop_surf_vel": (0.0, -5.1, 5.1),
+    },
+    {
+        "scene_id": "illusion_075L",
+        "config_path": PINBALL_CFG,
+        "si": 400,
+        "num_steps": 200,
+        "scene_type": "illusion",
+        "model_name": "d1a3o14_250525_imit_075L_2U_400S",
+        "action_scale": 8.0,
+        "action_bias": (0.0, -2.0, 2.0),
+        "target_diam": 0.75,
+    },
+    {
+        "scene_id": "illusion_1L",
+        "config_path": PINBALL_CFG,
+        "si": 600,
+        "num_steps": 200,
+        "scene_type": "illusion",
+        "model_name": "d1a3o14_250525_imit_1L_2U_600S",
+        "action_scale": 8.0,
+        "action_bias": (0.0, -2.0, 2.0),
+        "target_diam": 1.0,
+    },
+    {
+        "scene_id": "illusion_15L",
+        "config_path": PINBALL_CFG,
+        "si": 800,
+        "num_steps": 200,
+        "scene_type": "illusion",
+        "model_name": "d1a3o14_250525_imit_15L_2U",
+        "action_scale": 8.0,
+        "action_bias": (0.0, -2.0, 2.0),
+        "target_diam": 1.5,
+    },
+    {
+        "scene_id": "vortex_lamb",
+        "config_path": PINBALL_CFG,
+        "si": 800,
+        "num_steps": 150,
+        "scene_type": "vortex",
+        "model_name": "vortex_lamb",
+        "action_scale": 4.0,
+        "action_bias": (0.0, -4.0, 4.0),
+        "vortex_type": "lamb",
+        "vortex_strength_factor": 0.5,
+    },
+    {
+        "scene_id": "vortex_taylor",
+        "config_path": PINBALL_CFG,
+        "si": 800,
+        "num_steps": 150,
+        "scene_type": "vortex",
+        "model_name": "vortex_taylor",
+        "action_scale": 4.0,
+        "action_bias": (0.0, -4.0, 4.0),
+        "vortex_type": "taylor",
+        "vortex_strength_factor": 0.03,
+    },
+]

src/drl_pinball/eval/viz_flow.py

@@ -0,0 +1,189 @@
+#!/usr/bin/env python3
+"""Flow field visualization — vorticity panels and error maps.
+
+Works on pre-saved vorticity PNGs or raw Macroscopic data.
+All panels use unified [-0.03, 0.03] vorticity range.
+
+Usage:
+    conda run -n pycuda_3_10 python viz_flow.py [--scene re100]
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+
+_OUT_BASE = Path(__file__).resolve().parent / "output"
+
+
+def log(msg: str) -> None:
+    print(f"[viz_flow] {msg}", flush=True)
+
+
+def _find_vorticity_files(scene_dir: Path) -> dict:
+    """Scan scene output dir for vorticity images. Returns dict keyed by label."""
+    files = {}
+    for name in ["vorticity_target", "vorticity_controlled", "vorticity_zero",
+                 "vorticity_uncontrolled"]:
+        png = scene_dir / f"{name}.png"
+        if png.exists():
+            files[name.replace("vorticity_", "")] = png
+    return files
+
+
+def make_comparison_panel(scene_name: str, train_dir: Optional[Path],
+                          repro_dir: Optional[Path], out_path: Path) -> None:
+    """Create a multi-panel vorticity comparison for one scene.
+
+    Layout: rows = [repro, train], cols = [target, controlled, zero]
+    """
+    panels: List[Tuple[str, Path]] = []
+
+    if repro_dir and repro_dir.exists():
+        rep_files = _find_vorticity_files(repro_dir)
+        for label, p in rep_files.items():
+            panels.append((f"Repro-{label}", p))
+
+    if train_dir and train_dir.exists():
+        trn_files = _find_vorticity_files(train_dir)
+        for label, p in trn_files.items():
+            panels.append((f"Train-{label}", p))
+
+    if not panels:
+        log(f"  {scene_name}: no vorticity images found, skipping")
+        return
+
+    n = len(panels)
+    cols = min(3, n)
+    rows = (n + cols - 1) // cols
+
+    fig, axes = plt.subplots(rows, cols, figsize=(6 * cols, 4.5 * rows))
+    if rows * cols == 1:
+        axes = np.array([[axes]])
+    elif rows == 1:
+        axes = axes.reshape(1, -1)
+    elif cols == 1:
+        axes = axes.reshape(-1, 1)
+
+    for idx, (label, img_path) in enumerate(panels):
+        r, c = divmod(idx, cols)
+        ax = axes[r, c]
+        ax.imshow(plt.imread(str(img_path)))
+        ax.set_title(label, fontsize=10)
+        ax.axis("off")
+
+    # Hide unused axes
+    for idx in range(len(panels), rows * cols):
+        r, c = divmod(idx, cols)
+        axes[r, c].axis("off")
+
+    fig.suptitle(f"{scene_name} - Vorticity Comparison", fontsize=14)
+    fig.tight_layout()
+    fig.savefig(out_path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+    log(f"  {scene_name}: {n} panels saved to {out_path.name}")
+
+
+def make_side_by_side(scene_name: str, train_dir: Optional[Path],
+                      repro_dir: Optional[Path], out_path: Path) -> None:
+    """Simple side-by-side: repro controlled | train controlled."""
+    images = []
+    labels = []
+    for label, d in [("Reproduce", repro_dir), ("Train", train_dir)]:
+        if d is None or not d.exists():
+            continue
+        for name in ["controlled", "zero"]:
+            png = d / f"vorticity_{name}.png"
+            if png.exists():
+                images.append(png)
+                labels.append(f"{label} ({name})")
+                break  # take first available
+
+    if len(images) < 2:
+        return
+
+    fig, axes = plt.subplots(1, len(images), figsize=(6 * len(images), 4.5))
+    if len(images) == 1:
+        axes = [axes]
+    for ax, img_path, label in zip(axes, images, labels):
+        ax.imshow(plt.imread(str(img_path)))
+        ax.set_title(label, fontsize=11)
+        ax.axis("off")
+    fig.suptitle(f"{scene_name}", fontsize=13)
+    fig.tight_layout()
+    fig.savefig(out_path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+    log(f"  {scene_name}: side-by-side saved")
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Vorticity visualization")
+    parser.add_argument("--scene", type=str, default=None,
+                        help="Single scene to process")
+    parser.add_argument("--side", type=str, default="all",
+                        choices=["all", "train", "reproduce"],
+                        help="Which pipeline to render")
+    args = parser.parse_args()
+
+    report_dir = _OUT_BASE / "reports" / "vorticity_panels"
+    report_dir.mkdir(parents=True, exist_ok=True)
+
+    # Scene names to process
+    train_scenes = ["re100_karman", "transfer_re60", "transfer_re200",
+                    "transfer_re400", "illusion_075L", "illusion_1L", "illusion_15L"]
+    repro_scenes = ["karman_cloak", "steady_cloak", "illusion_075L",
+                    "illusion_1L", "illusion_15L", "vortex_lamb", "vortex_taylor"]
+
+    # Map train to repro for overlap
+    overlap_map = {
+        "re100_karman": "karman_cloak",
+        "illusion_075L": "illusion_075L",
+        "illusion_1L": "illusion_1L",
+        "illusion_15L": "illusion_15L",
+    }
+
+    if args.side in ("all", "train"):
+        for scene in train_scenes:
+            if args.scene and scene != args.scene and not scene.startswith(args.scene):
+                continue
+            train_dir = _OUT_BASE / "train" / scene
+            repro_dir = _OUT_BASE / "reproduce" / overlap_map.get(scene, "")
+            make_comparison_panel(scene, train_dir,
+                                  repro_dir if repro_dir.exists() else None,
+                                  report_dir / f"vorticity_{scene}.png")
+
+    if args.side in ("all", "reproduce"):
+        for scene in repro_scenes:
+            if args.scene and scene != args.scene:
+                continue
+            if scene in overlap_map.values():
+                continue  # already covered above
+            repro_dir = _OUT_BASE / "reproduce" / scene
+            make_comparison_panel(scene, None, repro_dir,
+                                  report_dir / f"vorticity_{scene}.png")
+
+    # Summary: side-by-side for overlapping scenes
+    for scene, rep_key in overlap_map.items():
+        if args.scene and scene != args.scene and not scene.startswith(args.scene):
+            continue
+        train_dir = _OUT_BASE / "train" / scene
+        repro_dir = _OUT_BASE / "reproduce" / rep_key
+        make_side_by_side(scene, train_dir, repro_dir,
+                          report_dir / f"vorticity_compare_{scene}.png")
+
+    log(f"Reports in {report_dir}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

src/drl_pinball/eval/viz_signals.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+"""Signal visualisation — obs/action timeseries, DTW, FFT spectrum.
+
+Reads signals.npz and target.npz from scene output dirs.
+Produces per-scene diagnostic plots.
+
+Usage:
+    conda run -n pycuda_3_10 python viz_signals.py [--scene re100] [--side train]
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+
+_OUT_BASE = Path(__file__).resolve().parent / "output"
+
+
+def log(msg: str) -> None:
+    print(f"[viz_signals] {msg}", flush=True)
+
+
+# ---------------------------------------------------------------------------
+# Per-scene plot
+# ---------------------------------------------------------------------------
+def plot_scene_signals(scene_name: str, signals_path: Path,
+                       target_path: Optional[Path],
+                       out_dir: Path) -> None:
+    """Full signal diagnostic for one scene."""
+    if not signals_path.exists():
+        log(f"  {scene_name}: signals.npz not found at {signals_path}, skipping")
+        return
+
+    data = np.load(signals_path, allow_pickle=True)
+    sensors = data.get("sensors")
+    forces = data.get("forces")
+    actions = data.get("actions")
+    rewards = data.get("rewards")
+
+    fig = plt.figure(figsize=(16, 18))
+
+    n_channels = 6
+    ch_names_s = ["s0_ux", "s0_uy", "s1_ux", "s1_uy", "s2_ux", "s2_uy"]
+    ch_names_f = ["F_fx", "F_fy", "T_fx", "T_fy", "B_fx", "B_fy"]
+
+    # 1. Sensor timeseries
+    ax1 = fig.add_subplot(4, 2, 1)
+    if sensors is not None and sensors.shape[1] >= 6:
+        for i in range(6):
+            ax1.plot(sensors[:, i], lw=0.6, label=ch_names_s[i])
+    ax1.set_title("Sensors (raw, 6 channels)")
+    ax1.set_xlabel("Step"); ax1.legend(loc="upper right", fontsize=6, ncol=2)
+    ax1.grid(alpha=0.3)
+
+    # 2. Sensor uy channels only (for visual clarity)
+    ax2 = fig.add_subplot(4, 2, 2)
+    if sensors is not None and sensors.shape[1] >= 6:
+        for idx, lbl in [(1, "s0_uy"), (3, "s1_uy"), (5, "s2_uy")]:
+            ax2.plot(sensors[:, idx], lw=0.8, label=lbl)
+    ax2.set_title("Sensors (uy channels)")
+    ax2.set_xlabel("Step"); ax2.legend(fontsize=7)
+    ax2.grid(alpha=0.3)
+
+    # 3. Force timeseries
+    ax3 = fig.add_subplot(4, 2, 3)
+    if forces is not None and forces.shape[1] >= 6:
+        for i in range(6):
+            ax3.plot(forces[:, i], lw=0.6, label=ch_names_f[i])
+    ax3.set_title("Forces (raw, 6 channels)")
+    ax3.set_xlabel("Step"); ax3.legend(loc="upper right", fontsize=6, ncol=2)
+    ax3.grid(alpha=0.3)
+
+    # 4. Net force
+    ax4 = fig.add_subplot(4, 2, 4)
+    if forces is not None and forces.shape[1] >= 6:
+        cd = (forces[:, 0] + forces[:, 2] + forces[:, 4]) / 3.0
+        cl = (forces[:, 1] + forces[:, 3] + forces[:, 5]) / 3.0
+        ax4.plot(cd, lw=1, label="Cd (net)", color="tab:red")
+        ax4.plot(cl, lw=1, label="Cl (net)", color="tab:blue")
+    ax4.set_title("Net force (Cd, Cl)")
+    ax4.set_xlabel("Step"); ax4.legend(); ax4.grid(alpha=0.3)
+
+    # 5. Actions
+    ax5 = fig.add_subplot(4, 2, 5)
+    if actions is not None and actions.shape[1] >= 3:
+        ax5.plot(actions[:, 0], lw=0.8, label="aF (front)")
+        ax5.plot(actions[:, 1], lw=0.8, label="aB (bottom)")
+        ax5.plot(actions[:, 2], lw=0.8, label="aT (top)")
+    ax5.set_title("Actions [-1, 1]")
+    ax5.set_xlabel("Step"); ax5.legend(); ax5.grid(alpha=0.3)
+    ax5.set_ylim(-1.05, 1.05)
+
+    # 6. Reward (if available)
+    ax6 = fig.add_subplot(4, 2, 6)
+    if rewards is not None and len(rewards) > 0:
+        ax6.plot(rewards, lw=1, color="tab:green", label="reward")
+        ax6.axhline(y=np.mean(rewards[-180:]) if len(rewards) >= 180 else np.mean(rewards),
+                    color="green", ls="--", lw=1, label="avg (tail)")
+    ax6.set_title("Reward")
+    ax6.set_xlabel("Step"); ax6.legend(); ax6.grid(alpha=0.3)
+
+    # 7. FFT spectrum (controlled sensor uy vs target)
+    ax7 = fig.add_subplot(4, 2, 7)
+    if sensors is not None and sensors.shape[1] > 3:
+        ax7, _ = _plot_fft(ax7, sensors[:, 3], label="Controlled s1_uy",
+                           color="tab:blue")
+        if target_path and target_path.exists():
+            tgt = np.load(target_path, allow_pickle=True)
+            tgt_data = tgt.get("target_states", tgt.get("sensors"))
+            if tgt_data is not None and tgt_data.shape[1] > 3:
+                _plot_fft(ax7, tgt_data[:, 3], label="Target s1_uy",
+                          color="tab:red", linestyle="--")
+    ax7.set_title("FFT: Center sensor uy")
+    ax7.legend(fontsize=7); ax7.grid(alpha=0.3)
+
+    # 8. Action histogram
+    ax8 = fig.add_subplot(4, 2, 8)
+    if actions is not None and actions.shape[1] >= 3:
+        tail = slice(-180, None) if actions.shape[0] >= 180 else slice(None)
+        ax8.hist(actions[tail, 0], bins=20, alpha=0.5, label="aF", color="tab:red")
+        ax8.hist(actions[tail, 1], bins=20, alpha=0.5, label="aB", color="tab:orange")
+        ax8.hist(actions[tail, 2], bins=20, alpha=0.5, label="aT", color="tab:green")
+    ax8.set_title("Action distribution (tail 180 steps)")
+    ax8.legend(fontsize=7); ax8.grid(alpha=0.3)
+
+    fig.suptitle(f"{scene_name} - Signal Analysis", fontsize=14)
+    fig.tight_layout()
+    fig.savefig(out_dir / f"signals_{scene_name}.png", dpi=150, bbox_inches="tight")
+    plt.close(fig)
+    log(f"  {scene_name}: signal plot saved")
+
+
+def _plot_fft(ax, signal, label="", color="tab:blue", linestyle="-"):
+    """Plot single-sided FFT magnitude spectrum."""
+    n = len(signal)
+    sig = np.asarray(signal, dtype=np.float64)
+    sig = sig - np.mean(sig)
+    fft = np.abs(np.fft.rfft(sig)) / n
+    freqs = np.fft.rfftfreq(n, d=1)
+    ax.plot(freqs[1:], fft[1:], lw=1, color=color, ls=linestyle, label=label)
+    ax.set_xlim(0, 0.5)
+    ax.set_xlabel("Frequency (1/step)")
+    return ax, freqs, fft
+
+
+# ---------------------------------------------------------------------------
+# Cross-scene comparison: DTW / reward bars
+# ---------------------------------------------------------------------------
+def plot_cross_scene_summary(scene_dirs: dict, out_dir: Path) -> None:
+    """Bar chart comparing key metrics across scenes."""
+    import json
+
+    fig, axes = plt.subplots(1, 2, figsize=(14, 5))
+
+    names = list(scene_dirs.keys())
+    dtw_vals = []
+    reward_vals = []
+    for name, d in scene_dirs.items():
+        m_path = d / "metrics.json"
+        if m_path.exists():
+            with open(m_path) as f:
+                m = json.load(f)
+            dtw_vals.append(m.get("dtw_sim_v5", m.get("sim_raw_mean", 0)))
+            reward_vals.append(m.get("reward_mean", 0))
+        else:
+            dtw_vals.append(0)
+            reward_vals.append(0)
+
+    ax = axes[0]
+    bars = ax.bar(names, dtw_vals, color="tab:blue", alpha=0.7)
+    for b, v in zip(bars, dtw_vals):
+        if v > 0:
+            ax.text(b.get_x() + b.get_width() / 2, b.get_height() + 0.01,
+                    f"{v:.3f}", ha="center", fontsize=8)
+    ax.set_title("DTW Similarity (V5)")
+    ax.set_ylim(0, 1.1)
+    ax.tick_params(axis="x", rotation=30)
+    ax.grid(axis="y", alpha=0.3)
+
+    ax = axes[1]
+    bars = ax.bar(names, reward_vals, color="tab:green", alpha=0.7)
+    for b, v in zip(bars, reward_vals):
+        if v > 0:
+            ax.text(b.get_x() + b.get_width() / 2, b.get_height() + 0.01,
+                    f"{v:.3f}", ha="center", fontsize=8)
+    ax.set_title("Average Reward (tail 180)")
+    ax.tick_params(axis="x", rotation=30)
+    ax.grid(axis="y", alpha=0.3)
+
+    fig.suptitle("Cross-Scene Summary")
+    fig.tight_layout()
+    fig.savefig(out_dir / "cross_scene_summary.png", dpi=150, bbox_inches="tight")
+    plt.close(fig)
+    log(f"  Cross-scene summary saved")
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Signal visualization")
+    parser.add_argument("--scene", type=str, default=None)
+    parser.add_argument("--side", type=str, default="all",
+                        choices=["all", "train", "reproduce"])
+    args = parser.parse_args()
+
+    report_dir = _OUT_BASE / "reports" / "signal_plots"
+    report_dir.mkdir(parents=True, exist_ok=True)
+
+    for side_name, side_key in [("train", "train"), ("reproduce", "reproduce")]:
+        if args.side != "all" and args.side != side_key:
+            continue
+        side_dir = _OUT_BASE / side_key
+        if not side_dir.exists():
+            continue
+
+        scene_dirs_for_summary = {}
+        for scene_dir in sorted(side_dir.iterdir()):
+            if not scene_dir.is_dir():
+                continue
+            scene_name = scene_dir.name
+            if args.scene and scene_name != args.scene and not scene_name.startswith(args.scene):
+                continue
+
+            sig_path = scene_dir / "signals.npz"
+            tgt_paths = [scene_dir / "target.npz",
+                         scene_dir / ".." / ".." / ".." / "calibrations" / "re100" / "target.npy"]
+            tgt_found = None
+            for tp in tgt_paths:
+                if tp.exists():
+                    tgt_found = tp
+                    break
+
+            plot_scene_signals(f"{side_key}_{scene_name}", sig_path, tgt_found,
+                               report_dir)
+            scene_dirs_for_summary[f"{side_key}_{scene_name}"] = scene_dir
+
+        if scene_dirs_for_summary:
+            plot_cross_scene_summary(scene_dirs_for_summary, report_dir)
+
+    log(f"Reports in {report_dir}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

src/drl_pinball/train/CROSSRE_ANALYSIS.md

@@ -0,0 +1,388 @@
+# Cross-Re Transfer Learning — 分析报告
+
+> 日期: 2026-07-07  
+> 实验: 改变上游来流雷诺数 (Re60 / Re200 / Re400)，从 re100 baseline 进行 transfer learning  
+> 实验阶段: base (crossre_transfer.sh, lr=3e-4) → extend (extend_transfer.sh, lr=1e-4) → ext2 (ext2_transfer.sh, lr=1e-4)
+
+---
+
+## 1. 实验配置总览
+
+### 1.1 共享超参数
+
+| 参数 | base (crossre_transfer) | extend / ext2 |
+|------|:----------------------:|:-------------:|
+| PPO n_steps | 2048 | 2048 |
+| PPO batch_size | 64 | 64 |
+| **PPO n_epochs** | **10** | **5** ← 减半 |
+| **Learning rate** | **3e-4** | **1e-4** ← 降为 1/3 |
+| Gamma | 0.995 | 0.995 |
+| Policy net_arch | [64, 64] | [64, 64] |
+| Activation | sin | sin |
+| Symmetry augmentation | prob=0.5 | prob=0.5 |
+| Episode 数 | 200 (base) | 200-400 (extend / ext2) |
+| 基座模型 | re100_karman_seed43 (best≈0.92) | 各自 base/ext 的 best_model |
+
+> **关键差异**: extend/ext2 相比 base 将 n_epochs 从 10 降到 5、lr 从 3e-4 降到 1e-4，**综合保守程度约为 base 的 6 倍**。原始意图是 fine-tune 更稳定，但实际效果适得其反。
+
+### 1.2 校准参数差异（核心问题所在）
+
+| 参数 | re60 | re100 (base) | re200 | re400 |
+|------|:---:|:------------:|:-----:|:-----:|
+| **SI** | 800 | 800 | 500 | 400 |
+| **FORCE_SCALE** | 0.0021 | 0.0024 | 0.0026 | 0.0042 |
+| **SENS_SCALE** | 0.72 | 0.75 | 0.90 | 0.98 |
+| **dtw_norm_scale** | 0.107 | 0.204 | 0.269 | 0.310 |
+| **SIM_BP[1]** (zero rot) | 0.41 | 0.32 | 0.45 | 0.56 |
+| **SIM_BP[2]** (ref rot) | 0.61 | 0.82 | 0.77 | 0.73 |
+| **SIM_BP gap** (spread) | **0.20** | 0.50 | **0.32** | **0.17** |
+| **Δrev / Δsim 梯度比** | **2.5x** | 1.0x | **1.6x** | **2.9x** |
+| **SIM_BP 来源** | 实测 | 实测 | 实测 | 实测 |
+| **K_CD / K_CL** | **12/25** | 50/100 | **12/25** | **12/25** |
+
+> **关键发现 1**: re60 (gap=0.20) 和 re400 (gap=0.17) 的 SIM_BP gap 远小于 re100 基准的 0.50。  
+> **关键发现 2**: re60/re200/re400 的 K_CD/K_CL = 12/25，只有 re100 的 1/4。这意味着跨 Re 迁移后 drag/lift 惩罚显著放宽，改变了 reward landscape。  
+> **关键发现 3**: calibrate.py 的 generic SIM_BP 兜底条件（`spread<0.10 或 better_sim<0.5`）对 re60/re200/re400 全部未触发。
+
+### 1.3 SIM_BP 映射机制的数学解释
+
+calibrate.py 将实测的 DTW similarity 范围 `[worst_sim, better_sim]` 固定映射到 reward 值 `[0.2, 0.5]`：
+
+```
+r_sim = piecewise_map(measured_sim, SIM_BP=[0, w, b, ...], SIM_VAL=[0, 0.2, 0.5, ...])
+```
+
+这意味着 **gap 越小的场景，单位 similarity 变化对应的 reward 变化越大**：
+
+```
+Δr_sim/Δsim ≈ (0.5 - 0.2) / gap = 0.3 / gap
+```
+
+| Case | gap | Δr/Δsim | 效应 |
+|------|:---:|:-------:|------|
+| re60 | 0.20 | **1.50** | reward 梯度过陡 → PPO advantage 方差偏大 → 训练不稳定 |
+| re100 | 0.50 | **0.60** | 基准：梯度适中 |
+| re200 | 0.32 | **0.94** | 梯度偏陡，可接受 |
+| re400 | 0.17 | **1.76** | reward 梯度极陡 → PPO 估计噪音极大 → 早期 peak 后快速崩溃 |
+| vardist d075 | 0.54 | **0.56** | 梯度偏平 → PPO 信号过弱 → 持续 peak-crash 震荡 |
+
+**与 vardist 的对称性**：vardist d075 的问题方向是 gap 太大（梯度被摊薄），Karman re60/re400 的问题方向是 gap 太小（梯度被过压），但**根源完全相同：实测 SIM_BP 不适合非 re100 基线场景**。
+
+---
+
+## 2. 训练结果
+
+### 2.1 Base Transfer (lr=3e-4, n_epochs=10, 200ep)
+
+| Case | Seed | Best Reward | Best @ Ep | Ep 1 Reward | Ep 200 Reward | 走势质量 |
+|------|:----:|:-----------:|:---------:|:-----------:|:-------------:|:--------:|
+| **re60** | 43 | **0.724** | 181 | 0.370 | 0.163 | ✅ 快速上升后波动 |
+| re60 | 41 | 0.701 | 191 | 0.073 | 0.697 | ✅ 慢启动但稳定 |
+| **re200** | 43 | **0.499** | 177 | 0.223 | 0.477 | ⚠️ 缓慢爬升 |
+| re200 | 45 | 0.441 | 23 | 0.283 | 0.359 | ❌ 早期 peak 后停滞 |
+| re200 | 41 | 0.489 | 60 | 0.190 | 0.381 (Ep105) | ⚠️ 日志截断 |
+| **re400** | 43 | **0.553** | 28 | 0.326 | 0.264 | ❌ 极早 peak 后持续退化 |
+
+### 2.2 Extend Transfer (lr=1e-4, n_epochs=5, 200-400ep)
+
+从各自 base best_model 继续 fine-tune：
+
+| Case | Seed | Best Reward | Best @ Ep | Ep 1 Reward | 末 Ep Reward | vs Base | 走势 |
+|------|:----:|:-----------:|:---------:|:-----------:|:------------:|:-------:|------|
+| re60 ext | 43 | 0.695 | 149 | 0.212 | 0.660 | **-0.029** ⬇ | ⚠️ 起始更低 |
+| re200 ext | 43 | **0.535** | 182 | 0.436 | 0.244 (Ep400) | **+0.036** ⬆ | ❌ peak 后退至 0.24 |
+| re400 ext | 43 | 0.538 | 107 | 0.341 | 0.345 (Ep400) | **-0.015** ⬇ | ⚠️ 微下降 |
+
+### 2.3 Ext2 Transfer (lr=1e-4, n_epochs=5, 200-400ep)
+
+从各自 base best_model 重新 fine-tune（不继续 ext）：
+
+| Case | Seed | Best Reward | Best @ Ep | Ep 1 Reward | 末 Ep Reward | vs Base | 走势 |
+|------|:----:|:-----------:|:---------:|:-----------:|:------------:|:-------:|------|
+| re60 ext2 | 43 | 0.711 | 187 | 0.375 | 0.711 | **-0.013** ⬇ | ⚠️ 接近但未超越 |
+| re200 ext2 | 43 | 0.524 | 51 | 0.342 | 0.326 (Ep400) | **+0.025** ⬆ | ❌ 低于 ext |
+| re400 ext2 | 43 | 0.548 | 373 | 0.365 | 0.393 (Ep400) | **-0.005** ⬇ | ⚠️ 勉强持平 |
+
+### 2.4 跨实验总览
+
+| Case | 最优 | Ep @ 最优 | Ep1→末 差值 | 退化幅度 |
+|------|:----:|:---------:|:----------:|:--------:|
+| re60 base seed43 | **0.724** | 181 | +0.354 → -0.207 | -0.561 |
+| re200 ext seed43 | **0.535** | 182 | +0.436 → -0.192 | -0.628 |
+| re400 base seed43 | **0.553** | 28 | +0.326 → -0.062 | -0.388 |
+
+> **re200/re400 的 Ep1 还有提升空间，但都未能守住并持续改进，最终均出现不同程度的退化。**
+
+### 2.5 Reward 走势定性图
+
+```
+re60 base seed43:  ▄▂▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄  ─→ 0.724 (Ep181 peak，Ep200 崩至 0.16)
+re60 ext seed43:   ▄▂▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄  ─→ 0.695 (stable，低于 base 0.724)
+re60 ext2 seed43:  ▃▃▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄  ─→ 0.711 (接近 base，仍略低)
+
+re200 base seed43: ▂▃▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄  ─→ 0.499 (慢升)
+re200 ext seed43:  ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▂▁  ─→ 0.535 (Ep182 peak 后退至 0.244)
+re200 ext2 seed43: ▄▀▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃  ─→ 0.524 (Ep51 peak 后停滞)
+
+re400 base seed43: ▄▀▂▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃▃  ─→ 0.553 (Ep28 peak 后退至 0.264)
+re400 ext seed43:  ▄▄▄▄▀▂▂▂▃▃▃▃▃▃▃▃▃▃▃▃  ─→ 0.538 (平稳退化)
+re400 ext2 seed43: ▄▂▂▃▃▃▃▄▄▄▄▄▄▄▄▄▄▄▄▄  ─→ 0.548 (极慢恢复)
+```
+
+三条核心模式：
+1. **re60**：base 能冲到 0.72 但非常波动，ext/ext2 更稳定但上限被压低
+2. **re200**："早期爬坡 → 高峰 → 严重退化"三部曲
+3. **re400**："极早 peak → 持续退化"二部曲，从未恢复
+
+---
+
+## 3. 诊断分析
+
+### 3.1 ✅ re60 base — 相对成功但波动大
+
+**为什么相对成功：**
+
+1. Re60 流场接近稳态（FFT 显示极弱涡脱落），控制难度最低
+2. Re60 与 Re100 的物理差异小（FORCE_SCALE: 0.0021 vs 0.0024，仅差 12%）
+3. Ep1 r_cd=0.793 → re100 的策略在 Re60 下 drag 控制仍然有效
+4. Ep1 r_sim=0.236 → similarity 虽然初始低，但几何不变 + 流场简单可以快速调整
+
+**潜在问题：**
+
+1. 虽然最优能到 0.724，但 Ep200 跌回 0.163——极不稳定的后期表现
+2. 可能已经撞到局部最优（randomly 达到高 reward 后随 PPO 探索而丢失）
+3. SIM_BP gap=0.20 导致 reward 梯度 2.5x 于基准，PPO 在被放大的噪音中探步过大
+
+**证据：re60 base seed41 vs seed43 差异巨大**
+- seed41: Ep1=0.07（极低起点）→ 最终 0.701（稳步上升）
+- seed43: Ep1=0.37（较好起点）→ 冲高 0.724 后末班 0.163（过山车）
+- 不同 seed 从不同策略起点出发，但最终都达到了类似上限（0.70-0.72），说明 re60 的能力上限可能就在 0.72 左右
+
+### 3.2 ❌ re200 ext — 最典型的退化模式
+
+**re200 ext seed43 详细曲线：**
+```
+Ep   1: 0.436  (较高起点——ext 从 base best 继续，base Ep200=0.477)
+Ep  50: 0.460  (缓慢上升)
+Ep 150: 0.480  (继续缓慢上升)
+Ep 182: 0.535  ← BEST (突然突破)
+Ep 200: 0.488  (快速回落)
+Ep 300: 0.304  (持续下降)
+Ep 400: 0.244  (崩溃，回到接近 Ep1 水平)
+```
+
+**根因 1 — SIM_BP 梯度过陡（2.5x）**
+
+gap=0.32，Δr/Δsim=0.94，比 re100 基准陡 56%。PPO 的 advantage 估计在这种放大后的 reward 空间中方差增大，导致：
+- 偶尔能发现好策略（Ep182 的 0.535）
+- 但下次 PPO 更新时在大方差下 over-shoot，丢失策略
+- 之后再也找不回来——"过山车"无法逆转
+
+这和一个经典现象一致：**advantage variance 过大时，即使 PPO 的 clipping 也无法防止 catastrophic update**。
+
+**根因 2 — extend 超参过于保守（6x）**
+
+lr=1e-4 + n_epochs=5 的组合相当于每次 PPO update 的有效学习量只有 base 的 ~1/6。当策略退化到 0.244 时，如此小的更新量已无法推动策略脱离低谷。
+
+**根因 3 — K_CD/K_CL 不一致改变 reward landscape**
+
+re100 基准使用 K_CD=50, K_CL=100，但 re200 的 calibration 只有 K_CD=12, K_CL=25（1/4）。这意味着：
+- re100 专家策略训练时 drag/lift 受到非常严格的平方惩罚
+- 迁移到 re200 后，同样的 drag 偏差只受到 1/4 的惩罚
+- 相当于 reward 中 drag/lift 分量的"价格"大幅下降 → PPO 可以"偷工减料"仍然拿到最高 reward
+- 但不一定意味着真正控制了流场——更像在 reward 空间中找到了捷径
+
+### 3.3 ❌ re400 — 极早 peak 后永不恢复
+
+**re400 base seed43 详细曲线：**
+```
+Ep   1: 0.326  (中等起点)
+Ep  28: 0.553  ← BEST (极早 peak)
+Ep  50: 0.451
+Ep 100: 0.362  (持续退化)
+Ep 150: 0.301  (继续退化)
+Ep 200: 0.264  (接近起点)
+```
+
+**根因 1 — SIM_BP gap=0.17，梯度 2.9x 于基准**
+
+这是所有 case 中最极端的 SIM_BP 异常。在 0.17 的窄 similarity 范围内，0.2→0.5 的 reward 映射意味着：
+- 任何微小的 similarity 波动被 2.9 倍放大
+- PPO 观测到的 reward signal 几乎全是噪音
+- 类似在高噪声数据上用大步长 SGD——方向随机，永远无法收敛
+
+**根因 2 — 流场混沌度高**
+
+Re400 涡脱落更强更不规则（FORCE_SCALE=0.0042，比 re100 高 75%）。流场本身的随机性已经大到 PPO 无法在合理步数内学习有效的 value function，再加上被放大的 reward 梯度 → 不稳定的更新 → 策略崩坏。
+
+**根因 3 — 三种退化叠加**
+
+与 re200 不同，re400 同时受到：
+1. SIM_BP 梯度异常（2.9x，最严重）
+2. K_CD/K_CL 缩小（reward landscape 变形）
+3. 流场混沌（自然信号噪声高）
+
+三座大山共同压垮了训练。
+
+### 3.4 extend/ext2 vs base 的退化对比
+
+| Case | base best | ext best | Δ base→ext | ext2 best | Δ best→ext2 | 超参保守效应 |
+|------|:---------:|:--------:|:----------:|:---------:|:-----------:|:----------:|
+| re60 | **0.724** | 0.695 | **-0.029** | 0.711 | -0.013 | ⚠️ 有害 |
+| re200 | 0.499 | **0.535** | **+0.036** | 0.524 | +0.025 | ⚠️ 边际改善但稳不住 |
+| re400 | **0.553** | 0.538 | **-0.015** | 0.548 | -0.005 | ⚠️ 基本持平 |
+
+**模式**：extend/ext2 的超参组合（lr=1e-4, n_epochs=5）对任何 Re 都没有产生显著正向帮助：
+- re60: 明显有害（-0.029）
+- re200: 微改善（+0.036）但后续崩塌
+- re400: 基本持平但远低于可接受水平
+
+**推论**：在 SIM_BP 梯度异常未修复的前提下，调整超参只是治标不治本。
+
+---
+
+## 4. 与 Vardist 的交叉验证
+
+### 4.1 SIM_BP 问题的对称性
+
+```
+                     ←── 梯度太陡（Karman re60/re400）──→
+Δr/Δsim:  0.56      0.60       0.94       1.50       1.76
+           │         │          │          │          │
+Case:   d075      re100      re200      re60      re400
+         │         │          │          │          │
+问题:  太平坦     基准      偏陡       太陡       极陡
+表现: peak-crash  正常     慢升+退化   波动大    极早peak崩溃
+│                    │                    │
+└─ vardist 方向 ──────┴─ Karman 方向 ─────┘
+```
+
+**两种方向的修复都需要 generic SIM_BP (gap=0.35)**，恰好落在安全区间。
+
+### 4.2 Early Peak 退化：d2 vs re400
+
+两个案例共享完全相同的退化模式：
+
+| 特征 | vardist d2 | Karman re400 | 是否同源？ |
+|------|:----------:|:------------:|:---------:|
+| Ep1 r_sim | 0.455 | 0.326 | 均 < 0.5 |
+| Best @ | Ep 2 | Ep 28 | 均极早 |
+| 退化幅度 | 0.470 → 0.246 (48%) | 0.553 → 0.264 (52%) | 接近 |
+| 恢复能力 | 无人力干预从未恢复 | 无人力干预从未恢复 | 相同 |
+| **根因** | **几何不匹配** | **SIM_BP 梯度 2.9x** | 不同 |
+
+> **d2 的根因是几何变化（2.0L vs 1.0L），re400 的根因是 reward 梯度异常。但两者的退化模式完全一致，说明 "早期 peak 后不可逆退化" 是一个通用的 training instability 信号，无论触发原因是什么。**
+
+### 4.3 Vardist 的改善经验是否可以套用？
+
+| Vardist v2 改进 | 原因 | 是否适用于 Karman？ |
+|----------------|------|:-------------------:|
+| generic SIM_BP | d075 gap=0.54 太宽 | ✅ **高度适用**（re60/re400 gap 太窄，同因异向） |
+| from scratch | d075 Ep1=0.023 完全不适用 | ⚠️ 部分适用（re60 Ep1=0.37 还行，re200/400 borderline） |
+| lr=1e-4 | 减少 scratch 训练 over-shoot | ❌ **不适用**（Karman 是 fine-tune，降 lr 有害） |
+| — | — | ✅ **需要升回 lr=3e-4, n_epochs=10**（与 base 保持一致） |
+
+---
+
+## 5. 改进建议
+
+### 5.1 针对 re60
+
+| 优先级 | 方案 | 原理 |
+|:------:|------|------|
+| **P0** | 使用 generic SIM_BP 重新 calibrate | gap=0.20 → 0.35，降低 reward 梯度从 2.5x→1x，稳定训练 |
+| **P1** | 从 re60 base best 继续 fine-tune，但保持 lr=3e-4 + n_epochs=10 | 当前 0.724 仍有波动，需要更多 episode 而非更保守更新 |
+| **P2** | Multi-seed fine-tune (seed41/43/45) | 不同 seed 的 Ep1→最终轨迹差异大，多 seed 取优 |
+
+### 5.2 针对 re200
+
+| 优先级 | 方案 | 原理 |
+|:------:|------|------|
+| **P0** | 使用 generic SIM_BP 重新 calibrate | gap=0.32 → 0.35（差异较小但仍有 56% 的梯度过压） |
+| **P1** | 恢复 lr=3e-4 + n_epochs=10 的原始超参 | re200 ext 是唯一从 extend 中获益的 case (+0.036)，说明保守更新至少没完全搞砸——但应该用原始超参加速收敛 |
+| **P2** | 延长 episode 数至 500+ | re200 base 200ep 仅到 0.499 且仍在上升，需要更长时间 |
+| **P3** | 对比 K_CD/K_CL=50/100 vs 12/25 | 找出 reward landscape 变形的实际影响 |
+| **P4** | 尝试 n_steps=4096 | 多采一倍经验做一次 PPO update，超参整体更保守但 advantage 估计更稳 |
+
+### 5.3 针对 re400
+
+| 优先级 | 方案 | 原理 |
+|:------:|------|------|
+| **P0** | 使用 generic SIM_BP 重新 calibrate | gap=0.17 → 0.35，梯度从 2.9x 降到 1x，是**最重要且最可能有效**的改动 |
+| **P1** | 对比 from scratch vs transfer | Ep1 r_sim=0.326 borderline，可能需要从头学 |
+| **P2** | 考虑 from scratch 500ep (lr=3e-4, n_epochs=10) | 如果 re100 策略对 re400 不适用，scratch 可能更快 |
+| **P3** | 尝试更大模型容量 [128, 64] 或 [128, 128] | Re400 流场更混沌，64-d MLP 可能容量不足 |
+| **P4** | 降低 symmetry probability 至 0.3 | 高 Re 下流场不对称性更强，强 symmetry 正则化可能有害 |
+
+### 5.4 针对 extend/ext2 脚本
+
+| 优先级 | 方案 | 原理 |
+|:------:|------|------|
+| **P0** | 恢复 lr=3e-4 + n_epochs=10 | 当前 6x 保守超参对所有 Re 无效甚至有害 |
+| **P1** | 只增加 episode 数，不改变任何超参 | 保持与 base 完全一致的 PPO 设置 |
+| **P2** | 在每个 Re 的 extend 中点（50% episodes）评估一次 | 如果 reward 持续下降，提前终止避免浪费时间 |
+
+### 5.5 通用改进
+
+| 优先级 | 方案 | 适用范围 |
+|:------:|------|---------|
+| **P0** | 修改 calibrate.py 的 generic SIM_BP 兜底条件：增加 gap<0.25（re100 基准的 50%）时触发 | 所有 future cross-Re / vardist case |
+| **P1** | 将 K_CD/K_CL 固定在 50/100，而非让 calibration 测量不同值 | 保持 reward landscape 一致，跨 Re / 跨几何比较才有意义 |
+| **P2** | Ep1 metrics 作为先行诊断指标：r_sim<0.3 时建议 from scratch；r_sim>0.5 + r_cd>0.6 时可放心 transfer | 减少无效实验 |
+| **P3** | 对高 Re (200+) 增加 n_steps=4096 的实验分支 | 混沌流场需要更大 minibatch 做稳定 advantage 估计 |
+| **P4** | 对比实验矩阵（见 §6） | 一次性验证多个假说 |
+
+---
+
+## 6. 建议的对比实验矩阵
+
+基于以上分析，最经济有效的实验设计（每个 200ep）：
+
+| 实验 | Re | SIM_BP | lr | n_ep | trans？ | 目的 |
+|------|:--:|:------:|:--:|:----:|:------:|------|
+| **T0** (baseline) | 200/400 | 实测 | 3e-4 | 10 | re100→ | 已有数据，基线 |
+| **T1** | 400 | generic | 3e-4 | 10 | re100→ | **P0 验证**：generic SIM_BP 是否消除早期崩溃 |
+| **T2** | 400 | generic | 3e-4 | 10 | 无 | 验证 from scratch 是否更优 |
+| **T3** | 200 | generic | 3e-4 | 10 | re100→ | 验证 re200 能否突破 0.50-0.53 瓶颈 |
+| **T4** | 200 | 实测 | 3e-4 | 10 | re100→, K=50/100 | 验证 K_CD/K_CL 统一的效应 |
+| **T5** | 400 | generic | 3e-4 | 10 | re100→, n_steps=4096 | 验证大 minibatch 的效果 |
+
+**推荐路径**：先跑 T1，如果 re400 不再早期崩溃 → P0 确诊 → 再生产性跑 T3 + T4 + T5。
+
+---
+
+## 7. 与 Vardist 的对照总结
+
+| 维度 | Vardist (变扰流尺寸) | Karman (变 Re) |
+|------|---------------------|---------------|
+| **物理变化** | 扰动圆柱直径 0.75L–2.0L | 来流粘度 → Re 变化 |
+| **核心问题** | SIM_BP gap=0.54 太宽（梯度被摊薄） | SIM_BP gap=0.17-0.32 太窄（梯度被过压） |
+| **典型退化** | d075: 持续 peak-crash 震荡 | re200/400: 早期 peak 后不可逆退化 |
+| **兜底逻辑** | d15/d2 触发 generic；d075 未触发 | re60/200/400 均未触发 |
+| **已尝试修复** | v2: generic SIM_BP + from scratch + lr=1e-4 | ext/ext2: lr=1e-4 + n_epochs=5（方向错误） |
+| **正确修复** | generic SIM_BP + 合理超参 | generic SIM_BP + 恢复 lr=3e-4 + n_epochs=10 |
+| **统一根因** | calibrate.py 的实测 SIM_BP 不适合非 re100 场景 | 同上 |
+
+---
+
+## 8. 关键文件索引
+
+| 文件 | 路径 |
+|------|------|
+| Base 训练脚本 | `train_karman.py` |
+| 环境 | `env_karman.py` |
+| 校准脚本 | `calibrate.py`（SIM_BP generic 兜底逻辑在第 526–527 行） |
+| Base transfer 启动 | `crossre_transfer.sh`（lr=3e-4, n_epochs=10） |
+| Extend transfer 启动 | `extend_transfer.sh`（lr=1e-4, n_epochs=5, 保守超参） |
+| Ext2 transfer 启动 | `ext2_transfer.sh`（同上，重新 fine-tune） |
+| Multi-GPU launcher | `launch_multi.sh`（lr=3e-4, n_epochs=10） |
+| 对比分析 | `VARDIST_ANALYSIS.md` |
+| re60 校准 | `calibrations/re60/calibration.json`（SIM_BP gap=0.20, K_CD=12） |
+| re100 校准 | `calibrations/re100/calibration.json`（SIM_BP gap=0.50, K_CD=50） |
+| re200 校准 | `calibrations/re200/calibration.json`（SIM_BP gap=0.32, K_CD=12） |
+| re400 校准 | `calibrations/re400/calibration.json`（SIM_BP gap=0.17, K_CD=12） |
+| re60 base 日志 | `output/transfer_re60_seed43/train.log` |
+| re200 base 日志 | `output/transfer_re200_seed43/train.log` |
+| re200 ext 日志 | `output/transfer_re200ext_seed43/train.log`（0.535→0.244 退化） |
+| re400 base 日志 | `output/transfer_re400_seed43/train.log`（Ep28 0.553→0.264 退化） |
+| re400 ext2 日志 | `output/transfer_re400ext2_seed43/train.log` |

src/drl_pinball/train/README.md

@@ -0,0 +1,221 @@
+# DynamisLab — 训练目录
+
+> `src/drl_pinball/train/`  
+> 更新: 2026-07-12
+
+---
+
+## 命名规则
+
+```
+{domain}_{variant}_{method}_seed{seed}
+
+domain:  kar = Karman  |  ill = Illusion
+variant: re{60,100,200,400} = 雷诺数  |  d{075,15,2} = 扰动圆柱直径(L)  |  {1L,15L,075L,2L} = 目标圆柱尺寸
+method:  sc = from scratch  |  tr = transfer from re100 baseline
+seed:    seed{41..45}
+
+Examples:
+  kar_re100_sc_seed45   — Karman Re100 scratch, seed 45
+  kar_d075_sc_seed44    — Karman 0.75L dist-cyl scratch
+  kar_d15_tr_seed45     — Karman 1.5L dist-cyl transfer
+  kar_re200_sc_seed43   — Karman Re200 scratch
+  ill_2L_sc_seed43      — Illusion 2L target scratch
+```
+
+---
+
+## 目录结构
+
+```
+train/
+├── train_karman.py              # Karman PPO 训练 (核心)
+├── train_illusion.py            # Illusion PPO 训练
+├── calibrate.py                 # Phase 0 校准
+│
+├── env_karman.py                # Karman 环境
+├── env_illusion.py              # Illusion 环境
+├── symmetry_wrapper.py          # G-symmetry 数据增强
+│
+├── scripts/                     # 启动脚本
+│   ├── train_baseline.sh        # kar_re100_sc multi-seed
+│   ├── train_illusion.sh        # ill_*_sc 4 个尺寸
+│   ├── vardist_scratch.sh       # kar_d*_sc (推荐)
+│   ├── vardist_transfer.sh      # kar_d*_tr (参考)
+│   ├── crossre_scratch.sh       # kar_re*_sc
+│   ├── crossre_transfer.sh      # kar_re*_tr (参考)
+│   └── resume.sh                # 中断恢复
+│
+├── calibrations/                # 校准文件
+│   ├── kar_re100/               # Re100 基准
+│   ├── kar_d*_sc/               # 变直径 scratch (generic SIM_BP)
+│   ├── kar_d*_tr/               # 变直径 transfer (实测 SIM_BP)
+│   ├── kar_re*_sc/              # 变雷诺数 scratch (generic SIM_BP)
+│   ├── kar_re*/                 # 变雷诺数 transfer (实测 SIM_BP)
+│   └── ill_*/                   # Illusion
+│
+├── output/                      # 训练输出 (21 dirs)
+│   ├── kar_re100_sc_seed{41..45}/
+│   ├── kar_d*_sc_seed{44,45}/
+│   ├── kar_d*_tr_seed{44,45}/
+│   ├── kar_re*_sc_seed43/
+│   ├── kar_re*_tr_seed43/
+│   └── ill_*_sc_seed43/
+│
+├── archive/                     # 旧版本 (保留)
+├── README.md                    # 当前文件
+├── VARDIST_ANALYSIS.md
+├── CROSSRE_ANALYSIS.md
+└── SERVER_DEPLOY.md
+```
+
+---
+
+## 快速开始
+
+### 基准训练
+
+```bash
+cd scripts
+bash train_baseline.sh --gpu 0 --episodes 500
+# → output/kar_re100_sc_seed{41..45}/
+```
+
+### 变直径 scratch (推荐)
+
+```bash
+cd scripts
+bash vardist_scratch.sh --gpu 0
+bash vardist_scratch.sh --only d075
+# → output/kar_d075_sc_seed44/  etc.
+```
+
+### 变雷诺数 scratch
+
+```bash
+cd scripts
+bash crossre_scratch.sh --gpu 0
+bash crossre_scratch.sh --only re200
+# → output/kar_re200_sc_seed43/  etc.
+```
+
+### Illusion
+
+```bash
+cd scripts
+bash train_illusion.sh --gpu 0
+# → output/ill_2L_sc_seed43/  etc.
+```
+
+### 中断恢复
+
+```bash
+cd scripts
+bash resume.sh --case kar_re60_sc --seed 43 --resume 460 --episodes 500
+```
+
+---
+
+## 核心训练脚本
+
+### `train_karman.py`
+
+```bash
+conda run -n pycuda_3_10 python -u train_karman.py \
+    --case-name kar_re100_sc --device-id 0 --seed 42 \
+    --config config.json --calibration calibrations/kar_re100/calibration.json \
+    --total-episodes 500 [--transfer-model PATH] [--resume-from N]
+```
+
+| 参数 | 默认值 | 说明 |
+|------|:-----:|------|
+| n_steps | 2048 | PPO 每轮收集步数 |
+| batch_size | 64 | minibatch |
+| n_epochs | 10 | 经验重用次数 |
+| lr | 3e-4 | 学习率 |
+| gamma | 0.995 | 折扣因子 |
+| net_arch | [64, 64] | MLP 两层 sin 激活 |
+
+---
+
+## 最终结果
+
+### Re100 基准 — `kar_re100_sc`
+
+| Seed | r_sim | r_cd | r_cl |
+|:----:|:-----:|:----:|:----:|
+| 45 | 0.883 | 0.977 | 0.982 |
+| Avg | 0.866 | 0.971 | 0.965 |
+
+### Vardist 变直径
+
+| Case | 方式 | r_sim | r_cd | r_cl |
+|------|:----:|:-----:|:-----:|:-----:|
+| **kar_d075_sc** | scratch | **0.918** | 0.954 | 0.879 |
+| kar_d075_tr | transfer | 0.450 | 0.585 | 0.236 |
+| **kar_d15_sc** | scratch | **0.904** | 0.991 | 0.992 |
+| kar_d15_tr | transfer | 0.791 | 0.918 | 0.470 |
+| **kar_d2_sc** | scratch | **0.793** | 0.967 | 0.961 |
+| kar_d2_tr | transfer | 0.673 | 0.537 | 0.192 |
+
+> Scratch 全面领先 transfer。
+
+### Cross-Re 变雷诺数
+
+| Case | 方式 | r_sim | r_cd | r_cl |
+|------|:----:|:-----:|:-----:|:-----:|
+| kar_re60_tr | transfer | 0.446 | **0.882** | 0.936 |
+| kar_re60_sc | scratch | 0.261 | **0.987** | 0.981 |
+| **kar_re200_sc** | scratch | **0.664** | 0.667 | 0.281 |
+| kar_re200_tr | transfer | 0.374 | 0.749 | 0.427 |
+| **kar_re400_sc** | scratch | **0.509** | 0.714 | 0.420 |
+| kar_re400_tr | transfer | 0.293 | 0.883 | 0.571 |
+
+> Scratch sim 最优，transfer CD 最优。两者均保留。
+
+### Illusion
+
+| Case | r_sim | r_cd | r_cl |
+|------|:-----:|:-----:|:-----:|
+| ill_1L_sc | 0.725 | 0.774 | 0.449 |
+| ill_15L_sc | 0.810 | 0.825 | 0.384 |
+| ill_075L_sc | 0.794 | 0.840 | 0.486 |
+| **ill_2L_sc** | **0.896** | 0.863 | 0.570 |
+
+---
+
+## Calibration 参考
+
+| Calibration | 物理 | SI | SIM_BP | K_CD/K_CL | 对应 output |
+|------------|------|:--:|--------|:---------:|------------|
+| `kar_re100` | Re=100, 1.0L | 800 | 实测 | 50/100 | `kar_re100_sc` |
+| `kar_d075_sc` | Re=100, 0.75L | 800 | generic | 50/100 | `kar_d075_sc` |
+| `kar_d075_tr` | Re=100, 0.75L | 800 | 实测 | 50/100 | `kar_d075_tr` |
+| `kar_d15_sc` | Re=100, 1.5L | 800 | generic | 50/100 | `kar_d15_sc` |
+| `kar_d15_tr` | Re=100, 1.5L | 800 | 实测 | 50/100 | `kar_d15_tr` |
+| `kar_d2_sc` | Re=100, 2.0L | 800 | generic | 50/100 | `kar_d2_sc` |
+| `kar_d2_tr` | Re=100, 2.0L | 800 | 实测 | 50/100 | `kar_d2_tr` |
+| `kar_re60` | Re=60 | 800 | 实测 | 12/25 | `kar_re60_tr` |
+| `kar_re60_sc` | Re=60 | 800 | generic | 50/100 | `kar_re60_sc` |
+| `kar_re200` | Re=200 | 500 | 实测 | 12/25 | `kar_re200_tr` |
+| `kar_re200_sc` | Re=200 | 500 | generic | 50/100 | `kar_re200_sc` |
+| `kar_re400` | Re=400 | 400 | 实测 | 12/25 | `kar_re400_tr` |
+| `kar_re400_sc` | Re=400 | 400 | generic | 50/100 | `kar_re400_sc` |
+| `ill_*` | Illusion | — | 实测 | 12/25 | `ill_*_sc` |
+
+---
+
+## Key Findings
+
+1. **SIM_BP 映射是跨场景训练的最关键变量。** 实测 gap ≠ 0.35 会导致 reward 梯度异常。
+   - Generic SIM_BP `[0, 0.30, 0.65, 0.79, 0.89, 1.0]` (gap=0.35) → 稳定学习
+
+2. **变直径: scratch > transfer.** Generic SIM_BP + K_CD/CL=50/100 + lr=3e-4 + 500ep 是最优配方。
+
+3. **变雷诺数: scratch 和 transfer 各有侧重。** 两者均保留。
+
+4. **变雷诺数存在 CD/CL ↔ r_sim 根本性 trade-off。** 训练越久 r_cd 越高但 r_sim 越低（re60_sc: Ep60 r_sim=0.48 → Ep390 r_sim=0.26, r_cd=0.99）。CD/CL reward 分量主导了优化方向。
+
+5. **降低 W_drag/W_lift (0.1) 有害。** CD/CL reward 是稳定器而非瓶颈。
+
+6. **Ep1 r_sim ≥ 0.5 可预测 transfer 成功。**

src/drl_pinball/train/TRAIN_KNOWLEDGE.md

@@ -1,352 +0,0 @@
-# Karman Cloak Training — Knowledge Document (V5)
-
-> **V5 (2026-07-03)**: Parameterized, calibration-driven, no_bias only.
-> All paths use DynamisLab submodule `CelerisLab/` (no external dev dir).
-> Cross-Re transfer pipeline verified: re60, re200, re400.
-> Every episode saves model checkpoint.
-> V4 backups moved to `old/`.
-
----
-
-## 1. What This Codebase Does
-
-Trains a PPO agent to control a fluidic pinball (3 rotating cylinders) to achieve
-hydrodynamic cloaking — making the downstream flow match the "undisturbed" flow
-(as if the pinball weren't there). The upstream disturbance cylinder generates a
-Kármán vortex street; the pinball must cancel it.
-
-- **CFD**: CelerisLab LBM solver (DynamisLab submodule), D2Q9 MRT, 2000x600 grid, uniform inlet, free-slip walls
-- **DRL**: PPO with Sin activation, 64x64 MLP, SB3 + VecNormalize
-- **V5 mode**: No_bias only (ACTION_SCALE=12, ACTION_BIAS=[0,0,0]). All cases use calibration-first workflow.
-
-## 0. Quick Start
-
-### 0.1 Single-Re training (re100)
-
-```bash
-# 1. Calibrate (~5 min)
-cd src/drl_pinball/train
-conda run -n pycuda_3_10 python calibrate.py \
-    --case re100 --device-id 0 \
-    --config configs/config_lbm_karman_2000x600.json
-
-# 2. Multi-seed training (server, sequential 7-min delay between GPUs)
-bash launch_multi.sh \
-    --case-name re100_karman --seeds 42,43,44,45,46,47 \
-    --gpus 0,1,2,3,4,5 --episodes 500 \
-    --config configs/config_lbm_karman_2000x600.json \
-    --calibration calibrations/re100/calibration.json
-
-# 3. Monitor
-tail -f output/re100_karman_seed42/train.log
-tensorboard --logdir output/re100_karman_seed42/tb --port 6006
-```
-
-### 0.2 Cross-Re transfer (re60, re200, re400)
-
-```bash
-# Local test (5 episodes each, quick verification):
-bash crossre_transfer.sh --re-list 60,200,400 --test-episodes 5
-
-# Server production (200 episodes each):
-# !! BEFORE PUSHING TO SERVER: update BEST_MODEL path in crossre_transfer.sh !!
-bash crossre_transfer.sh --re-list 60,200,400
-# Then push to server and run there.
-```
-
-### 0.3 Path notes for server deployment
-
-`crossre_transfer.sh` has relative paths via `SCRIPT_DIR`/`REPO_DIR`.
-Only `BEST_MODEL` needs updating — point to the best Re100 model from
-multi-seed training (e.g. `output/re100_karman_seed42/models/best_model.zip`).
-
----
-
-## 2. File Structure (V5 Final)
-
-```
-train/
-├── __init__.py
-│
-├── # ACTIVE FILES
-├── calibrate.py                # Phase 0 calibration (produces calibration.json + target.npy)
-├── env_karman.py               # Parameterized Karman cloak env
-├── env_illusion.py             # Parameterized Illusion env
-├── env_vortex.py               # Vortex cloak env (lamb/taylor, MAX_STEPS=150)
-├── train_karman.py             # Parameterized training script (every ep saves model)
-├── train_illusion.py           # Illusion training script
-├── launch_multi.sh             # Sequential multi-GPU server launcher
-├── crossre_transfer.sh         # Cross-Re transfer: calibrate + train (re60→re200→re400)
-├── symmetry_wrapper.py         # G-mirror symmetry augmentation (per-rollout)
-├── visualize_and_analyze.py    # Flow-field visualization & analysis
-├── SERVER_DEPLOY.md            # Server deployment instructions
-├── TRAIN_KNOWLEDGE.md          # This file
-│
-├── old/                        # Archived V4 files (NOT active)
-│   ├── env_karman_2000x600.py
-│   ├── train_karman_2000x600.py
-│   ├── phase0_baseline_measure.py
-│   └── analyze_final.py
-│
-├── calibrations/               # Per-case calibration files (IMMUTABLE)
-│   ├── re60/
-│   │   ├── calibration.json    # SI=800, FORCE_SCALE=0.0021, SENS_SCALE=0.72
-│   │   ├── target.npy
-│   │   └── calibrate.log
-│   ├── re100/
-│   │   ├── calibration.json    # SI=800, FORCE_SCALE=0.0024, SENS_SCALE=0.75
-│   │   └── calibrate.log
-│   ├── re200/
-│   │   ├── calibration.json    # SI=500, FORCE_SCALE=0.0026, SENS_SCALE=0.90
-│   │   ├── target.npy
-│   │   └── calibrate.log
-│   ├── re400/
-│   │   ├── calibration.json    # SI=400, FORCE_SCALE=0.0042, SENS_SCALE=0.98
-│   │   ├── target.npy
-│   │   └── calibrate.log
-│   └── illusion_1L/
-│       ├── calibration.json
-│       ├── target.npy
-│       ├── target_harmonics.json
-│       └── calibrate.log
-│
-└── output/                     # Training outputs
-    └── <case>_seed<N>/
-        ├── models/             # ep0001_model.zip, ..., best_model.zip, final_model.zip
-        ├── tb/                 # TensorBoard logs
-        ├── train.log
-        ├── calibration.json
-        ├── vec_normalize.pkl
-        └── meta.json
-```
-
----
-
-## 3. Calibration Workflow (ALWAYS RUN FIRST)
-
-Every case MUST run `calibrate.py` before training. This produces:
-
-- `calibration.json`: FORCE_SCALE, SENS_SCALE, dtw_norm_scale, SIM_BP, SIM_VAL, reward constants
-- `target.npy`: Target sensor signals (150 steps x 6 channels)
-
-The calibration measures Stage0 (zero rotation) and Stage1 (open-loop reference) to compute normalization
-constants. Calibration is **IMMUTABLE** — once produced, never modify.
-
-### Calibration Results (all Re)
-
-| Case | SI | FORCE_SCALE | SENS_SCALE | dtw_norm_scale | Stage0 sim | Stage1 sim |
-|------|-----|-------------|------------|----------------|-----------|-----------|
-| re60 | 800 | 0.0021 | 0.72 | 0.107 | 0.41 | 0.61 |
-| re100 | 800 | 0.0024 | 0.75 | 0.204 | 0.32 | 0.82 |
-| re200 | 500 | 0.0026 | 0.90 | 0.269 | 0.45 | 0.77 |
-| re400 | 400 | 0.0042 | 0.98 | 0.310 | 0.56 | 0.73 |
-
-### Cross-Re SI guidance
-
-Based on ~18 samples per vortex shedding cycle:
-| Case | SI | Rationale |
-|------|----|-----------|
-| re60 | 800 | FFT shows very weak/absent shedding at this Re with free-slip |
-| re100 | 800 | Verified (~19 samples/cycle) |
-| re200 | 500 | ~18 samples/cycle |
-| re400 | 400 | ~18 samples/cycle |
-
-### re60 note
-
-At Re=60 with uniform inlet + free-slip walls, the upstream disturbance cylinder
-produces very weak periodic shedding (FFT dominant period ~5625 samples).
-This is a different regime from legacy parabolic+no-slip where re50 did shed.
-SI=800 is adequate; the DRL essentially learns a steady-state control policy.
-
----
-
-## 4. Reward Design
-
-### Formula
-
-```python
-# Gaussian reward (no zero-crossing spikes)
-r_cd_raw = exp(-cd_norm² * K_CD)      # cd_norm = (Σfx)/3 / FORCE_SCALE
-r_cl_raw = exp(-cl_norm² * K_CL)
-
-# EMA smoothing for cd/cl (r_sim uses DTW, already smooth)
-r_cd = EMA(r_cd_raw, weight=0.2)
-r_cl = EMA(r_cl_raw, weight=0.2)
-
-# Normalized DTW similarity (piecewise-mapped to [0,1])
-r_sim = piecewise_map(sim, SIM_BP, SIM_VAL)
-
-# Floor penalty: prevents sacrificing one component
-penalty = 0.05 * sum(max(0, FLOOR - r) / FLOOR for r, FLOOR in zip(...))
-
-reward = max(0, W_CD*r_cd + W_CL*r_cl + W_SIM*r_sim - penalty)
-# W_CD=0.30, W_CL=0.30, W_SIM=0.40
-```
-
-### Three-stage targets
-
-| Stage | r_cd | r_cl | r_sim | Description |
-|-------|------|------|-------|-------------|
-| Stage0 (zero rotation) | ~0 | ~0 | ~0.2 | No control baseline |
-| Stage1 (reference open-loop) | ~0.7 | ~0.5 | ~0.5 | Legacy-equiv bias |
-| Optimal (trained) | ~0.9 | ~0.9 | ~0.9 | Full cloaking |
-
-### Why Gaussian not exp(-|x|)
-
-`exp(-|x|)` has maximum gradient at x=0, causing reward spikes at zero-crossings
-of oscillating cd/cl. `exp(-x²)` has zero gradient at x=0 → smooth near optimum.
-
-### Why normalized DTW
-
-Raw DTW has narrow dynamic range (0.70-0.97). Normalizing by target's uy-channel
-std extends range to 0.0-0.9, giving DRL meaningful gradient.
-
-### Why no EMA on r_sim
-
-DTW is already a smooth 30-step windowed signal. Adding EMA over-smooths.
-
----
-
-## 5. PPO Configuration
-
-```python
-PPO(
-    "MlpPolicy",
-    policy_kwargs={"activation_fn": Sin, "net_arch": [64, 64]},
-    env=vec_env,
-    device=torch.device("cuda:X"),
-    n_steps=2048,        # MUST be 2048. 512 → noisy curves.
-    batch_size=64,
-    n_epochs=10,
-    learning_rate=3e-4,
-    gamma=0.995,         # Higher than default for DTW delay propagation
-)
-```
-
-- **Evaluation**: stochastic (no deterministic=True) — smoother curves
-- **Symmetry**: per-rollout G-mirror (50% probability). Disabled during eval.
-- **Every episode saves**: `ep0001_model.zip` + `ep0001_vecnormalize.pkl` saved each episode
-
----
-
-## 6. Obs Normalization (Two-layer)
-
-1. **Env physical norm** (fixed, from calibration):
-   - forces / FORCE_SCALE, sensors / SENS_SCALE
-   - No clipping (VecNormalize handles)
-
-2. **SB3 VecNormalize** (running mean/std):
-   - norm_obs=True, norm_reward=False, clip_obs=10.0
-   - Saved to `vec_normalize.pkl` for inference
-
----
-
-## 7. Action Configuration (V5: no_bias only)
-
-```python
-ACTION_SCALE = 12.0
-ACTION_BIAS = [0, 0, 0]
-# omega = -(action * 12) * U0 / RADIUS
-# Physical range: all cylinders [-12, 12] × U0
-```
-
-Sign convention: `Uw = -omega * ry` (omega>0 = clockwise).
-
----
-
-## 8. Environment Design
-
-### Two-phase initialization
-
-1. `record_target()`: dist_cyl + sensors only → record 150-step target → close
-2. Training Simulation: all 7 objects → warmup → zero-action FIFO → snapshot
-
-Body IDs (add order):
-```
-0: dist_cyl (force, skipped in obs)
-1-3: sensors (top, center, bottom)
-4-6: pinball (front, top_rear, bottom_rear)
-```
-
-Obs layout (12-dim): forces[6] + sensors[6]
-
-### No-reset training
-
-`step()` returns `terminated=False`. Eval does `reset()` for reproducible assessment.
-
----
-
-## 9. Cross-Re Transfer Pipeline
-
-### How to add a new Re
-
-```bash
-# 1. Create config (copy existing, change viscosity)
-cp configs/config_lbm_karman_2000x600.json configs/config_lbm_karman_2000x600_reNNN.json
-# Edit "viscosity" to U0 * 2D / Re_NNN
-
-# 2. Calibrate
-python calibrate.py --case reNNN --device-id 0 --si <SI> --config <config>
-
-# 3. Test (5 episodes, local)
-python train_karman.py --case-name transfer_reNNN --device-id 0 --seed 41 \
-    --config <config> --calibration calibrations/reNNN/calibration.json \
-    --si <SI> --total-episodes 5 \
-    --transfer-model output/re100_karman_seed<BEST>/models/best_model.zip
-
-# 4. Production (add to crossre_transfer.sh or run directly with 200 episodes)
-```
-
-### Transfer test results (5-episode verification, 2026-07-02)
-
-| Re | Best Reward | r_cd | r_cl | r_sim | Time/ep |
-|----|------------|------|------|-------|---------|
-| 60 | 0.637 | 0.879 | 0.402 | 0.641 | 281s |
-| 200 | 0.428 | 0.677 | 0.259 | 0.387 | 186s |
-| 400 | 0.489 | 0.787 | 0.491 | 0.274 | 153s |
-
-All show rapid learning from Re100 base. r_cl remains the hardest component across all Re.
-
----
-
-## 10. CelerisLab Integration
-
-**CelerisLab is a git submodule** at `DynamisLab/CelerisLab/`.
-All Python imports use `from CelerisLab import Simulation`.
-No external paths — everything is self-contained within the repo.
-Do NOT reference `/home/frank14f/CelerisLab` anywhere.
-
----
-
-## 11. Key Parameters Reference
-
-| Parameter | Value | Where | Notes |
-|-----------|-------|-------|-------|
-| Grid | 2000×600 | config | uniform inlet, free_slip |
-| U0 | 0.01 | config | lattice inlet velocity |
-| ν (re100) | 0.004 | config | Re_D=50 (code Re=100) |
-| SI | 400-800 | calibration | varies by Re |
-| FIFO_LEN | 150 | env | history buffer |
-| CONV_LEN | 30 | env | DTW comparison window |
-| SENSOR_CC | 78 | env | sensor area→legacy conversion |
-| K_CD/K_CL | 50/100 | env | Gaussian reward coefficients |
-| W_CD/W_CL/W_SIM | 0.30/0.30/0.40 | env | reward weights |
-| n_steps | 2048 | train | PPO rollout size |
-| n_epochs | 10 | train | PPO epochs per update |
-| gamma | 0.995 | train | discount factor |
-| ACTION_SCALE | 12.0 | env | no_bias only |
-
----
-
-## 12. Bugs Found & Fixed
-
-| # | Bug | Symptom | Fix |
-|---|-----|---------|-----|
-| 1 | Simultaneous GPU startup | Kernel compilation race → reward=0.000 | Sequential launch, 7-min delay |
-| 2 | Bias FIFO not applying omega | Wrong normalization baseline | Added set_omega in bias FIFO |
-| 3 | DTW not normalized | sim always 0.90+ → flat gradient | Normalize by target uy-channel avg std |
-| 4 | Gaussian vs exp(-|x|) | Zero-crossing reward spikes | Use exp(-x² · K) |
-| 5 | n_steps=512 | Noisy curves, degradation | Use 2048 (SB3 default) |
-| 6 | deterministic eval | Sharp, noisy reward | Stochastic eval |
-| 7 | External CelerisLab paths | Permission issues, server mismatch | Use DynamisLab submodule only |
-| 8 | Manual kernel cache cleaning | Unnecessary, root-only files | CelerisLab handles internally |

src/drl_pinball/train/VARDIST_ANALYSIS.md

@@ -0,0 +1,177 @@
+# Vardist Transfer Learning — 分析报告
+
+> 日期: 2026-07-07  
+> 实验: 改变上游扰动圆柱尺寸 (0.75L / 1.5L / 2.0L)，从 re100 baseline 进行 transfer learning  
+> 所有实验使用相同超参数和物理配置（仅 dist_radius 不同）
+
+---
+
+## 1. 实验配置总览
+
+### 1.1 共享超参数
+
+| 参数 | 值 |
+|------|-----|
+| PPO n_steps | 2048 |
+| PPO batch_size | 64 |
+| PPO n_epochs | 10 |
+| Learning rate | 3e-4 |
+| Gamma | 0.995 |
+| Policy net_arch | [64, 64] |
+| Activation | sin |
+| Symmetry augmentation | prob=0.5 |
+| Episode 数 | 200 (transfer) |
+| 基座模型 | re100_karman_seed44 或 seed45 (500ep from scratch, best ≈ 0.92) |
+
+### 1.2 校准参数差异
+
+| 参数 | d075 (0.75L) | re100 (1.0L) | d15 (1.5L) | d2 (2.0L) |
+|------|:-----------:|:------------:|:----------:|:---------:|
+| **FORCE_SCALE** | 0.0018 | 0.0024 | 0.0036 | 0.0046 |
+| **SENS_SCALE** | 0.84 | 0.75 | 0.75 | 0.77 |
+| **dtw_norm_scale** | 0.146 | 0.204 | 0.307 | 0.393 |
+| **SIM_BP[1]** (zero rot) | 0.25 | 0.32 | 0.30 | 0.30 |
+| **SIM_BP[2]** (ref rot) | 0.79 | 0.82 | 0.65 | 0.65 |
+| **SIM_BP gap** | **0.54** | 0.50 | **0.35** | **0.35** |
+| **SIM_BP 来源** | 实测 | 实测 | generic 兜底 | generic 兜底 |
+| **K_CD / K_CL** | 50/100 | 50/100 | 50/100 | 50/100 |
+
+> **关键**: d075 的 SIM_BP 使用了实测值 (gap=0.54)，而 d15 和 d2 因为 `spread<0.10` 或 `better_sim<0.5` 触发了 calibrate.py 中的 generic fallback (gap=0.35)。
+
+---
+
+## 2. 训练结果
+
+### 2.1 最终指标
+
+| Case | Best Reward | Ep 1 Reward | Ep 1 r_sim | Ep 1 r_cd | 走势质量 |
+|------|:-----------:|:-----------:|:----------:|:---------:|:--------:|
+| **d15 (1.5L)** | **0.7265** (Ep 198) | 0.570 | 0.748 | 0.650 | ✅ 稳定单调上升 |
+| **d2 (2.0L)** | **0.4696** (Ep 2!) | 0.301 | 0.455 | 0.288 | ❌ Ep 2 peak 后持续退化 |
+| **d075 (0.75L)** | **0.4175** (Ep 153) | 0.023 | 0.053 | 0.012 | ❌ 持续 peak-crash 震荡 |
+
+### 2.2 对比基线：跨 Re transfer (来自同一基座模型)
+
+| Case | Best Reward | 走势 |
+|------|:-----------:|:----:|
+| re60 transfer | **0.724** | ✅ 稳定上升 |
+| re200 transfer | **0.499** | ⚠️ 缓慢但稳定 |
+
+### 2.3 Reward 走势图 (定性)
+
+```
+d15:  ▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄  ───→ 0.727  (稳步爬坡)
+d2:   ▄▀▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄  ───→ 0.470  (Ep2 昙花一现，后再未超越)
+d075: ▁▁▁▁▂▁▂▁▂▁▂▁▁▂▁▁▁▂  ───→ 0.418  (震荡不止，末班 0.053)
+```
+
+---
+
+## 3. 诊断分析
+
+### 3.1 ✅ d15 (1.5L) — 成功案例
+
+**为什么成功：**
+1. 上游圆柱放大 → 1.0L 的专家策略"不够用但方向对"，可以在此基础上升级
+2. SIM_BP 使用 generic mapping (gap=0.35)，reward 梯度均匀且有意义
+3. Ep 1 r_sim=0.748 说明初始策略在 1.5L 尾流下已经有相当不错的信号重建能力
+4. r_cd 从 0.65 涨到 0.92，r_cl 从 0.27 涨到 0.48，三个 reward 分量协作上升
+
+### 3.2 ❌ d075 (0.75L) — 最差案例
+
+**根因 1 — SIM_BP 映射问题 (最主要)**
+
+d075 是唯一一个使用实测 SIM_BP 的 case。测得的 zero-rotation similarity=0.25，reference rotation=0.79，gap=0.54。
+
+这意味着 reward 映射中 SIM_VAL 从 0.2→0.5 覆盖了 0.54 的真实 similarity 跨度，梯度被显著摊薄。当 PPO 在 reward 空间中观测到的改进信号极小时，policy 更新方向近乎随机——这完美解释了反复的 peak-crash 行为。
+
+**根因 2 — 物理域不匹配**
+
+0.75L 扰动圆柱产生的卡门涡街更弱更窄（FORCE_SCALE=0.0018，比 1.0L 低 25%）。而 pinball 圆柱仍是 1.0L 固定尺寸，它们的旋转对弱流场的控制可能"过强"——类似于用力关门但门很轻。1.0L 的专家策略不适用于小扰动场景。
+
+**根因 3 — 基座策略已接近局部最优**
+
+reference rotation 在 0.75L 场景下已给出 similarity=0.79（接近 re100 baseline 的 0.82）。DRL 要超越一个已经很接近 1.0L baseline 水平的开环策略，且 reward 梯度又被摊薄，双重不利。
+
+**证据 — Ep 1 collapse**
+
+Ep 1 reward=0.023，r_cd=0.012，r_sim=0.053。这说明 1.0L 的 expert policy 在 0.75L 场景下几乎完全不适用，不是在微调而是在重新学习。
+
+### 3.3 ❌ d2 (2.0L) — 早期 peak 后退化
+
+**根因 1 — 几何差异导致初始 mismatch**
+
+2.0L 圆柱是 1.0L 的两倍，FORCE_SCALE=0.0046（近乎翻倍）。Ep 1 r_sim=0.455（vs d15 的 0.748），说明在如此大差异下 transfer 效果甚微，几乎从接近 scratch 的状态开始。
+
+**根因 2 — Ep 2 的 0.470 是偶发性好运**
+
+```
+Ep  2: 0.470 BEST
+Ep 50: 0.138
+Ep 125: 0.299 (轻微恢复)
+Ep 200: 0.246
+```
+
+在独占 GPU 又跑了 150ep 后，从未超越 Ep 2 的 0.470。"早期 peak 后持续退化"的模式说明 Ep 2 的高 reward 是一次偶然发现的好策略，PPO 之后的探索却撞进了 reward 更低的方向且无力返回。
+
+---
+
+## 4. Ep 1 Metrics 作为先行指标的发现
+
+| Case | Ep 1 r_sim | Ep 1 r_cd | 最终 Best | Transfer 成功? |
+|------|:----------:|:---------:|:---------:|:--------------:|
+| d15 | 0.748 | 0.650 | 0.727 | ✅ |
+| d2 | 0.455 | 0.288 | 0.470 | ❌ |
+| d075 | 0.053 | 0.012 | 0.417 | ❌ |
+| re60 | 0.236 | 0.793 | 0.724 | ✅ |
+
+**推论**: Ep 1 r_sim 是预测 transfer 能否成功的强信号。r_sim≥0.5 的 case 最终都达到了 0.7+，r_sim<0.5 的 case 均未超过 0.47。例外是 re60 —— 虽然 r_sim 不高 (0.236)，但几何不变，PPO 可以快速"调回"相似度。
+
+---
+
+## 5. 改进建议
+
+### 5.1 针对 d075 (0.75L)
+
+| 优先级 | 方案 | 原理 |
+|:------:|------|------|
+| **P0** | 强制使用 generic SIM_BP mapping | 消除 SIM_BP gap=0.54 导致的平坦梯度问题 (即修改 calibrate.py 或手动替换 calibration.json 中 SIM_BP 为 [0, 0.30, 0.65, 0.79, 0.89, 1.0]) |
+| **P1** | 降低 learning rate 至 1e-4 | 减少 PPO 在高方差环境中的 over-shoot，缓解 peak-crash |
+| **P2** | 增加 episode 数至 500 | 当前 200ep 明显不足以收敛 |
+| **P3** | 不 transfer，from scratch | 因为 Ep 1 已证明 re100 policy 对 d075 高度不适配 (reward=0.023)，scratch 训练可能更稳定 |
+
+### 5.2 针对 d2 (2.0L)
+
+| 优先级 | 方案 | 原理 |
+|:------:|------|------|
+| **P0** | 不 transfer，from scratch + 500ep | Ep 1 初始 mismatch 太大，从头学习可能更高效 |
+| **P1** | transfer 但降低 lr=1e-4 + 更多 episode | 如果仍用 transfer，更保守的更新速率有助于保持策略稳定 |
+| **P2** | 加强 symmetry augmentation (prob=0.7) | 2.0L 尾流更宽，采样空间更大，更强的对称正则化可能帮助泛化 |
+| **P3** | 调整 K_CD/K_CL 以匹配 2.0L 的力尺度 | FORCE_SCALE 翻倍但 K 值不变，reward 的分量权重可能已不平衡 |
+
+### 5.3 通用改进
+
+| 优先级 | 方案 | 适用范围 |
+|:------:|------|---------|
+| **P0** | 给 calibrate.py 的 generic SIM_BP 兜底条件加宽阈值 | 所有 future case，避免 d075 式的 SIM_BP gap 问题再次出现 |
+| **P1** | 观察 Ep 1 metrics 作为 transfer 可行性的先行判断 | 如果 Ep 1 r_sim<0.5，建议直接 from scratch 而非 transfer |
+| **P2** | 对不同直径使用不同的 K_CD/K_CL 缩放 | FORCE_SCALE 变化时，reward 中 drag/lift 贡献的比例可能需要调整 |
+| **P3** | 启用 VecNormalize reward normalization | 当前 `norm_reward=False`，对小 reward 场景可能会让 PPO 的信号强度不足 |
+
+---
+
+## 6. 关键文件索引
+
+| 文件 | 路径 |
+|------|------|
+| 训练脚本 | `train_karman.py` |
+| 环境 | `env_karman.py` |
+| 校准脚本 | `calibrate.py` (generic SIM_BP 兜底逻辑在第 526-535 行) |
+| Transfer 启动脚本 | `vardist_transfer.sh` |
+| d075 校准 | `calibrations/karman_d075/calibration.json` |
+| d15 校准 | `calibrations/karman_d15/calibration.json` |
+| d2 校准 | `calibrations/karman_d2/calibration.json` |
+| re100 基线校准 | `calibrations/re100/calibration.json` |
+| d075 训练日志 | `output/transfer_karman_d075_seed44/train.log` |
+| d15 训练日志 | `output/transfer_karman_d15_seed45/train.log` |
+| d2 训练日志 | `output/transfer_karman_d2_seed45/train.log` |

src/drl_pinball/train/calibrate.py

@@ -386,6 +386,8 @@ def main() -> int:
                         help="Scene type (karman or illusion)")
     parser.add_argument("--target-diam", type=float, default=1.0,
                         help="Target cylinder diameter in L0 units (illusion only, default=1.0)")
+    parser.add_argument("--dist-radius", type=float, default=1.0,
+                        help="Disturbance cylinder radius in L0 units (karman only, default=1.0)")
     args = parser.parse_args()
 
     case = args.case
@@ -419,9 +421,11 @@ def main() -> int:
 
     # ---- Step 1: Record target (Karman: dist_cyl + sensors only) ----
     log("Step 1: Recording target signal...")
+    dist_radius = args.dist_radius * L0
+    log(f"  Dist cylinder radius = {args.dist_radius}L = {dist_radius:.1f} lattice")
     sim = Simulation(lbm_config_path=config_path, device_id=device_id)
     sim._assert_object_count_contract = lambda *a, **kw: None
-    dist_id_t = sim.add_body("circle", center=(DIST_X, CENTER_Y, 0.0), radius=1.0 * L0)
+    dist_id_t = sim.add_body("circle", center=(DIST_X, CENTER_Y, 0.0), radius=dist_radius)
     s0_t = sim.add_body("sensor", center=(SENSOR_X, CENTER_Y + 40.0, 0.0), radius=5.0)
     s1_t = sim.add_body("sensor", center=(SENSOR_X, CENTER_Y, 0.0), radius=5.0)
     s2_t = sim.add_body("sensor", center=(SENSOR_X, CENTER_Y - 40.0, 0.0), radius=5.0)
@@ -453,7 +457,7 @@ def main() -> int:
     log("Step 2: Creating training sim (all 7 objects)...")
     sim = Simulation(lbm_config_path=config_path, device_id=device_id)
     sim._assert_object_count_contract = lambda *a, **kw: None
-    dist_id = sim.add_body("circle", center=(DIST_X, CENTER_Y, 0.0), radius=1.0 * L0)
+    dist_id = sim.add_body("circle", center=(DIST_X, CENTER_Y, 0.0), radius=dist_radius)
     sensor_ids = [
         sim.add_body("sensor", center=(SENSOR_X, CENTER_Y + 40.0, 0.0), radius=5.0),
         sim.add_body("sensor", center=(SENSOR_X, CENTER_Y, 0.0), radius=5.0),
@@ -505,15 +509,34 @@ def main() -> int:
     log(f"  Stage0 sim_mean = {s0_sim:.4f}")
     log(f"  Stage1 sim_mean = {s1_sim:.4f}")
 
-    sim_bp = [0.0, s0_sim, s1_sim,
+    # Build SIM_BP: always [0, worst_measured, better_measured, ..., 1.0]
-              s1_sim + (1.0 - s1_sim) * 0.4,
+    if s1_sim < s0_sim:
-              s1_sim + (1.0 - s1_sim) * 0.7,
+        worst_sim = s1_sim
-              1.0]
+        better_sim = s0_sim
-    sim_val = [0.0, 0.2, 0.5, 0.8, 0.9, 1.0]
+    else:
+        worst_sim = s0_sim
+        better_sim = s1_sim
 
-    for i in range(1, len(sim_bp)):
+    # When stage0 and stage1 are too close (|s1-s0| < 0.05), the measured
-        if sim_bp[i] <= sim_bp[i - 1]:
+    # SIM_BP collapses to near-zero dynamic range.  Fall back to a generic
-            sim_bp[i] = sim_bp[i - 1] + 0.01
+    # mapping anchored on the well-behaved re100 baseline (s0~0.32, s1~0.82).
+    # This gives the DRL a meaningful reward gradient regardless of the
+    # open-loop baselines.
+    spread = abs(s1_sim - s0_sim)
+    if spread < 0.10 or better_sim < 0.5:
+        log(f"  Spread={spread:.3f} too small or better<0.5 — using generic SIM_BP mapping")
+        sim_bp = [0.0, 0.30, 0.65, 0.79, 0.89, 1.0]
+        sim_val = [0.0, 0.20, 0.50, 0.80, 0.90, 1.0]
+    else:
+        sim_bp = [0.0, worst_sim, better_sim,
+                  better_sim + (1.0 - better_sim) * 0.4,
+                  better_sim + (1.0 - better_sim) * 0.7,
+                  1.0]
+        sim_val = [0.0, 0.2, 0.5, 0.8, 0.9, 1.0]
+
+        for i in range(1, len(sim_bp)):
+            if sim_bp[i] <= sim_bp[i - 1]:
+                sim_bp[i] = sim_bp[i - 1] + 0.01
 
     log(f"  SIM_BP (raw) = {[f'{x:.4f}' for x in sim_bp]}")
     log(f"  SIM_VAL = {sim_val}")
@@ -540,6 +563,7 @@ def main() -> int:
     # ---- Step 6: Write calibration.json ----
     calibration = {
         "case": case,
+        "dist_radius": args.dist_radius,
         "grid": {"nx": NX, "ny": NY},
         "config_path": config_path,
         "SI": si,
@@ -551,8 +575,8 @@ def main() -> int:
         "dtw_norm_scale": float(dtw_norm_scale),
         "SIM_BP": [float(x) for x in sim_bp],
         "SIM_VAL": [float(x) for x in sim_val],
-        "K_CD": K_CD_ILLUSION,
+        "K_CD": K_CD,
-        "K_CL": K_CL_ILLUSION,
+        "K_CL": K_CL,
         "W_CD": W_CD,
         "W_CL": W_CL,
         "W_SIM": W_SIM,

src/drl_pinball/train/calibrations/ill_075L/calibration.json

@@ -1,5 +1,5 @@
 {
-  "case": "illusion_075L",
+  "case": "ill_075L",
   "scene": "illusion",
   "target_diam": 0.75,
   "grid": {

src/drl_pinball/train/calibrations/ill_15L/calibration.json

@@ -1,5 +1,5 @@
 {
-  "case": "illusion_15L",
+  "case": "ill_15L",
   "scene": "illusion",
   "target_diam": 1.5,
   "grid": {

src/drl_pinball/train/calibrations/ill_1L/calibration.json

@@ -1,5 +1,5 @@
 {
-  "case": "illusion_1L",
+  "case": "ill_1L",
   "scene": "illusion",
   "target_diam": 1.0,
   "grid": {

src/drl_pinball/train/calibrations/ill_2L/calibration.json

@@ -1,5 +1,5 @@
 {
-  "case": "illusion_2L",
+  "case": "ill_2L",
   "scene": "illusion",
   "target_diam": 2.0,
   "grid": {

src/drl_pinball/train/calibrations/kar_d075_sc/calibration.json

@@ -0,0 +1,50 @@
+{
+  "case": "kar_d075_sc",
+  "dist_radius": 0.75,
+  "grid": {
+    "nx": 2000,
+    "ny": 600
+  },
+  "config_path": "/root/private_data/DynamisLab/configs/config_lbm_karman_2000x600.json",
+  "SI": 800,
+  "FIFO_LEN": 150,
+  "CONV_LEN": 30,
+  "SENSOR_CC": 78.0,
+  "FORCE_SCALE": 0.0018,
+  "SENS_SCALE": 0.84,
+  "dtw_norm_scale": 0.146,
+  "SIM_BP": [
+    0.0,
+    0.3,
+    0.65,
+    0.79,
+    0.89,
+    1.0
+  ],
+  "SIM_VAL": [
+    0.0,
+    0.2,
+    0.5,
+    0.8,
+    0.9,
+    1.0
+  ],
+  "K_CD": 50.0,
+  "K_CL": 100.0,
+  "W_CD": 0.3,
+  "W_CL": 0.3,
+  "W_SIM": 0.4,
+  "FLOOR_CD": 0.1,
+  "FLOOR_CL": 0.1,
+  "FLOOR_SIM": 0.1,
+  "FLOOR_PENALTY": 0.05,
+  "ACTION_SCALE": 12.0,
+  "ACTION_BIAS": [
+    0.0,
+    0.0,
+    0.0
+  ],
+  "U0": 0.01,
+  "RADIUS": 10.0,
+  "L0": 20.0
+}

src/drl_pinball/train/calibrations/kar_d075_tr/calibration.json

@@ -0,0 +1,50 @@
+{
+  "case": "kar_d075_tr",
+  "dist_radius": 0.75,
+  "grid": {
+    "nx": 2000,
+    "ny": 600
+  },
+  "config_path": "/home/frank14f/DynamisLab/configs/config_lbm_karman_2000x600.json",
+  "SI": 800,
+  "FIFO_LEN": 150,
+  "CONV_LEN": 30,
+  "SENSOR_CC": 78.0,
+  "FORCE_SCALE": 0.0018,
+  "SENS_SCALE": 0.84,
+  "dtw_norm_scale": 0.146,
+  "SIM_BP": [
+    0.0,
+    0.25,
+    0.79,
+    0.88,
+    0.94,
+    1.0
+  ],
+  "SIM_VAL": [
+    0.0,
+    0.2,
+    0.5,
+    0.8,
+    0.9,
+    1.0
+  ],
+  "K_CD": 50.0,
+  "K_CL": 100.0,
+  "W_CD": 0.3,
+  "W_CL": 0.3,
+  "W_SIM": 0.4,
+  "FLOOR_CD": 0.1,
+  "FLOOR_CL": 0.1,
+  "FLOOR_SIM": 0.1,
+  "FLOOR_PENALTY": 0.05,
+  "ACTION_SCALE": 12.0,
+  "ACTION_BIAS": [
+    0.0,
+    0.0,
+    0.0
+  ],
+  "U0": 0.01,
+  "RADIUS": 10.0,
+  "L0": 20.0
+}

src/drl_pinball/train/calibrations/kar_d15_sc/calibration.json

@@ -0,0 +1,50 @@
+{
+  "case": "kar_d15_sc",
+  "dist_radius": 1.5,
+  "grid": {
+    "nx": 2000,
+    "ny": 600
+  },
+  "config_path": "/root/private_data/DynamisLab/configs/config_lbm_karman_2000x600.json",
+  "SI": 800,
+  "FIFO_LEN": 150,
+  "CONV_LEN": 30,
+  "SENSOR_CC": 78.0,
+  "FORCE_SCALE": 0.0036,
+  "SENS_SCALE": 0.75,
+  "dtw_norm_scale": 0.307,
+  "SIM_BP": [
+    0.0,
+    0.3,
+    0.65,
+    0.79,
+    0.89,
+    1.0
+  ],
+  "SIM_VAL": [
+    0.0,
+    0.2,
+    0.5,
+    0.8,
+    0.9,
+    1.0
+  ],
+  "K_CD": 50.0,
+  "K_CL": 100.0,
+  "W_CD": 0.3,
+  "W_CL": 0.3,
+  "W_SIM": 0.4,
+  "FLOOR_CD": 0.1,
+  "FLOOR_CL": 0.1,
+  "FLOOR_SIM": 0.1,
+  "FLOOR_PENALTY": 0.05,
+  "ACTION_SCALE": 12.0,
+  "ACTION_BIAS": [
+    0.0,
+    0.0,
+    0.0
+  ],
+  "U0": 0.01,
+  "RADIUS": 10.0,
+  "L0": 20.0
+}

src/drl_pinball/train/calibrations/kar_d15_tr/calibration.json

@@ -0,0 +1,50 @@
+{
+  "case": "kar_d15_tr",
+  "dist_radius": 1.5,
+  "grid": {
+    "nx": 2000,
+    "ny": 600
+  },
+  "config_path": "/home/frank14f/DynamisLab/configs/config_lbm_karman_2000x600.json",
+  "SI": 800,
+  "FIFO_LEN": 150,
+  "CONV_LEN": 30,
+  "SENSOR_CC": 78.0,
+  "FORCE_SCALE": 0.0036,
+  "SENS_SCALE": 0.75,
+  "dtw_norm_scale": 0.307,
+  "SIM_BP": [
+    0.0,
+    0.3,
+    0.65,
+    0.79,
+    0.89,
+    1.0
+  ],
+  "SIM_VAL": [
+    0.0,
+    0.2,
+    0.5,
+    0.8,
+    0.9,
+    1.0
+  ],
+  "K_CD": 50.0,
+  "K_CL": 100.0,
+  "W_CD": 0.3,
+  "W_CL": 0.3,
+  "W_SIM": 0.4,
+  "FLOOR_CD": 0.1,
+  "FLOOR_CL": 0.1,
+  "FLOOR_SIM": 0.1,
+  "FLOOR_PENALTY": 0.05,
+  "ACTION_SCALE": 12.0,
+  "ACTION_BIAS": [
+    0.0,
+    0.0,
+    0.0
+  ],
+  "U0": 0.01,
+  "RADIUS": 10.0,
+  "L0": 20.0
+}

src/drl_pinball/train/calibrations/kar_d2_sc/calibration.json

@@ -0,0 +1,50 @@
+{
+  "case": "kar_d2_sc",
+  "dist_radius": 2.0,
+  "grid": {
+    "nx": 2000,
+    "ny": 600
+  },
+  "config_path": "/root/private_data/DynamisLab/configs/config_lbm_karman_2000x600.json",
+  "SI": 800,
+  "FIFO_LEN": 150,
+  "CONV_LEN": 30,
+  "SENSOR_CC": 78.0,
+  "FORCE_SCALE": 0.0046,
+  "SENS_SCALE": 0.77,
+  "dtw_norm_scale": 0.393,
+  "SIM_BP": [
+    0.0,
+    0.3,
+    0.65,
+    0.79,
+    0.89,
+    1.0
+  ],
+  "SIM_VAL": [
+    0.0,
+    0.2,
+    0.5,
+    0.8,
+    0.9,
+    1.0
+  ],
+  "K_CD": 50.0,
+  "K_CL": 100.0,
+  "W_CD": 0.3,
+  "W_CL": 0.3,
+  "W_SIM": 0.4,
+  "FLOOR_CD": 0.1,
+  "FLOOR_CL": 0.1,
+  "FLOOR_SIM": 0.1,
+  "FLOOR_PENALTY": 0.05,
+  "ACTION_SCALE": 12.0,
+  "ACTION_BIAS": [
+    0.0,
+    0.0,
+    0.0
+  ],
+  "U0": 0.01,
+  "RADIUS": 10.0,
+  "L0": 20.0
+}

src/drl_pinball/train/calibrations/kar_d2_tr/calibration.json

@@ -0,0 +1,50 @@
+{
+  "case": "kar_d2_tr",
+  "dist_radius": 2.0,
+  "grid": {
+    "nx": 2000,
+    "ny": 600
+  },
+  "config_path": "/home/frank14f/DynamisLab/configs/config_lbm_karman_2000x600.json",
+  "SI": 800,
+  "FIFO_LEN": 150,
+  "CONV_LEN": 30,
+  "SENSOR_CC": 78.0,
+  "FORCE_SCALE": 0.0046,
+  "SENS_SCALE": 0.77,
+  "dtw_norm_scale": 0.393,
+  "SIM_BP": [
+    0.0,
+    0.3,
+    0.65,
+    0.79,
+    0.89,
+    1.0
+  ],
+  "SIM_VAL": [
+    0.0,
+    0.2,
+    0.5,
+    0.8,
+    0.9,
+    1.0
+  ],
+  "K_CD": 50.0,
+  "K_CL": 100.0,
+  "W_CD": 0.3,
+  "W_CL": 0.3,
+  "W_SIM": 0.4,
+  "FLOOR_CD": 0.1,
+  "FLOOR_CL": 0.1,
+  "FLOOR_SIM": 0.1,
+  "FLOOR_PENALTY": 0.05,
+  "ACTION_SCALE": 12.0,
+  "ACTION_BIAS": [
+    0.0,
+    0.0,
+    0.0
+  ],
+  "U0": 0.01,
+  "RADIUS": 10.0,
+  "L0": 20.0
+}

src/drl_pinball/train/calibrations/kar_re100/calibration.json

@@ -1,5 +1,5 @@
 {
-  "case": "re100",
+  "case": "kar_re100",
   "grid": {
     "nx": 2000,
     "ny": 600

src/drl_pinball/train/calibrations/kar_re200/calibration.json

@@ -1,5 +1,5 @@
 {
-  "case": "re200",
+  "case": "kar_re200",
   "grid": {
     "nx": 2000,
     "ny": 600

src/drl_pinball/train/calibrations/kar_re200_sc/calibration.json

@@ -0,0 +1,49 @@
+{
+  "case": "kar_re200_sc",
+  "grid": {
+    "nx": 2000,
+    "ny": 600
+  },
+  "config_path": "/root/private_data/DynamisLab/configs/config_lbm_karman_2000x600_re200.json",
+  "SI": 500,
+  "FIFO_LEN": 150,
+  "CONV_LEN": 30,
+  "SENSOR_CC": 78.0,
+  "FORCE_SCALE": 0.0026,
+  "SENS_SCALE": 0.9,
+  "dtw_norm_scale": 0.269,
+  "SIM_BP": [
+    0.0,
+    0.3,
+    0.65,
+    0.79,
+    0.89,
+    1.0
+  ],
+  "SIM_VAL": [
+    0.0,
+    0.2,
+    0.5,
+    0.8,
+    0.9,
+    1.0
+  ],
+  "K_CD": 50.0,
+  "K_CL": 100.0,
+  "W_CD": 0.3,
+  "W_CL": 0.3,
+  "W_SIM": 0.4,
+  "FLOOR_CD": 0.1,
+  "FLOOR_CL": 0.1,
+  "FLOOR_SIM": 0.1,
+  "FLOOR_PENALTY": 0.05,
+  "ACTION_SCALE": 12.0,
+  "ACTION_BIAS": [
+    0.0,
+    0.0,
+    0.0
+  ],
+  "U0": 0.01,
+  "RADIUS": 10.0,
+  "L0": 20.0
+}

src/drl_pinball/train/calibrations/kar_re400/calibration.json

@@ -1,5 +1,5 @@
 {
-  "case": "re400",
+  "case": "kar_re400",
   "grid": {
     "nx": 2000,
     "ny": 600

src/drl_pinball/train/calibrations/kar_re400_sc/calibration.json

@@ -0,0 +1,49 @@
+{
+  "case": "kar_re400_sc",
+  "grid": {
+    "nx": 2000,
+    "ny": 600
+  },
+  "config_path": "/root/private_data/DynamisLab/configs/config_lbm_karman_2000x600_re400.json",
+  "SI": 400,
+  "FIFO_LEN": 150,
+  "CONV_LEN": 30,
+  "SENSOR_CC": 78.0,
+  "FORCE_SCALE": 0.0042,
+  "SENS_SCALE": 0.98,
+  "dtw_norm_scale": 0.31,
+  "SIM_BP": [
+    0.0,
+    0.3,
+    0.65,
+    0.79,
+    0.89,
+    1.0
+  ],
+  "SIM_VAL": [
+    0.0,
+    0.2,
+    0.5,
+    0.8,
+    0.9,
+    1.0
+  ],
+  "K_CD": 50.0,
+  "K_CL": 100.0,
+  "W_CD": 0.3,
+  "W_CL": 0.3,
+  "W_SIM": 0.4,
+  "FLOOR_CD": 0.1,
+  "FLOOR_CL": 0.1,
+  "FLOOR_SIM": 0.1,
+  "FLOOR_PENALTY": 0.05,
+  "ACTION_SCALE": 12.0,
+  "ACTION_BIAS": [
+    0.0,
+    0.0,
+    0.0
+  ],
+  "U0": 0.01,
+  "RADIUS": 10.0,
+  "L0": 20.0
+}

src/drl_pinball/train/calibrations/kar_re60/calibration.json

@@ -1,5 +1,5 @@
 {
-  "case": "re60",
+  "case": "kar_re60",
   "grid": {
     "nx": 2000,
     "ny": 600

src/drl_pinball/train/calibrations/kar_re60_sc/calibration.json

@@ -0,0 +1,49 @@
+{
+  "case": "kar_re60_sc",
+  "grid": {
+    "nx": 2000,
+    "ny": 600
+  },
+  "config_path": "/root/private_data/DynamisLab/configs/config_lbm_karman_2000x600_re60.json",
+  "SI": 800,
+  "FIFO_LEN": 150,
+  "CONV_LEN": 30,
+  "SENSOR_CC": 78.0,
+  "FORCE_SCALE": 0.0021,
+  "SENS_SCALE": 0.72,
+  "dtw_norm_scale": 0.107,
+  "SIM_BP": [
+    0.0,
+    0.3,
+    0.65,
+    0.79,
+    0.89,
+    1.0
+  ],
+  "SIM_VAL": [
+    0.0,
+    0.2,
+    0.5,
+    0.8,
+    0.9,
+    1.0
+  ],
+  "K_CD": 50.0,
+  "K_CL": 100.0,
+  "W_CD": 0.3,
+  "W_CL": 0.3,
+  "W_SIM": 0.4,
+  "FLOOR_CD": 0.1,
+  "FLOOR_CL": 0.1,
+  "FLOOR_SIM": 0.1,
+  "FLOOR_PENALTY": 0.05,
+  "ACTION_SCALE": 12.0,
+  "ACTION_BIAS": [
+    0.0,
+    0.0,
+    0.0
+  ],
+  "U0": 0.01,
+  "RADIUS": 10.0,
+  "L0": 20.0
+}

src/drl_pinball/train/crossre_transfer.sh

@@ -1,119 +0,0 @@
-#!/bin/bash
-# Sequential cross-Re transfer learning: Re60 -> Re200 -> Re400
-# Each: calibrate (~5 min) + train N episodes
-#
-# Usage (local test, 5 episodes):
-#   bash crossre_transfer.sh --re-list 60 --test-episodes 5
-#
-# Usage (production on server, 200 episodes each):
-#   bash crossre_transfer.sh --re-list 60,200,400
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_DIR="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-TRAIN_DIR="$SCRIPT_DIR"
-CONFIG_DIR="$REPO_DIR/configs"
-# TODO: BEFORE PUSHING TO SERVER, update BEST_MODEL to the correct path
-BEST_MODEL="$TRAIN_DIR/output/re100_karman_seed41/models/best_model.zip"
-GPU=0
-EPISODES=200
-TEST_EPISODES=0
-RE_LIST=""
-LOG_BASE="/tmp/crossre_transfer"
-CONDA_ENV="pycuda_3_10"
-
-usage() {
-    echo "Usage: $0 [--re-list 60,200,400] [--test-episodes N] [--best-model PATH]"
-    echo "  --re-list        Comma-separated Re numbers (default: 60,200,400)"
-    echo "  --test-episodes  Run only N episodes per Re for quick verification"
-    echo "  --best-model     Path to Re100 best model .zip"
-    exit 1
-}
-
-while [[ $# -gt 0 ]]; do
-    case "$1" in
-        --re-list)       RE_LIST="$2"; shift 2 ;;
-        --test-episodes) TEST_EPISODES="$2"; shift 2 ;;
-        --best-model)    BEST_MODEL="$2"; shift 2 ;;
-        *)               echo "Unknown option: $1"; usage ;;
-    esac
-done
-
-if [[ -z "$RE_LIST" ]]; then
-    RE_LIST="60,200,400"
-fi
-
-IFS=',' read -ra RE_ARR <<< "$RE_LIST"
-
-echo "=== Cross-Re Transfer ==="
-echo "  Re list:         ${RE_ARR[*]}"
-echo "  Re60: base=seed43, train=seed43"
-echo "  Re200: base=seed45, train=seed45"
-echo "  Re400: base=seed43, train=seed43"
-echo "  Episodes:        ${EPISODES} (test-mode: ${TEST_EPISODES})"
-echo "  GPU:             ${GPU}"
-echo ""
-
-mkdir -p "$LOG_BASE"
-
-if [[ "$TEST_EPISODES" -gt 0 ]]; then
-    EPISODES="$TEST_EPISODES"
-    echo "  TEST MODE: only $TEST_EPISODES episodes per Re"
-fi
-
-for re in "${RE_ARR[@]}"; do
-    case $re in
-        60)  SI=800;  vis_label="re60";  TRAIN_SEED=43
-             BEST_MODEL="$TRAIN_DIR/output/re100_karman_seed43/models/best_model.zip" ;;
-        200) SI=500;  vis_label="re200"; TRAIN_SEED=45
-             BEST_MODEL="$TRAIN_DIR/output/re100_karman_seed45/models/best_model.zip" ;;
-        400) SI=400;  vis_label="re400"; TRAIN_SEED=43
-             BEST_MODEL="$TRAIN_DIR/output/re100_karman_seed43/models/best_model.zip" ;;
-        *)   echo "ERROR: Unknown Re=$re (supported: 60, 200, 400)"; exit 1 ;;
-    esac
-    CONFIG="$CONFIG_DIR/config_lbm_karman_2000x600_${vis_label}.json"
-    CASE="transfer_${vis_label}"
-    LOG="$LOG_BASE/${vis_label}_seed${TRAIN_SEED}.log"
-
-    if [[ ! -f "$BEST_MODEL" ]]; then
-        echo "ERROR: Best model not found: $BEST_MODEL" | tee -a "$LOG_BASE/summary.log"
-        exit 1
-    fi
-
-    echo "=== $(date): Starting $CASE (SI=$SI) ===" | tee -a "$LOG"
-
-    if [[ ! -f "$CONFIG" ]]; then
-        echo "  ERROR: Config not found: $CONFIG" | tee -a "$LOG"
-        exit 1
-    fi
-
-    # Step 1: Calibrate (skip if calibration.json already exists)
-    CAL_JSON="$TRAIN_DIR/calibrations/$vis_label/calibration.json"
-    if [[ -f "$CAL_JSON" ]]; then
-        echo "  [SKIP] Calibration already exists: $CAL_JSON" | tee -a "$LOG"
-        echo "  (Delete calibrations/$vis_label/ to force re-calibration)"
-    else
-        echo "  [$(date '+%H:%M:%S')] Calibrating..." | tee -a "$LOG"
-        conda run --no-capture-output -n "$CONDA_ENV" python -u \
-            "$TRAIN_DIR/calibrate.py" \
-            --case "$vis_label" --device-id $GPU --si $SI \
-            --config "$CONFIG" >> "$LOG" 2>&1
-        echo "  [$(date '+%H:%M:%S')] Calibration done." | tee -a "$LOG"
-    fi
-
-    # Step 2: Train with transfer
-    echo "  [$(date '+%H:%M:%S')] Training ${EPISODES} episodes..." | tee -a "$LOG"
-    conda run --no-capture-output -n "$CONDA_ENV" python -u \
-        "$TRAIN_DIR/train_karman.py" \
-        --case-name "$CASE" --device-id $GPU --seed $TRAIN_SEED \
-        --config "$CONFIG" \
-        --calibration "$CAL_JSON" \
-        --si $SI --total-episodes $EPISODES \
-        --transfer-model "$BEST_MODEL" >> "$LOG" 2>&1
-    echo "  [$(date '+%H:%M:%S')] Training done." | tee -a "$LOG"
-
-    echo "=== $(date): $CASE complete ===" | tee -a "$LOG"
-    echo ""
-done
-
-echo "=== ALL DONE ===" | tee -a "$LOG_BASE/summary.log"

src/drl_pinball/train/env_karman.py

@@ -114,12 +114,13 @@ class ActionSmoother:
 
 
 # ---------------------------------------------------------------------------
-def record_target(config_path: str, device_id: int, si: int) -> np.ndarray:
+def record_target(config_path: str, device_id: int, si: int,
+                  dist_radius: float = 1.0) -> np.ndarray:
     """Record target signal (dist_cyl + sensors, no pinball)."""
     warmup = int(4.0 * NX / U0)
     sim = Simulation(lbm_config_path=config_path, device_id=device_id)
     sim._assert_object_count_contract = lambda *a, **kw: None
-    sim.add_body("circle", center=(DIST_X, CENTER_Y, 0.0), radius=1.0 * L0)
+    sim.add_body("circle", center=(DIST_X, CENTER_Y, 0.0), radius=dist_radius * L0)
     s0 = sim.add_body("sensor", center=(SENSOR_X, CENTER_Y + 40.0, 0.0), radius=5.0)
     s1 = sim.add_body("sensor", center=(SENSOR_X, CENTER_Y, 0.0), radius=5.0)
     s2 = sim.add_body("sensor", center=(SENSOR_X, CENTER_Y - 40.0, 0.0), radius=5.0)
@@ -236,7 +237,8 @@ class KarmanCloakEnv(gym.Env):
         self.sim = Simulation(lbm_config_path=self._config_path, device_id=self.device_id)
         self.sim._assert_object_count_contract = lambda *a, **kw: None
 
-        self.dist_id = self.sim.add_body("circle", center=(DIST_X, CENTER_Y, 0.0), radius=1.0 * L0)
+        dist_radius = float(self._cal.get("dist_radius", 1.0))
+        self.dist_id = self.sim.add_body("circle", center=(DIST_X, CENTER_Y, 0.0), radius=dist_radius * L0)
         self.sensor_ids = [
             self.sim.add_body("sensor", center=(SENSOR_X, CENTER_Y + 40.0, 0.0), radius=5.0),
             self.sim.add_body("sensor", center=(SENSOR_X, CENTER_Y, 0.0), radius=5.0),

src/drl_pinball/train/extend_transfer.sh

@@ -1,81 +0,0 @@
-#!/bin/bash
-# Extend cross-Re transfer training from best_model (all seed43).
-# Re60: +200ep, Re200: +400ep, Re400: +400ep. Sequential GPU 0.
-#
-# Conservative fine-tune: lr=1e-4 (↓3x), n_epochs=5 (↓2x)
-# Symmetry-prob keeps default 0.5.
-#
-# Output naming: transfer_re60ext → train_karman appends _seed43
-#   → transfer_re60ext_seed43, transfer_re200ext_seed43, transfer_re400ext_seed43
-#
-# Timetable (SI → s/ep @ n_epochs=5 → total):
-#   Re60  SI=800  ~100s/ep  →  200ep ≈ 5.5h
-#   Re200 SI=500  ~ 68s/ep  →  400ep ≈ 7.5h
-#   Re400 SI=400  ~ 60s/ep  →  400ep ≈ 6.7h
-#   ─────────────────────────────────────────
-#   Total                          ≈ 19.7h
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_DIR="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-CONFIG_DIR="$REPO_DIR/configs"
-TRAIN_DIR="$SCRIPT_DIR"
-GPU=0
-SEED=43
-CONDA_ENV="pycuda_3_10"
-LOG_BASE="/tmp/extend_transfer"
-
-declare -A RE_SI   RE_EP
-RE_SI[60]=800;   RE_EP[60]=200
-RE_SI[200]=500;  RE_EP[200]=400
-RE_SI[400]=400;  RE_EP[400]=400
-
-RE_LIST="${1:-60,200,400}"
-IFS=',' read -ra RE_ARR <<< "$RE_LIST"
-
-mkdir -p "$LOG_BASE"
-
-echo "=== Extend Cross-Re Transfer (seed43) ==="
-echo "  Output dirs: transfer_{re}ext_seed43/"
-echo "  Hyperparams: lr=1e-4, n_epochs=5, symmetry=0.5"
-echo "  Re60:  +200ep (~5.5h, SI=800)"
-echo "  Re200: +400ep (~7.5h, SI=500)"
-echo "  Re400: +400ep (~6.7h, SI=400)"
-echo "  ────────────────────────────────"
-echo "  Total: ~19.7h"
-echo ""
-
-for re in "${RE_ARR[@]}"; do
-    vis="re${re}"
-    si=${RE_SI[$re]}
-    extra=${RE_EP[$re]}
-
-    CONFIG="$CONFIG_DIR/config_lbm_karman_2000x600_${vis}.json"
-    CAL_JSON="$TRAIN_DIR/calibrations/${vis}/calibration.json"
-    CASE="transfer_${vis}"
-    BEST_SRC="$TRAIN_DIR/output/${CASE}_seed${SEED}/models/best_model.zip"
-    EXT_CASE="${CASE}ext"      # → transfer_re60ext_seed43
-
-    if [[ ! -f "$BEST_SRC" ]]; then
-        echo "[SKIP] ${vis}: best_model not found — ${CASE}_seed${SEED} (still training?)"
-        continue
-    fi
-
-    LOG="$LOG_BASE/${vis}_ext.log"
-    echo "=== $(date): Extending ${vis} +${extra}ep (SI=$si) ===" | tee -a "$LOG"
-    echo "  Source: $BEST_SRC" | tee -a "$LOG"
-    echo "  Output: ${EXT_CASE}_seed${SEED}/" | tee -a "$LOG"
-
-    conda run --no-capture-output -n "$CONDA_ENV" python -u \
-        "$TRAIN_DIR/train_karman.py" \
-        --case-name "$EXT_CASE" --device-id $GPU --seed $SEED \
-        --config "$CONFIG" --calibration "$CAL_JSON" \
-        --si $si --total-episodes $extra \
-        --lr 1e-4 --n-epochs 5 \
-        --transfer-model "$BEST_SRC" >> "$LOG" 2>&1
-
-    echo "  [$(date '+%H:%M:%S')] Done." | tee -a "$LOG"
-    echo ""
-done
-
-echo "=== ALL EXTENSIONS DONE ===" | tee -a "$LOG_BASE/summary.log"

src/drl_pinball/train/launch_075L.sh

@@ -1,32 +0,0 @@
-#!/bin/bash
-# Launch Illusion 0.75L training on GPU2, seed 43, 500 episodes
-# Usage: bash launch_075L.sh
-# !! Wait 2 min after launching 2L on GPU0 before running this script
-#    (to avoid kernel compilation race)
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_DIR="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-
-CASE="illusion_075L"
-SEED=43
-DEVICE=2
-CONFIG="$REPO_DIR/configs/config_lbm_karman_2000x600.json"
-CAL="$SCRIPT_DIR/calibrations/$CASE/calibration.json"
-OUT_DIR="$SCRIPT_DIR/output/${CASE}_seed${SEED}"
-
-mkdir -p "$OUT_DIR"
-
-cd "$SCRIPT_DIR"
-
-nohup conda run --no-capture-output -n pycuda_3_10 python -u train_illusion.py \
-    --case-name "$CASE" \
-    --device-id "$DEVICE" \
-    --seed "$SEED" \
-    --total-episodes 500 \
-    --config "$CONFIG" \
-    --calibration "$CAL" \
-    > "$OUT_DIR/nohup.log" 2>&1 &
-
-echo "0.75L launched on GPU$DEVICE, seed=$SEED, PID=$!"
-echo "Monitor: tail -f output/${CASE}_seed${SEED}/train.log"

src/drl_pinball/train/launch_15L.sh

@@ -1,32 +0,0 @@
-#!/bin/bash
-# Launch Illusion 1.5L training on GPU1, seed 43, 500 episodes
-# Usage: bash launch_15L.sh
-# !! Wait 2 min after launching 1L on GPU0 before running this script
-#    (to avoid kernel compilation race)
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_DIR="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-
-CASE="illusion_15L"
-SEED=43
-DEVICE=1
-CONFIG="$REPO_DIR/configs/config_lbm_karman_2000x600.json"
-CAL="$SCRIPT_DIR/calibrations/$CASE/calibration.json"
-OUT_DIR="$SCRIPT_DIR/output/${CASE}_seed${SEED}"
-
-mkdir -p "$OUT_DIR"
-
-cd "$SCRIPT_DIR"
-
-nohup conda run --no-capture-output -n pycuda_3_10 python -u train_illusion.py \
-    --case-name "$CASE" \
-    --device-id "$DEVICE" \
-    --seed "$SEED" \
-    --total-episodes 500 \
-    --config "$CONFIG" \
-    --calibration "$CAL" \
-    > "$OUT_DIR/nohup.log" 2>&1 &
-
-echo "1.5L launched on GPU$DEVICE, seed=$SEED, PID=$!"
-echo "Monitor: tail -f output/${CASE}_seed${SEED}/train.log"

src/drl_pinball/train/launch_1L.sh

@@ -1,30 +0,0 @@
-#!/bin/bash
-# Launch Illusion 1L training on GPU0, seed 43, 500 episodes
-# Usage: bash launch_1L.sh
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_DIR="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-
-CASE="illusion_1L"
-SEED=43
-DEVICE=0
-CONFIG="$REPO_DIR/configs/config_lbm_karman_2000x600.json"
-CAL="$SCRIPT_DIR/calibrations/$CASE/calibration.json"
-OUT_DIR="$SCRIPT_DIR/output/${CASE}_seed${SEED}"
-
-mkdir -p "$OUT_DIR"
-
-cd "$SCRIPT_DIR"
-
-nohup conda run --no-capture-output -n pycuda_3_10 python -u train_illusion.py \
-    --case-name "$CASE" \
-    --device-id "$DEVICE" \
-    --seed "$SEED" \
-    --total-episodes 500 \
-    --config "$CONFIG" \
-    --calibration "$CAL" \
-    > "$OUT_DIR/nohup.log" 2>&1 &
-
-echo "1L launched on GPU$DEVICE, seed=$SEED, PID=$!"
-echo "Monitor: tail -f output/${CASE}_seed${SEED}/train.log"

src/drl_pinball/train/launch_2L.sh

@@ -1,32 +0,0 @@
-#!/bin/bash
-# Launch Illusion 2L training on GPU0, seed 43, 500 episodes
-# Usage: bash launch_2L.sh
-# !! Wait 2 min after launching 15L on GPU1 before running this script
-#    (to avoid kernel compilation race)
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_DIR="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-
-CASE="illusion_2L"
-SEED=43
-DEVICE=0
-CONFIG="$REPO_DIR/configs/config_lbm_karman_2000x600.json"
-CAL="$SCRIPT_DIR/calibrations/$CASE/calibration.json"
-OUT_DIR="$SCRIPT_DIR/output/${CASE}_seed${SEED}"
-
-mkdir -p "$OUT_DIR"
-
-cd "$SCRIPT_DIR"
-
-nohup conda run --no-capture-output -n pycuda_3_10 python -u train_illusion.py \
-    --case-name "$CASE" \
-    --device-id "$DEVICE" \
-    --seed "$SEED" \
-    --total-episodes 500 \
-    --config "$CONFIG" \
-    --calibration "$CAL" \
-    > "$OUT_DIR/nohup.log" 2>&1 &
-
-echo "2L launched on GPU$DEVICE, seed=$SEED, PID=$!"
-echo "Monitor: tail -f output/${CASE}_seed${SEED}/train.log"

src/drl_pinball/train/launch_multi.sh

@@ -1,141 +0,0 @@
-#!/usr/bin/env bash
-# launch_multi.sh — Sequential multi-GPU training launcher for server deployment.
-#
-# Starts Karman Cloak training on multiple GPUs sequentially, with a configurable
-# delay between launches to avoid CelerisLab kernel compilation race conditions.
-#
-# Usage:
-#   bash launch_multi.sh --case-name re100_karman --seeds 42,43,44,45,46,47 \
-#       --gpus 0,1,2,3,4,5 --episodes 500 \
-#       --config configs/config_lbm_karman_2000x600.json \
-#       --calibration calibrations/re100/calibration.json
-#
-#   # Transfer learning from a base model
-#   bash launch_multi.sh --case-name re200_karman --seeds 42,43,44 \
-#       --gpus 0,1,2 --episodes 500 \
-#       --config configs/config_lbm_karman_2000x600_re200.json \
-#       --calibration calibrations/re200/calibration.json \
-#       --transfer output/re100_karman_seed42/models/best_model.zip
-#
-# Requirements:
-#   - conda env pycuda_3_10
-#   - CelerisLab submodule at DynamisLab/CelerisLab
-#   - train_karman.py, env_karman.py, symmetry_wrapper.py in same directory
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-# --- Defaults ---
-CASE_NAME=""
-SEEDS=""
-GPUS=""
-EPISODES=500
-CONFIG=""
-CALIBRATION=""
-TRANSFER=""
-DELAY_SECONDS=420  # 7 minutes between launches
-CONDA_ENV="pycuda_3_10"
-
-usage() {
-    echo "Usage: $0 --case-name NAME --seeds S1,S2,... --gpus G1,G2,... [options]"
-    echo ""
-    echo "Required:"
-    echo "  --case-name    NAME     Case name for output dirs"
-    echo "  --seeds        S1,S2    Comma-separated seed values"
-    echo "  --gpus         G1,G2    Comma-separated GPU device IDs"
-    echo "  --config       PATH     LBM config JSON"
-    echo "  --calibration  PATH     calibration.json"
-    echo ""
-    echo "Options:"
-    echo "  --episodes     N        Total episodes (default: 500)"
-    echo "  --transfer     PATH     .zip model for transfer learning"
-    echo "  --delay        SEC      Seconds between launches (default: 420)"
-    echo "  --env          NAME     Conda env name (default: pycuda_3_10)"
-    exit 1
-}
-
-while [[ $# -gt 0 ]]; do
-    case "$1" in
-        --case-name)    CASE_NAME="$2"; shift 2 ;;
-        --seeds)        SEEDS="$2"; shift 2 ;;
-        --gpus)         GPUS="$2"; shift 2 ;;
-        --episodes)     EPISODES="$2"; shift 2 ;;
-        --config)       CONFIG="$2"; shift 2 ;;
-        --calibration)  CALIBRATION="$2"; shift 2 ;;
-        --transfer)     TRANSFER="$2"; shift 2 ;;
-        --delay)        DELAY_SECONDS="$2"; shift 2 ;;
-        --env)          CONDA_ENV="$2"; shift 2 ;;
-        *)              echo "Unknown option: $1"; usage ;;
-    esac
-done
-
-# Validate
-if [[ -z "$CASE_NAME" || -z "$SEEDS" || -z "$GPUS" || -z "$CONFIG" || -z "$CALIBRATION" ]]; then
-    echo "ERROR: Missing required arguments."
-    usage
-fi
-
-IFS=',' read -ra SEED_ARR <<< "$SEEDS"
-IFS=',' read -ra GPU_ARR <<< "$GPUS"
-
-if [[ ${#SEED_ARR[@]} -ne ${#GPU_ARR[@]} ]]; then
-    echo "ERROR: Number of seeds (${#SEED_ARR[@]}) must match number of GPUs (${#GPU_ARR[@]})."
-    exit 1
-fi
-
-echo "=== Multi-GPU Training Launcher ==="
-echo "  Case:       $CASE_NAME"
-echo "  Seeds:      $SEEDS"
-echo "  GPUs:       $GPUS"
-echo "  Episodes:   $EPISODES"
-echo "  Config:     $CONFIG"
-echo "  Calibration: $CALIBRATION"
-echo "  Transfer:   ${TRANSFER:-none}"
-echo "  Delay:      ${DELAY_SECONDS}s between launches"
-echo "  Jobs:       ${#SEED_ARR[@]}"
-echo ""
-
-# Build transfer arg
-TRANSFER_ARG=""
-if [[ -n "$TRANSFER" ]]; then
-    TRANSFER_ARG="--transfer-model $TRANSFER"
-fi
-
-mkdir -p "$SCRIPT_DIR/output"
-
-for i in "${!SEED_ARR[@]}"; do
-    seed="${SEED_ARR[$i]}"
-    gpu="${GPU_ARR[$i]}"
-    run_name="${CASE_NAME}_seed${seed}"
-    logfile="$SCRIPT_DIR/output/${run_name}/nohup.log"
-
-    mkdir -p "$SCRIPT_DIR/output/${run_name}"
-
-    echo "[$(date '+%H:%M:%S')] Launching seed=$seed on GPU=$gpu ..."
-    nohup conda run --no-capture-output -n "$CONDA_ENV" python -u \
-        "$SCRIPT_DIR/train_karman.py" \
-        --case-name "$CASE_NAME" \
-        --device-id "$gpu" \
-        --seed "$seed" \
-        --total-episodes "$EPISODES" \
-        --config "$CONFIG" \
-        --calibration "$CALIBRATION" \
-        $TRANSFER_ARG \
-        > "$logfile" 2>&1 &
-
-    echo "  PID: $!"
-    echo "  Log: $logfile"
-
-    if [[ $i -lt $((${#SEED_ARR[@]} - 1)) ]]; then
-        echo "  Waiting ${DELAY_SECONDS}s before next launch..."
-        sleep "$DELAY_SECONDS"
-    fi
-done
-
-echo ""
-echo "All jobs launched. Monitor with:"
-echo "  tail -f $SCRIPT_DIR/output/${CASE_NAME}_seed*/nohup.log"
-echo "  tensorboard --logdir $SCRIPT_DIR/output/${CASE_NAME}_seed*/tb"
-echo ""
-echo "To stop all:"
-echo "  ps aux | grep train_karman | grep -v grep | awk '{print \$2}' | xargs kill"

src/drl_pinball/train/scripts/crossre_scratch.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+# =============================================================================
+# crossre_scratch.sh — Cross-Re From-Scratch Training
+#
+# Trains re60/re200/re400 from scratch on single GPU, serially.
+# Uses generic SIM_BP, K_CD/CL=50/100, lr=3e-4.
+# Output: output/kar_{re60,re200,re400}_sc_seed43/
+#
+# Usage:
+#   bash crossre_scratch.sh [--gpu 0] [--episodes 500]
+#   bash crossre_scratch.sh --only re200
+# =============================================================================
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TRAIN_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+REPO_DIR="$(cd "$TRAIN_DIR/../../.." && pwd)"
+CONDA_ENV="pycuda_3_10"
+GPU=0; EPISODES=500; DELAY=120; ONLY=""; SEED=43
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --gpu) GPU="$2"; shift 2 ;;
+        --episodes) EPISODES="$2"; shift 2 ;;
+        --only) ONLY="$2"; shift 2 ;;
+        *) echo "Unknown: $1"; exit 1 ;;
+    esac
+done
+
+echo "=== Cross-Re Scratch: GPU=$GPU, ep=$EPISODES ==="
+
+declare -A RE_CFGS=(
+    [re60]="$REPO_DIR/configs/config_lbm_karman_2000x600_re60.json"
+    [re200]="$REPO_DIR/configs/config_lbm_karman_2000x600_re200.json"
+    [re400]="$REPO_DIR/configs/config_lbm_karman_2000x600_re400.json"
+)
+
+for re in re60 re200 re400; do
+    [[ -n "$ONLY" && "$ONLY" != "$re" ]] && continue
+    CASE="kar_${re}_sc"
+    CAL="$TRAIN_DIR/calibrations/kar_${re}_sc/calibration.json"
+    CFG="${RE_CFGS[$re]}"
+    echo "  [$(date '+%H:%M:%S')] Training $CASE..."
+    conda run --no-capture-output -n "$CONDA_ENV" python -u \
+        "$TRAIN_DIR/train_karman.py" \
+        --case-name "$CASE" --device-id "$GPU" --seed "$SEED" \
+        --config "$CFG" --calibration "$CAL" \
+        --total-episodes "$EPISODES" --lr 0.0003
+    echo "  [$(date '+%H:%M:%S')] $CASE done. Sleeping ${DELAY}s..."
+    sleep "$DELAY"
+done
+echo "=== All done ==="

src/drl_pinball/train/scripts/crossre_transfer.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+# =============================================================================
+# crossre_transfer.sh — Cross-Re Transfer Learning
+#
+# Transfers from kar_re100_sc baseline to re60/re200/re400.
+# Uses original measured-SIM_BP calibrations (kar_re*).
+# Kept for comparison; scratch better for r_sim, transfer better for r_cd.
+#
+# Output: output/kar_{re60,re200,re400}_tr_seed43/
+#
+# Usage:
+#   bash crossre_transfer.sh [--gpu 0] [--episodes 200]
+# =============================================================================
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TRAIN_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+REPO_DIR="$(cd "$TRAIN_DIR/../../.." && pwd)"
+CONDA_ENV="pycuda_3_10"
+GPU=0; EPISODES=200; DELAY=120; SEED=43
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --gpu) GPU="$2"; shift 2 ;;
+        --episodes) EPISODES="$2"; shift 2 ;;
+        *) echo "Unknown: $1"; exit 1 ;;
+    esac
+done
+
+echo "=== Cross-Re Transfer: GPU=$GPU, ep=$EPISODES ==="
+
+BASE_MODEL="$TRAIN_DIR/output/kar_re100_sc_seed${SEED}/models/best_model.zip"
+if [[ ! -f "$BASE_MODEL" ]]; then
+    echo "ERROR: base model not found: $BASE_MODEL"
+    exit 1
+fi
+
+declare -A RE_CFGS=(
+    [re60]="$REPO_DIR/configs/config_lbm_karman_2000x600_re60.json"
+    [re200]="$REPO_DIR/configs/config_lbm_karman_2000x600_re200.json"
+    [re400]="$REPO_DIR/configs/config_lbm_karman_2000x600_re400.json"
+)
+
+for re in re60 re200 re400; do
+    CASE="kar_${re}_tr"
+    CAL="$TRAIN_DIR/calibrations/kar_${re}/calibration.json"
+    CFG="${RE_CFGS[$re]}"
+    echo "  [$(date '+%H:%M:%S')] Training $CASE..."
+    conda run --no-capture-output -n "$CONDA_ENV" python -u \
+        "$TRAIN_DIR/train_karman.py" \
+        --case-name "$CASE" --device-id "$GPU" --seed "$SEED" \
+        --config "$CFG" --calibration "$CAL" \
+        --total-episodes "$EPISODES" --lr 0.0003 \
+        --transfer-model "$BASE_MODEL"
+    echo "  [$(date '+%H:%M:%S')] $CASE done. Sleeping ${DELAY}s..."
+    sleep "$DELAY"
+done
+echo "=== All done ==="

src/drl_pinball/train/scripts/resume.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+# Resume interrupted training from an episode checkpoint.
+# Loads ep{N}_model.zip + ep{N}_vecnormalize.pkl and continues.
+#
+# Case naming: {domain}_{variant}_{method}_seed{seed}
+#   domain: kar(man) | ill(usion)
+#   variant: re{60,100,200,400} | d{075,15,2} | {1L,15L,075L,2L}
+#   method: sc(ratch) | tr(ansfer)
+#
+# Usage:
+#   bash resume.sh --case kar_re60_sc --seed 43 --resume 460 [--gpu 0]
+# =============================================================================
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TRAIN_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+REPO_DIR="$(cd "$TRAIN_DIR/../../.." && pwd)"
+CONDA_ENV="pycuda_3_10"
+GPU=0; EPISODES=500; CASE=""; SEED=43; RESUME_EP=0
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --case) CASE="$2"; shift 2 ;;
+        --seed) SEED="$2"; shift 2 ;;
+        --resume) RESUME_EP="$2"; shift 2 ;;
+        --episodes) EPISODES="$2"; shift 2 ;;
+        --gpu) GPU="$2"; shift 2 ;;
+        *) echo "Unknown: $1"; exit 1 ;;
+    esac
+done
+
+[[ -z "$CASE" || "$RESUME_EP" -eq 0 ]] && { echo "Usage: resume.sh --case CASE --resume EP [--seed 43]"; exit 1; }
+
+# Map case prefix to LBM config
+if   [[ "$CASE" == kar_re60*  ]]; then CFG="$REPO_DIR/configs/config_lbm_karman_2000x600_re60.json"
+elif [[ "$CASE" == kar_re200* ]]; then CFG="$REPO_DIR/configs/config_lbm_karman_2000x600_re200.json"
+elif [[ "$CASE" == kar_re400* ]]; then CFG="$REPO_DIR/configs/config_lbm_karman_2000x600_re400.json"
+elif [[ "$CASE" == kar_* ]] || [[ "$CASE" == ill_* ]]; then CFG="$REPO_DIR/configs/config_lbm_karman_2000x600.json"
+else echo "ERROR: unknown case pattern: $CASE"; exit 1
+fi
+
+# Map case name to calibration: kar_d075_sc → calibrations/kar_d075_sc/
+CAL="$TRAIN_DIR/calibrations/${CASE%%_seed*}/calibration.json"
+if [[ ! -f "$CAL" ]]; then
+    echo "ERROR: calibration not found: $CAL"
+    exit 1
+fi
+
+echo "=== Resume: $CASE (seed=$SEED, resume=$RESUME_EP, total=$EPISODES, GPU=$GPU) ==="
+echo "  Config: $CFG"
+echo "  Calibration: $CAL"
+
+conda run --no-capture-output -n "$CONDA_ENV" python -u \
+    "$TRAIN_DIR/train_karman.py" \
+    --case-name "$CASE" --device-id "$GPU" --seed "$SEED" \
+    --config "$CFG" --calibration "$CAL" \
+    --total-episodes "$EPISODES" --lr 0.0003 \
+    --resume-from "$RESUME_EP"
+echo "=== Done ==="

src/drl_pinball/train/scripts/train_baseline.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+# =============================================================================
+# train_baseline.sh — Karman Re100 Baseline (scratch, multi-seed)
+#
+# Trains kar_re100_sc from scratch with N seeds on a single GPU.
+# Output: output/kar_re100_sc_seed{N}/
+#
+# Usage:
+#   bash train_baseline.sh [--seeds 41,42,43,44,45] [--gpu 0] [--episodes 500]
+# =============================================================================
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TRAIN_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+REPO_DIR="$(cd "$TRAIN_DIR/../../.." && pwd)"
+CONDA_ENV="pycuda_3_10"
+GPU=0; EPISODES=500; DELAY=120
+SEEDS="41,42,43,44,45"
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --seeds) SEEDS="$2"; shift 2 ;;
+        --gpu) GPU="$2"; shift 2 ;;
+        --episodes) EPISODES="$2"; shift 2 ;;
+        *) echo "Unknown: $1"; exit 1 ;;
+    esac
+done
+
+IFS=',' read -ra SEED_ARR <<< "$SEEDS"
+CAL="$TRAIN_DIR/calibrations/kar_re100/calibration.json"
+CFG="$REPO_DIR/configs/config_lbm_karman_2000x600.json"
+
+echo "=== Baseline: kar_re100_sc, seeds=${SEED_ARR[*]}, ep=$EPISODES, GPU=$GPU ==="
+
+for seed in "${SEED_ARR[@]}"; do
+    echo "  [$(date '+%H:%M:%S')] Training seed=$seed..."
+    conda run --no-capture-output -n "$CONDA_ENV" python -u \
+        "$TRAIN_DIR/train_karman.py" \
+        --case-name kar_re100_sc --device-id "$GPU" --seed "$seed" \
+        --config "$CFG" --calibration "$CAL" \
+        --total-episodes "$EPISODES" --lr 0.0003
+    echo "  [$(date '+%H:%M:%S')] Seed $seed done. Sleeping ${DELAY}s..."
+    sleep "$DELAY"
+done
+echo "=== All done ==="

src/drl_pinball/train/scripts/train_illusion.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+# =============================================================================
+# train_illusion.sh — Hydrodynamic Illusion Training (scratch)
+#
+# Trains all 4 target cylinder sizes on a single GPU, serially.
+# Output: output/ill_{1L,15L,075L,2L}_sc_seed43/
+#
+# Usage:
+#   bash train_illusion.sh [--gpu 0] [--episodes 500]
+#   bash train_illusion.sh --only 2L
+# =============================================================================
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TRAIN_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+REPO_DIR="$(cd "$TRAIN_DIR/../../.." && pwd)"
+CONDA_ENV="pycuda_3_10"
+GPU=0; EPISODES=500; DELAY=120; SEED=43; ONLY=""
+CFG="$REPO_DIR/configs/config_lbm_karman_2000x600.json"
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --gpu) GPU="$2"; shift 2 ;;
+        --episodes) EPISODES="$2"; shift 2 ;;
+        --only) ONLY="$2"; shift 2 ;;
+        *) echo "Unknown: $1"; exit 1 ;;
+    esac
+done
+
+echo "=== Illusion: GPU=$GPU, ep=$EPISODES ==="
+
+for size in 1L 075L 15L 2L; do
+    [[ -n "$ONLY" && "$ONLY" != "$size" ]] && continue
+    CASE="ill_${size}_sc"
+    CAL="$TRAIN_DIR/calibrations/ill_${size}/calibration.json"
+    echo "  [$(date '+%H:%M:%S')] Training $CASE..."
+    conda run --no-capture-output -n "$CONDA_ENV" python -u \
+        "$TRAIN_DIR/train_illusion.py" \
+        --case-name "$CASE" --device-id "$GPU" --seed "$SEED" \
+        --config "$CFG" --calibration "$CAL" \
+        --total-episodes "$EPISODES"
+    echo "  [$(date '+%H:%M:%S')] $CASE done. Sleeping ${DELAY}s..."
+    sleep "$DELAY"
+done
+echo "=== All done ==="

src/drl_pinball/train/scripts/vardist_scratch.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+# =============================================================================
+# vardist_scratch.sh — Variable-Dist Cylinder From-Scratch Training
+#
+# Trains d075/d15/d2 from scratch on single GPU.
+# Uses generic SIM_BP, K_CD/CL=50/100, lr=3e-4.
+# Output: output/kar_{d075,d15,d2}_sc_seed{N}/
+#
+# Usage:
+#   bash vardist_scratch.sh [--gpu 0] [--episodes 500]
+#   bash vardist_scratch.sh --only d075
+# =============================================================================
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TRAIN_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+REPO_DIR="$(cd "$TRAIN_DIR/../../.." && pwd)"
+CONDA_ENV="pycuda_3_10"
+GPU=0; EPISODES=500; DELAY=120; ONLY=""
+CFG="$REPO_DIR/configs/config_lbm_karman_2000x600.json"
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --gpu) GPU="$2"; shift 2 ;;
+        --episodes) EPISODES="$2"; shift 2 ;;
+        --only) ONLY="$2"; shift 2 ;;
+        *) echo "Unknown: $1"; exit 1 ;;
+    esac
+done
+
+echo "=== Vardist Scratch: GPU=$GPU, ep=$EPISODES ==="
+
+declare -A SEEDS=( [d075]=44 [d15]=45 [d2]=45 )
+
+for diam in d075 d15 d2; do
+    [[ -n "$ONLY" && "$ONLY" != "$diam" ]] && continue
+    SEED="${SEEDS[$diam]}"
+    CASE="kar_${diam}_sc"
+    CAL="$TRAIN_DIR/calibrations/kar_${diam}_sc/calibration.json"
+    echo "  [$(date '+%H:%M:%S')] Training $CASE (seed=$SEED)..."
+    conda run --no-capture-output -n "$CONDA_ENV" python -u \
+        "$TRAIN_DIR/train_karman.py" \
+        --case-name "$CASE" --device-id "$GPU" --seed "$SEED" \
+        --config "$CFG" --calibration "$CAL" \
+        --total-episodes "$EPISODES" --lr 0.0003
+    echo "  [$(date '+%H:%M:%S')] $CASE done. Sleeping ${DELAY}s..."
+    sleep "$DELAY"
+done
+echo "=== All done ==="

src/drl_pinball/train/scripts/vardist_transfer.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+# =============================================================================
+# vardist_transfer.sh — Variable-Dist Cylinder Transfer Learning
+#
+# Transfers from kar_re100_sc baseline to different dist cylinder sizes.
+# Uses original measured-SIM_BP calibrations (kar_d*_tr).
+# Kept for comparison; scratch (vardist_scratch.sh) produces better results.
+#
+# Output: output/kar_{d075,d15,d2}_tr_seed{N}/
+#
+# Usage:
+#   bash vardist_transfer.sh [--gpu 0] [--episodes 200]
+# =============================================================================
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TRAIN_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+REPO_DIR="$(cd "$TRAIN_DIR/../../.." && pwd)"
+CONDA_ENV="pycuda_3_10"
+GPU=0; EPISODES=200; DELAY=120
+CFG="$REPO_DIR/configs/config_lbm_karman_2000x600.json"
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --gpu) GPU="$2"; shift 2 ;;
+        --episodes) EPISODES="$2"; shift 2 ;;
+        *) echo "Unknown: $1"; exit 1 ;;
+    esac
+done
+
+echo "=== Vardist Transfer: GPU=$GPU, ep=$EPISODES ==="
+
+declare -A SEEDS=( [d075]=44 [d15]=45 [d2]=45 )
+declare -A BASE_SEEDS=( [d075]=44 [d15]=45 [d2]=45 )
+
+for diam in d075 d15 d2; do
+    SEED="${SEEDS[$diam]}"
+    BS="${BASE_SEEDS[$diam]}"
+    BASE_MODEL="$TRAIN_DIR/output/kar_re100_sc_seed${BS}/models/best_model.zip"
+
+    if [[ ! -f "$BASE_MODEL" ]]; then
+        echo "  SKIP $diam: base model not found: $BASE_MODEL"
+        continue
+    fi
+
+    CASE="kar_${diam}_tr"
+    CAL="$TRAIN_DIR/calibrations/kar_${diam}_tr/calibration.json"
+    echo "  [$(date '+%H:%M:%S')] Training $CASE (seed=$SEED)..."
+    conda run --no-capture-output -n "$CONDA_ENV" python -u \
+        "$TRAIN_DIR/train_karman.py" \
+        --case-name "$CASE" --device-id "$GPU" --seed "$SEED" \
+        --config "$CFG" --calibration "$CAL" \
+        --total-episodes "$EPISODES" --lr 0.0003 \
+        --transfer-model "$BASE_MODEL"
+    echo "  [$(date '+%H:%M:%S')] $CASE done. Sleeping ${DELAY}s..."
+    sleep "$DELAY"
+done
+echo "=== All done ==="

src/drl_pinball/train/train_karman.py

@@ -61,6 +61,10 @@ def main() -> int:
                         help="G-symmetry augmentation probability (0=off, 0.5=half)")
     parser.add_argument("--transfer-model", type=str, default=None,
                         help="Path to .zip model for transfer learning")
+    parser.add_argument("--resume-from", type=int, default=0,
+                        help="Resume from episode N (0=start fresh). Loads ep{N}_model.zip "
+                             "and ep{N}_vecnormalize.pkl, parses train.log for best_reward, "
+                             "continues from ep N+1.")
     args = parser.parse_args()
 
     # Load calibration
@@ -78,6 +82,38 @@ def main() -> int:
     out_dir = Path(__file__).resolve().parent / "output" / run_name
     (out_dir / "models").mkdir(parents=True, exist_ok=True)
 
+    # ── Resume mode: load checkpoint and restore best_reward ──────────────
+    resume_ep = args.resume_from
+    resume_best_reward = -float("inf")
+
+    if resume_ep > 0:
+        log_path_tmp = out_dir / "train.log"
+        def _log(msg):
+            line = f"[{time.strftime('%H:%M:%S')}] {msg}"
+            print(line, flush=True)
+            with open(log_path_tmp, "a") as f: f.write(line + "\n"); f.flush()
+        _log(f"=== V5 {run_name} (RESUME from ep {resume_ep}) ===")
+        if log_path_tmp.exists():
+            with open(log_path_tmp, "r") as f:
+                for line in f:
+                    if "BEST" in line:
+                        import re
+                        m = re.search(r'reward=([\d.]+)\s+\(BEST', line)
+                        if m:
+                            resume_best_reward = float(m.group(1))
+            _log(f"  Recovered best_reward={resume_best_reward:.4f} from log")
+        else:
+            _log("  WARNING: train.log not found, best_reward set to -inf")
+        ckpt_model = out_dir / "models" / f"ep{resume_ep:04d}_model.zip"
+        ckpt_norm  = out_dir / "models" / f"ep{resume_ep:04d}_vecnormalize.pkl"
+        if not ckpt_model.exists():
+            _log(f"  ERROR: Checkpoint not found: {ckpt_model}")
+            return 1
+        if not ckpt_norm.exists():
+            _log(f"  ERROR: Checkpoint not found: {ckpt_norm}")
+            return 1
+        _log(f"  Resume checkpoint: {ckpt_model}")
+
     log_path = out_dir / "train.log"
     def log(msg):
         line = f"[{time.strftime('%H:%M:%S')}] {msg}"
@@ -96,8 +132,9 @@ def main() -> int:
     cal_copy["config_path"] = config_path
     if args.transfer_model:
         cal_copy["transfer_model"] = args.transfer_model
-    with open(out_dir / "calibration.json", "w") as f:
+    if not resume_ep:
-        json.dump(cal_copy, f, indent=2)
+        with open(out_dir / "calibration.json", "w") as f:
+            json.dump(cal_copy, f, indent=2)
 
     # Load target
     cal_dir = Path(args.calibration).resolve().parent
@@ -108,7 +145,8 @@ def main() -> int:
     else:
         log("  Recording target...")
         t0 = time.perf_counter()
-        target_states = record_target(config_path, args.device_id, si_val)
+        dist_radius = float(cal.get("dist_radius", 1.0))
+        target_states = record_target(config_path, args.device_id, si_val, dist_radius=dist_radius)
         np.save(str(out_dir / "target.npy"), target_states)
         log(f"  Target recorded in {time.perf_counter()-t0:.0f}s")
 
@@ -120,8 +158,16 @@ def main() -> int:
     env = SymmetryAugmentWrapper(env, prob=args.symmetry_prob, seed=args.seed,
                                   rollout_len=args.n_steps)
     vec_env = DummyVecEnv([lambda: env])
-    vec_env = VecNormalize(vec_env, norm_obs=True, norm_reward=False,
+    if resume_ep and ckpt_norm.exists():
-                           clip_obs=10.0, gamma=0.99)
+        # Resume: restore single-layer VecNormalize from checkpoint
+        vec_env = VecNormalize.load(str(ckpt_norm), vec_env)
+        vec_env.training = True
+        vec_env.norm_reward = False
+        log("  Loaded VecNormalize from checkpoint.")
+    else:
+        # Fresh training or transfer: create new VecNormalize
+        vec_env = VecNormalize(vec_env, norm_obs=True, norm_reward=False,
+                               clip_obs=10.0, gamma=0.99)
     log(f"  Env ready in {time.perf_counter()-t0:.0f}s")
 
     device = torch.device(f"cuda:{args.device_id}")
@@ -132,6 +178,11 @@ def main() -> int:
         model = PPO.load(args.transfer_model, env=vec_env, device=device,
                           custom_objects={"activation_fn": Sin})
         log("  Loaded base model.")
+    elif resume_ep:
+        log(f"  Resuming from: {ckpt_model}")
+        model = PPO.load(str(ckpt_model), env=vec_env, device=device,
+                          custom_objects={"activation_fn": Sin})
+        log("  Loaded checkpoint model.")
     else:
         model = PPO(
             "MlpPolicy",
@@ -147,11 +198,16 @@ def main() -> int:
         )
         log("  Created from scratch.")
 
-    best_reward = -float("inf")
+    best_reward = resume_best_reward if resume_ep else -float("inf")
     t_last = time.perf_counter()
     norm_path = str(out_dir / "vec_normalize.pkl")
 
-    for ep in range(1, args.total_episodes + 1):
+    # Save initial vec_normalize state (important after checkpoint load)
+    if resume_ep:
+        vec_env.save(norm_path)
+
+    start_ep = resume_ep + 1 if resume_ep else 1
+    for ep in range(start_ep, args.total_episodes + 1):
         model.learn(total_timesteps=args.learn_timesteps, reset_num_timesteps=False)
 
         # Evaluation (disable symmetry for clean policy eval)

src/drl_pinball/train/visualize_and_analyze.py

@@ -1,492 +0,0 @@
-#!/usr/bin/env python3
-"""Post-training flow-field visualization and quantitative analysis.
-
-Compares control modes for Karman Cloak 2000x600:
-  - target: disturbance-only reference (no pinball)
-  - zero: pinball with zero rotation
-  - bias: open-loop bias action (zeros -> [0,-4,4]*U0)
-  - bias_drl: trained Bias best model
-  - nobias_drl: trained NoBias best model
-
-Outputs to output/flow_analysis_v4/:
-  vorticity_*.png, macro_*.npz, metrics summary, comparison plots.
-
-Usage:
-    conda run -n pycuda_3_10 python -u visualize_and_analyze.py --device-id 0
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-import time
-from pathlib import Path
-from typing import Callable, Dict, List, Optional, Tuple
-
-import matplotlib
-matplotlib.use("Agg")
-import matplotlib.pyplot as plt
-import numpy as np
-import pycuda.driver as cuda
-
-cuda.init()
-
-_REPO = Path(__file__).resolve().parents[3]
-if str(_REPO) not in sys.path:
-    sys.path.insert(0, str(_REPO))
-
-import torch
-from torch.nn import Module as TorchModule
-from stable_baselines3 import PPO
-from stable_baselines3.common.vec_env import DummyVecEnv, VecNormalize
-from CelerisLab.common.render import compute_vorticity, render_vorticity_field
-
-from env_karman_2000x600 import (
-    KarmanCloakEnv,
-    SI,
-    FIFO_LEN,
-    CONV_LEN,
-    NX,
-    NY,
-    L0,
-    U0,
-    RADIUS,
-    CENTER_Y,
-    DIST_X,
-    PINBALL_FRONT_X,
-    PINBALL_REAR_X,
-    SENSOR_X,
-    SENSOR_CC,
-    FORCE_SCALE,
-    compute_similarity,
-    record_target,
-    WARMUP_STEPS,
-    CFG_PATH,
-)
-
-TRAIN_DIR = Path(__file__).resolve().parent
-BIAS_RUN = TRAIN_DIR / "output" / "bias_seed42_s2048_e10_v4"
-NOBIAS_RUN = TRAIN_DIR / "output" / "nobias_seed42_s2048_e10_v4"
-
-CYLINDERS_FULL = [
-    ((DIST_X, CENTER_Y), 1.0 * L0),
-    ((PINBALL_FRONT_X, CENTER_Y), RADIUS),
-    ((PINBALL_REAR_X, CENTER_Y + 15.0), RADIUS),
-    ((PINBALL_REAR_X, CENTER_Y - 15.0), RADIUS),
-]
-CYLINDERS_DIST = [((DIST_X, CENTER_Y), 1.0 * L0)]
-
-
-class Sin(TorchModule):
-    def __init__(self):
-        super().__init__()
-
-    def forward(self, x):
-        return torch.sin(x)
-
-
-def log(msg: str) -> None:
-    print(f"[{time.strftime('%H:%M:%S')}] {msg}", flush=True)
-
-
-def save_flow(sim, out_dir: Path, name: str, cylinders, nx: int = NX, ny: int = NY) -> None:
-    macro = sim.get_macroscopic()
-    np.savez_compressed(
-        out_dir / f"macro_{name}.npz",
-        rho=macro["rho"], ux=macro["ux"], uy=macro["uy"],
-    )
-    vort = compute_vorticity(macro["ux"], macro["uy"])
-    render_vorticity_field(
-        vort, nx=nx, ny=ny,
-        out_path=str(out_dir / f"vorticity_{name}.png"),
-        cylinders=cylinders,
-    )
-
-
-def save_target_field(device_id: int, out_dir: Path) -> None:
-    """Disturbance-only reference flow (no pinball)."""
-    from env_karman_2000x600 import _clean_cache
-    from CelerisLab import Simulation
-
-    log("Recording target reference flow field...")
-    _clean_cache()
-    sim = Simulation(lbm_config_path=CFG_PATH, device_id=device_id)
-    sim._assert_object_count_contract = lambda *a, **kw: None
-    sim.add_body("circle", center=(DIST_X, CENTER_Y, 0.0), radius=1.0 * L0)
-    sim.add_body("sensor", center=(SENSOR_X, CENTER_Y + 40.0, 0.0), radius=5.0)
-    sim.add_body("sensor", center=(SENSOR_X, CENTER_Y, 0.0), radius=5.0)
-    sim.add_body("sensor", center=(SENSOR_X, CENTER_Y - 40.0, 0.0), radius=5.0)
-    sim.initialize()
-    sim.run(WARMUP_STEPS + FIFO_LEN * SI, zero_obs=True)
-    save_flow(sim, out_dir, "target", CYLINDERS_DIST)
-    sim.close()
-
-
-def run_manual_rollout(
-    env: KarmanCloakEnv,
-    n_steps: int,
-    *,
-    action: Optional[np.ndarray] = None,
-    fixed_omega: Optional[np.ndarray] = None,
-    action_provider: Optional[Callable[[np.ndarray], np.ndarray]] = None,
-) -> Dict[str, np.ndarray]:
-    """Run rollout bypassing gym step when fixed_omega is set."""
-    obs, _ = env.reset()
-    if fixed_omega is not None:
-        env.smoother.reset(np.asarray(fixed_omega, dtype=np.float32))
-    rewards, r_cd, r_cl, r_sim = [], [], [], []
-    cd_vals, cl_vals, sim_vals = [], [], []
-    actions = []
-    sensor_hist = []
-    force_hist = []
-
-    for _ in range(n_steps):
-        if fixed_omega is not None:
-            omega = np.asarray(fixed_omega, dtype=np.float32)
-            act = np.zeros(3, dtype=np.float32)
-        elif action_provider is not None:
-            act = np.asarray(action_provider(obs), dtype=np.float32).flatten()
-            omega = env.smoother(env._action_to_omega(act))
-        else:
-            act = np.zeros(3, dtype=np.float32) if action is None else np.asarray(action, dtype=np.float32)
-            omega = env.smoother(env._action_to_omega(act))
-
-        env._set_omega(omega)
-        env._gpu_block(lambda: env.sim.run(SI, zero_obs=True))
-
-        obs_raw = env._read_obs()
-        obs_slice = obs_raw[2:14]
-        obs = env._normalize_obs(obs_slice)
-        env.fifo_states.append(obs_slice[0:6] * SENSOR_CC)
-        reward, info = env._compute_reward(obs_slice)
-
-        rewards.append(reward)
-        r_cd.append(info["r_cd"])
-        r_cl.append(info["r_cl"])
-        r_sim.append(info["r_sim"])
-        cd_vals.append(info["cd"])
-        cl_vals.append(info["cl"])
-        sim_vals.append(info["sim"])
-        actions.append(act.copy())
-        sensor_hist.append(obs_slice[0:6] * SENSOR_CC)
-        force_hist.append(obs_slice[6:12].copy())
-
-    return {
-        "rewards": np.array(rewards, dtype=np.float64),
-        "r_cd": np.array(r_cd, dtype=np.float64),
-        "r_cl": np.array(r_cl, dtype=np.float64),
-        "r_sim": np.array(r_sim, dtype=np.float64),
-        "cd": np.array(cd_vals, dtype=np.float64),
-        "cl": np.array(cl_vals, dtype=np.float64),
-        "sim": np.array(sim_vals, dtype=np.float64),
-        "actions": np.array(actions, dtype=np.float32),
-        "sensors": np.array(sensor_hist, dtype=np.float32),
-        "forces": np.array(force_hist, dtype=np.float32),
-    }
-
-
-def run_model_rollout(
-    env: KarmanCloakEnv,
-    model_path: Path,
-    norm_path: Path,
-    device_id: int,
-    n_steps: int,
-    deterministic: bool = True,
-) -> Dict[str, np.ndarray]:
-    vec_env = DummyVecEnv([lambda: env])
-    vec_env = VecNormalize.load(str(norm_path), vec_env)
-    vec_env.training = False
-    vec_env.norm_reward = False
-
-    model = PPO.load(
-        str(model_path),
-        env=vec_env,
-        device=torch.device(f"cuda:{device_id}"),
-        custom_objects={"policy_kwargs": {"activation_fn": Sin, "net_arch": [64, 64]}},
-    )
-
-    obs = vec_env.reset()
-    rewards, r_cd, r_cl, r_sim = [], [], [], []
-    cd_vals, cl_vals, sim_vals = [], [], []
-    actions = []
-    sensor_hist = []
-    force_hist = []
-
-    for _ in range(n_steps):
-        action, _ = model.predict(obs, deterministic=deterministic)
-        obs, reward, done, info = vec_env.step(action)
-        inf = info[0] if isinstance(info, list) else info
-        rewards.append(float(reward[0]))
-        r_cd.append(float(inf.get("r_cd", 0.0)))
-        r_cl.append(float(inf.get("r_cl", 0.0)))
-        r_sim.append(float(inf.get("r_sim", 0.0)))
-        cd_vals.append(float(inf.get("cd", 0.0)))
-        cl_vals.append(float(inf.get("cl", 0.0)))
-        sim_vals.append(float(inf.get("sim", 0.0)))
-        actions.append(np.asarray(action[0], dtype=np.float32))
-        raw = env._read_obs()[2:14]
-        sensor_hist.append(raw[0:6] * SENSOR_CC)
-        force_hist.append(raw[6:12].copy())
-
-    return {
-        "rewards": np.array(rewards, dtype=np.float64),
-        "r_cd": np.array(r_cd, dtype=np.float64),
-        "r_cl": np.array(r_cl, dtype=np.float64),
-        "r_sim": np.array(r_sim, dtype=np.float64),
-        "cd": np.array(cd_vals, dtype=np.float64),
-        "cl": np.array(cl_vals, dtype=np.float64),
-        "sim": np.array(sim_vals, dtype=np.float64),
-        "actions": np.array(actions, dtype=np.float32),
-        "sensors": np.array(sensor_hist, dtype=np.float32),
-        "forces": np.array(force_hist, dtype=np.float32),
-    }
-
-
-def summarize_rollout(name: str, data: Dict[str, np.ndarray], tail: int = 180) -> Dict[str, float]:
-    sl = slice(-tail, None) if len(data["rewards"]) >= tail else slice(None)
-    return {
-        "name": name,
-        "reward": float(np.mean(data["rewards"][sl])),
-        "r_cd": float(np.mean(data["r_cd"][sl])),
-        "r_cl": float(np.mean(data["r_cl"][sl])),
-        "r_sim": float(np.mean(data["r_sim"][sl])),
-        "cd_norm": float(np.mean(data["cd"][sl])),
-        "cl_norm": float(np.mean(data["cl"][sl])),
-        "sim_raw": float(np.mean(data["sim"][sl])),
-        "cd_force": float(np.mean((data["forces"][sl, 0] + data["forces"][sl, 2] + data["forces"][sl, 4]) / 3.0)),
-        "cl_force": float(np.mean((data["forces"][sl, 1] + data["forces"][sl, 3] + data["forces"][sl, 5]) / 3.0)),
-    }
-
-
-def save_flow_from_env(env: KarmanCloakEnv, out_dir: Path, name: str) -> None:
-    env.sim.ctx._ctx.push()
-    try:
-        save_flow(env.sim, out_dir, name, CYLINDERS_FULL)
-    finally:
-        env.sim.ctx._ctx.pop()
-
-
-def plot_vorticity_panel(out_dir: Path, names: List[str], titles: List[str]) -> None:
-    n = len(names)
-    fig, axes = plt.subplots(2, 3, figsize=(18, 7))
-    axes = axes.flatten()
-    for ax, name, title in zip(axes, names, titles):
-        img_path = out_dir / f"vorticity_{name}.png"
-        if img_path.exists():
-            ax.imshow(plt.imread(img_path))
-        ax.set_title(title, fontsize=11)
-        ax.axis("off")
-    for ax in axes[n:]:
-        ax.axis("off")
-    fig.suptitle("Karman Cloak — Vorticity Comparison (2000×600)", fontsize=14)
-    fig.tight_layout()
-    fig.savefig(out_dir / "vorticity_panel.png", dpi=150, bbox_inches="tight")
-    plt.close(fig)
-
-
-def plot_metrics(summary: List[Dict], out_dir: Path) -> None:
-    names = [s["name"] for s in summary]
-    x = np.arange(len(names))
-    width = 0.2
-    fig, axes = plt.subplots(1, 2, figsize=(14, 5))
-
-    for i, key in enumerate(["reward", "r_cd", "r_cl", "r_sim"]):
-        axes[0].bar(x + (i - 1.5) * width, [s[key] for s in summary], width, label=key)
-    axes[0].set_xticks(x)
-    axes[0].set_xticklabels(names, rotation=15)
-    axes[0].set_ylim(0, 1.05)
-    axes[0].set_ylabel("Reward component")
-    axes[0].set_title("Eval reward (last 180 steps mean)")
-    axes[0].legend()
-    axes[0].grid(axis="y", alpha=0.3)
-
-    axes[1].bar(x - width / 2, [s["cd_norm"] for s in summary], width, label="|Cd| norm")
-    axes[1].bar(x + width / 2, [s["cl_norm"] for s in summary], width, label="|Cl| norm")
-    axes[1].set_xticks(x)
-    axes[1].set_xticklabels(names, rotation=15)
-    axes[1].set_ylabel("Force norm")
-    axes[1].set_title("Hydrodynamic forces (normalized)")
-    axes[1].legend()
-    axes[1].grid(axis="y", alpha=0.3)
-
-    fig.tight_layout()
-    fig.savefig(out_dir / "metrics_comparison.png", dpi=150)
-    plt.close(fig)
-
-
-def plot_sensor_signals(
-    target_states: np.ndarray,
-    rollouts: Dict[str, Dict[str, np.ndarray]],
-    out_dir: Path,
-) -> None:
-    """Plot center-sensor uy vs target reference."""
-    fig, axes = plt.subplots(2, 1, figsize=(14, 8), sharex=True)
-
-    t_ref = target_states[CONV_LEN:2 * CONV_LEN, 3]  # center uy
-    axes[0].plot(t_ref, "k-", lw=2, label="target (disturbance only)")
-    colors = {"zero": "#d62728", "bias": "#ff7f0e", "bias_drl": "#2ca02c", "nobias_drl": "#1f77b4"}
-    for name, data in rollouts.items():
-        if name == "target":
-            continue
-        s = data["sensors"][-CONV_LEN:, 3]
-        axes[0].plot(s, color=colors.get(name, "gray"), alpha=0.85, label=name)
-
-    axes[0].set_ylabel("Center sensor uy (legacy-equiv)")
-    axes[0].set_title("Downstream velocity signal vs target")
-    axes[0].legend(loc="upper right")
-    axes[0].grid(alpha=0.3)
-
-    for name, data in rollouts.items():
-        if name in ("target", "zero"):
-            continue
-        axes[1].plot(data["actions"][:, 0], alpha=0.7, label=f"{name} a_front")
-        axes[1].plot(data["actions"][:, 1], alpha=0.7, ls="--", label=f"{name} a_top")
-        axes[1].plot(data["actions"][:, 2], alpha=0.7, ls=":", label=f"{name} a_bot")
-    axes[1].set_xlabel("Step")
-    axes[1].set_ylabel("Action [-1, 1]")
-    axes[1].set_title("Control actions")
-    axes[1].legend(ncol=2, fontsize=8)
-    axes[1].grid(alpha=0.3)
-
-    fig.tight_layout()
-    fig.savefig(out_dir / "sensor_action_timeseries.png", dpi=150)
-    plt.close(fig)
-
-
-def plot_reward_traces(rollouts: Dict[str, Dict[str, np.ndarray]], out_dir: Path) -> None:
-    fig, ax = plt.subplots(figsize=(12, 4))
-    colors = {"zero": "#d62728", "bias": "#ff7f0e", "bias_drl": "#2ca02c", "nobias_drl": "#1f77b4"}
-    for name, data in rollouts.items():
-        if name == "target":
-            continue
-        r = data["rewards"]
-        w = min(30, len(r))
-        smooth = np.convolve(r, np.ones(w) / w, mode="same")
-        ax.plot(smooth, color=colors.get(name, "gray"), label=name, alpha=0.9)
-    ax.set_xlabel("Step")
-    ax.set_ylabel("Reward (smoothed)")
-    ax.set_title("Reward traces during eval rollout")
-    ax.legend()
-    ax.grid(alpha=0.3)
-    fig.tight_layout()
-    fig.savefig(out_dir / "reward_traces.png", dpi=150)
-    plt.close(fig)
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--device-id", type=int, default=0)
-    parser.add_argument("--target", type=str, default=str(TRAIN_DIR / "target.npy"))
-    parser.add_argument("--n-steps", type=int, default=360)
-    parser.add_argument("--out", type=str, default=str(TRAIN_DIR / "output" / "flow_analysis_v4"))
-    args = parser.parse_args()
-
-    out_dir = Path(args.out)
-    out_dir.mkdir(parents=True, exist_ok=True)
-    target_states = np.load(args.target)
-    n_steps = args.n_steps
-
-    log(f"Output -> {out_dir}")
-    log(f"Eval steps per case: {n_steps}")
-
-    # --- Target reference field ---
-    save_target_field(args.device_id, out_dir)
-
-    rollouts: Dict[str, Dict[str, np.ndarray]] = {}
-    summary: List[Dict] = []
-
-    # --- Bias env cases (zero, bias, bias_drl) ---
-    log("Creating Bias env...")
-    bias_env = KarmanCloakEnv(
-        device_id=args.device_id, seed=42, target_states=target_states,
-    )
-
-    dtw_norm_scale = bias_env._dtw_norm_scale
-
-    log("Case: zero rotation...")
-    rollouts["zero"] = run_manual_rollout(
-        bias_env, n_steps, fixed_omega=np.zeros(3, dtype=np.float32),
-    )
-    save_flow_from_env(bias_env, out_dir, "zero")
-
-    log("Case: bias (open-loop)...")
-    rollouts["bias"] = run_manual_rollout(
-        bias_env, n_steps, action=np.zeros(3, dtype=np.float32),
-    )
-    save_flow_from_env(bias_env, out_dir, "bias")
-
-    log("Case: Bias DRL best...")
-    rollouts["bias_drl"] = run_model_rollout(
-        bias_env,
-        BIAS_RUN / "models" / "best_model.zip",
-        BIAS_RUN / "vec_normalize.pkl",
-        args.device_id,
-        n_steps,
-        deterministic=True,
-    )
-    save_flow_from_env(bias_env, out_dir, "bias_drl")
-
-    bias_env.close()
-
-    # --- NoBias DRL ---
-    log("Creating NoBias env...")
-    nobias_env = KarmanCloakEnv(
-        device_id=args.device_id, seed=42, target_states=target_states,
-        action_bias=np.array([0.0, 0.0, 0.0], dtype=np.float32),
-        action_scale=12.0,
-    )
-
-    log("Case: NoBias DRL best...")
-    rollouts["nobias_drl"] = run_model_rollout(
-        nobias_env,
-        NOBIAS_RUN / "models" / "best_model.zip",
-        NOBIAS_RUN / "vec_normalize.pkl",
-        args.device_id,
-        n_steps,
-        deterministic=True,
-    )
-    save_flow_from_env(nobias_env, out_dir, "nobias_drl")
-    nobias_env.close()
-
-    # --- Summaries ---
-    for name, data in rollouts.items():
-        s = summarize_rollout(name, data)
-        # DTW on full fifo at end
-        if len(data["sensors"]) >= CONV_LEN:
-            fifo = np.zeros((FIFO_LEN, 6), dtype=np.float32)
-            n = min(FIFO_LEN, len(data["sensors"]))
-            fifo[-n:] = data["sensors"][-n:]
-            s["sim_dtw_end"] = float(compute_similarity(
-                target_states, fifo, conv_len=CONV_LEN,
-                norm_scale=dtw_norm_scale,
-            ))
-        summary.append(s)
-        log(f"  {name:12s}: reward={s['reward']:.4f}  r_cd={s['r_cd']:.3f}  "
-            f"r_cl={s['r_cl']:.3f}  r_sim={s['r_sim']:.3f}  sim_raw={s['sim_raw']:.3f}")
-
-    with open(out_dir / "summary.json", "w") as f:
-        json.dump(summary, f, indent=2)
-
-    # --- Plots ---
-    plot_vorticity_panel(
-        out_dir,
-        ["target", "zero", "bias", "bias_drl", "nobias_drl"],
-        ["Target (no pinball)", "Zero rotation", "Bias open-loop",
-         "Bias DRL (best)", "NoBias DRL (best)"],
-    )
-    plot_metrics(summary, out_dir)
-    plot_sensor_signals(target_states, rollouts, out_dir)
-    plot_reward_traces(rollouts, out_dir)
-
-    np.savez_compressed(
-        out_dir / "rollout_data.npz",
-        **{f"{k}_{fld}": v for k, d in rollouts.items() for fld, v in d.items()},
-        target_states=target_states,
-    )
-
-    log(f"Done. Results in {out_dir}")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())