Update app.py

app.py

@@ -17,12 +17,18 @@
 # 2) Restore BFO plot (it disappeared previously)
 #    - Re-added full BFO analysis computation + chart + MAE/RMSE markdown.
 #
-# NEW (THIS UPDATE):
+# NEW (PREVIOUS UPDATE):
 # 3) Plausible final major turn (18:22→18:40) can adjust BOTH heading and speed
 #    - Turn speed is no longer fixed to the southern cruise speed.
 #    - The solver searches a plausible TURN speed range and chooses the best-scoring solution.
 #    - After 18:40, the southern trajectory continues “as per usual” using the selected speed profile.
 #    - Applies to BOTH scenarios: Straight and Straight + drift.
+#
+# NEW (THIS UPDATE):
+# 4) Two-stage guided search (COARSE → REFINE) to make generation much faster
+#    - Stage 1: coarse grid search to find the region of the best solution
+#    - Stage 2: refined grid around the best candidate only
+#    - Applies to BOTH scenarios: Straight and Straight + drift
 
 import os
 import re
@@ -113,27 +119,38 @@ TURN_BANK_MAX_DEG = 30.0
 TURN_BANK_DEFAULT_DEG = 25.0
 TURN_STEP_SEC = 30.0
 
-# ===== NEW: Turn-speed search parameters (turn only; southern uses speed profile) =====
+# Turn-speed search parameters (turn only; southern uses speed profile)
 TURN_SPEED_SEARCH_DELTA_KT = 40.0     # search ± around the southern cruise speed
-TURN_SPEED_STEP_KT = 5.0              # candidate spacing
+TURN_SPEED_STEP_KT = 5.0              # refined candidate spacing
 TURN_SPEED_MIN_ABS_KT = 350.0         # hard min plausible
 TURN_SPEED_MAX_ABS_KT = 550.0         # hard max plausible
 
 # Guided heading search (south-ish)
 GUIDED_HEADING_MIN = 150.0
 GUIDED_HEADING_MAX = 210.0
-STRAIGHT_STEP_DEG = 0.5
+STRAIGHT_STEP_DEG = 0.5  # refined step
 
 # Southern schedule (kept)
 GUIDED_LEG_SCHEDULE_MIN = [12.0, 60.0, 60.0, 60.0, 60.0, 90.0, 10.0]
 
 # Drift
 DEFAULT_DRIFT_MAX_DEG = 2.0
-DRIFT_STEP_DEG = 0.5
+DRIFT_STEP_DEG = 0.5  # refined step
 DEFAULT_WEIGHT_DRIFT = 0.30
 DEFAULT_DRIFT_ITERS = 2
 DRIFT_SCALE_DEG = 1.0
 
+# ===== NEW: Two-stage search knobs =====
+# Stage 1 (coarse)
+COARSE_HEADING_STEP_DEG = 2.0
+COARSE_TURN_SPEED_STEP_KT = 10.0
+COARSE_DRIFT_STEP_DEG = 1.0
+
+# Stage 2 (refine around best)
+REFINE_HEADING_HALF_WINDOW_DEG = 2.0   # +/- around best
+REFINE_TURN_SPEED_HALF_WINDOW_KT = 10.0
+REFINE_DRIFT_HALF_WINDOW_DEG = 1.0
+
 # Search area colors (optional)
 SEARCH_AREA_COLORS = {
     "Ocean Infinity": "#ff3b3b",
@@ -1151,7 +1168,7 @@ def speed_from_profile(profile: str, alt_ft: float, custom_mach: float, custom_k
     return mach_to_tas_knots(0.82, alt_ft)
 
 
-def _turn_speed_candidates(south_speed_knots: float):
+def _turn_speed_candidates(south_speed_knots: float, step_kt: float):
     """
     Plausible turn-speed candidates around the southern cruise speed.
     Hard-clipped to [TURN_SPEED_MIN_ABS_KT, TURN_SPEED_MAX_ABS_KT].
@@ -1159,7 +1176,7 @@ def _turn_speed_candidates(south_speed_knots: float):
     base = float(south_speed_knots)
     lo = max(TURN_SPEED_MIN_ABS_KT, base - float(TURN_SPEED_SEARCH_DELTA_KT))
     hi = min(TURN_SPEED_MAX_ABS_KT, base + float(TURN_SPEED_SEARCH_DELTA_KT))
-    step = max(1.0, float(TURN_SPEED_STEP_KT))
+    step = max(1.0, float(step_kt))
     if hi < lo:
         lo, hi = hi, lo
     cand = list(np.arange(lo, hi + 1e-9, step))
@@ -1170,6 +1187,28 @@ def _turn_speed_candidates(south_speed_knots: float):
     return cand
 
 
+def _clamp(x, lo, hi):
+    return max(lo, min(hi, x))
+
+
+def _frange(lo: float, hi: float, step: float):
+    # inclusive hi, stable float stepping
+    step = float(step)
+    if step <= 0:
+        return []
+    n = int(math.floor((hi - lo) / step + 1e-9)) + 1
+    out = [lo + i * step for i in range(max(0, n))]
+    # trim due to floating errors
+    out = [x for x in out if x <= hi + 1e-9]
+    return out
+
+
+def _refine_range(center: float, half_window: float, step: float, lo: float, hi: float):
+    lo2 = _clamp(center - half_window, lo, hi)
+    hi2 = _clamp(center + half_window, lo, hi)
+    return _frange(lo2, hi2, step)
+
+
 # ================= Guided Legs Creation =================
 def make_legs_from_schedule(headings, speed_knots, schedule_minutes):
     legs = []
@@ -1183,6 +1222,86 @@ def make_legs_from_schedule(headings, speed_knots, schedule_minutes):
     return legs
 
 
+# ================= Scoring helper (used in guided solvers) =================
+def score_legs_bfo_bto(
+    start_lat, start_lon, method, start_dt, end_dt, legs,
+    alt_ft, vs_fpm, descent_start_dt,
+    weight_bfo: float, weight_bto: float,
+    pts_window=None
+):
+    # pts_window: optional precomputed list [(lbl, dt, meas_bfo, meas_bto), ...] already clipped to [start_dt, end_dt]
+    if pts_window is None:
+        pts = _ping_points_after(start_dt)
+        pts = [(lbl, dt, bfo, bto) for (lbl, dt, bfo, bto) in pts if start_dt <= dt <= end_dt]
+    else:
+        pts = pts_window
+
+    if len(pts) < 2:
+        return None
+
+    leg_secs = [float(m) * 60.0 for _, _, m in legs]
+    boundaries = np.cumsum([0.0] + leg_secs)
+    total_end = float(boundaries[-1])
+
+    leg_start_positions = _precompute_leg_starts(start_lat, start_lon, legs, method)
+
+    bfo_preds, bfo_meas = [], []
+    bto_preds, bto_meas = [], []
+
+    for _lbl, dt_ping, meas_bfo, meas_bto in pts:
+        t_sec = (dt_ping - start_dt).total_seconds()
+        if t_sec < 0 or t_sec > total_end:
+            continue
+
+        i = int(np.searchsorted(boundaries, t_sec, side="right") - 1)
+        i = max(0, min(i, len(legs) - 1))
+        t_inside = float(t_sec) - float(boundaries[i])
+
+        leg_start_lat, leg_start_lon = leg_start_positions[i]
+        hdg, spd, _ = legs[i]
+        lat, lon = _predict_state_from_leg_start(method, leg_start_lat, leg_start_lon, hdg, spd, t_inside)
+
+        alt_now_ft = altitude_ft_at_dt(dt_ping, start_dt, float(alt_ft), float(vs_fpm), descent_start_dt)
+        alt_m = alt_now_ft * 0.3048
+
+        vs_mps = float(vs_fpm) * 0.00508
+        if descent_start_dt is not None and dt_ping < descent_start_dt:
+            vs_mps = 0.0
+
+        spd_mps = float(spd) * 1852.0 / 3600.0
+        pred_bfo = float(fp.calculateBFO_at_time(spd_mps, float(hdg), float(lat), float(lon), alt_m, vs_mps, dt_ping))
+        bfo_preds.append(pred_bfo)
+        bfo_meas.append(float(meas_bfo))
+
+        if meas_bto is not None:
+            pred_bto = float(fp.calculateBTO_at_time(float(lat), float(lon), alt_m, dt_ping))
+            bto_preds.append(pred_bto)
+            bto_meas.append(float(meas_bto))
+
+    if len(bfo_meas) < 2:
+        return None
+
+    e_bfo = np.array(bfo_preds) - np.array(bfo_meas)
+    rmse_bfo = float(np.sqrt(np.mean(e_bfo * e_bfo)))
+
+    rmse_bto = None
+    if len(bto_meas) >= 2:
+        e_bto = np.array(bto_preds) - np.array(bto_meas)
+        rmse_bto = float(np.sqrt(np.mean(e_bto * e_bto)))
+
+    combined = float(weight_bfo) * (rmse_bfo / BFO_SCALE_HZ)
+    if rmse_bto is not None:
+        combined += float(weight_bto) * (rmse_bto / BTO_SCALE_US)
+
+    return {
+        "n_bfo": len(bfo_meas),
+        "n_bto": len(bto_meas),
+        "rmse_bfo": rmse_bfo,
+        "rmse_bto": rmse_bto,
+        "combined": combined,
+    }
+
+
 # ================= Guided Solvers =================
 def _guided_start_dt():
     return RADAR_FIX_TIME_UTC
@@ -1196,11 +1315,6 @@ def solve_guided_straight(
     start_dt = _guided_start_dt()
     end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
 
-    best_h = None
-    best_turn_spd = None
-    best_full_legs = None
-    best_score = None
-
     # descent start
     descent_start_dt = None
     if (descent_start_choice or "").startswith("After Ping Ring 6"):
@@ -1208,45 +1322,70 @@ def solve_guided_straight(
     elif (descent_start_choice or "").startswith("After Ping Ring 7"):
         descent_start_dt = dt_ping7_utc()
 
-    # turn-speed candidates (turn only). Southern uses south_speed_knots.
-    turn_speed_candidates = _turn_speed_candidates(float(south_speed_knots))
-
-    h = GUIDED_HEADING_MIN
-    while h <= GUIDED_HEADING_MAX + 1e-9:
-        # Southern cruise continues as usual (fixed by speed profile)
-        southern_legs = make_legs_from_schedule(h, float(south_speed_knots), GUIDED_LEG_SCHEDULE_MIN)
-
-        # Search for plausible turn speed that best fits BFO/BTO
-        for spd_turn in turn_speed_candidates:
-            preturn_legs, _turn_info = build_turn_legs(
-                speed_knots=float(spd_turn),
-                method=method,
-                heading_final_deg=float(h),
-            )
-            full_legs = preturn_legs + southern_legs
-
-            # clip to 00:20 so scoring window and plotting window are consistent
-            full_legs = clip_legs_to_end_dt(full_legs, start_dt, end_dt)
-
-            # score using BFO/BTO inside start_dt→end_dt duration only
-            s = score_legs_bfo_bto(
-                RADAR_FIX_LAT, RADAR_FIX_LON, method, start_dt, end_dt, full_legs,
-                alt_ft, vs_fpm, descent_start_dt,
-                weight_bfo, weight_bto
-            )
+    # Precompute ping points once (windowed)
+    pts_all = _ping_points_after(start_dt)
+    pts_window = [(lbl, dt, bfo, bto) for (lbl, dt, bfo, bto) in pts_all if start_dt <= dt <= end_dt]
+    if len(pts_window) < 2:
+        return None, "Guided solve: not enough ping points to score.", None
+
+    def try_candidate(h_south: float, spd_turn: float):
+        southern_legs = make_legs_from_schedule(h_south, float(south_speed_knots), GUIDED_LEG_SCHEDULE_MIN)
+        preturn_legs, _turn_info = build_turn_legs(
+            speed_knots=float(spd_turn),
+            method=method,
+            heading_final_deg=float(h_south),
+        )
+        full_legs = preturn_legs + southern_legs
+        full_legs = clip_legs_to_end_dt(full_legs, start_dt, end_dt)
+        s = score_legs_bfo_bto(
+            RADAR_FIX_LAT, RADAR_FIX_LON, method, start_dt, end_dt, full_legs,
+            alt_ft, vs_fpm, descent_start_dt,
+            weight_bfo, weight_bto,
+            pts_window=pts_window
+        )
+        return s, full_legs
+
+    # -------- Stage 1: COARSE search --------
+    best_h = None
+    best_turn_spd = None
+    best_full_legs = None
+    best_score = None
+
+    coarse_headings = _frange(GUIDED_HEADING_MIN, GUIDED_HEADING_MAX, COARSE_HEADING_STEP_DEG)
+    coarse_turn_speeds = _turn_speed_candidates(float(south_speed_knots), COARSE_TURN_SPEED_STEP_KT)
+
+    for h in coarse_headings:
+        for spd_turn in coarse_turn_speeds:
+            s, legs = try_candidate(h, spd_turn)
             if s is not None and (best_score is None or s["combined"] < best_score["combined"]):
                 best_score = s
                 best_h = float(h)
                 best_turn_spd = float(spd_turn)
-                best_full_legs = full_legs
-
-        h += STRAIGHT_STEP_DEG
+                best_full_legs = legs
 
     if best_full_legs is None:
         return None, "Guided solve: not enough ping points to score.", None
 
+    # -------- Stage 2: REFINE around best --------
+    refine_headings = _refine_range(best_h, REFINE_HEADING_HALF_WINDOW_DEG, STRAIGHT_STEP_DEG, GUIDED_HEADING_MIN, GUIDED_HEADING_MAX)
+    refine_turn_speeds = _refine_range(
+        best_turn_spd, REFINE_TURN_SPEED_HALF_WINDOW_KT, TURN_SPEED_STEP_KT,
+        max(TURN_SPEED_MIN_ABS_KT, float(south_speed_knots) - TURN_SPEED_SEARCH_DELTA_KT),
+        min(TURN_SPEED_MAX_ABS_KT, float(south_speed_knots) + TURN_SPEED_SEARCH_DELTA_KT),
+    )
+
+    for h in refine_headings:
+        for spd_turn in refine_turn_speeds:
+            s, legs = try_candidate(h, spd_turn)
+            if s is not None and (best_score is None or s["combined"] < best_score["combined"]):
+                best_score = s
+                best_h = float(h)
+                best_turn_spd = float(spd_turn)
+                best_full_legs = legs
+
     report = "\n".join([
         "**Guided mode: Straight + computed turn (18:22→18:40), clipped to 00:20**",
+        f"- Search mode: **two-stage (coarse → refine)**",
         f"- Southern speed (speed profile): **{float(south_speed_knots):.1f} kt**",
         f"- Best turn speed (18:22→18:40): **{float(best_turn_spd):.1f} kt**",
         f"- Best southern heading: **{best_h:.1f}°**",
@@ -1263,15 +1402,9 @@ def solve_guided_straight_with_drift(
     descent_start_choice, weight_bfo, weight_bto,
     drift_max_deg, drift_weight
 ):
-    # lightweight drift version: use nominal heading search, but add a small constant drift
     start_dt = _guided_start_dt()
     end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
 
-    best_h0 = None
-    best_turn_spd = None
-    best_full_legs = None
-    best_score = None
-
     # descent start
     descent_start_dt = None
     if (descent_start_choice or "").startswith("After Ping Ring 6"):
@@ -1279,64 +1412,113 @@ def solve_guided_straight_with_drift(
     elif (descent_start_choice or "").startswith("After Ping Ring 7"):
         descent_start_dt = dt_ping7_utc()
 
-    # try drift candidates within ±drift_max_deg
-    drift_candidates = list(np.arange(-float(drift_max_deg), float(drift_max_deg) + 1e-9, DRIFT_STEP_DEG))
-    if not drift_candidates:
-        drift_candidates = [0.0]
-
-    # turn-speed candidates (turn only). Southern uses south_speed_knots.
-    turn_speed_candidates = _turn_speed_candidates(float(south_speed_knots))
-
-    h0 = GUIDED_HEADING_MIN
-    while h0 <= GUIDED_HEADING_MAX + 1e-9:
-        for d in drift_candidates:
-            h_eff = _wrap_heading_deg(float(h0) + float(d))
-
-            # Southern cruise continues as usual (fixed by speed profile)
-            southern_legs = make_legs_from_schedule(h_eff, float(south_speed_knots), GUIDED_LEG_SCHEDULE_MIN)
-
-            # Search turn speed candidates for best fit
-            for spd_turn in turn_speed_candidates:
-                preturn_legs, _turn_info = build_turn_legs(
-                    speed_knots=float(spd_turn),
-                    method=method,
-                    heading_final_deg=float(h_eff),
-                )
-                full_legs = preturn_legs + southern_legs
-
-                # clip to 00:20
-                full_legs = clip_legs_to_end_dt(full_legs, start_dt, end_dt)
-
-                s = score_legs_bfo_bto(
-                    RADAR_FIX_LAT, RADAR_FIX_LON, method, start_dt, end_dt, full_legs,
-                    alt_ft, vs_fpm, descent_start_dt,
-                    weight_bfo, weight_bto
-                )
-                if s is None:
-                    continue
+    # Precompute ping points once (windowed)
+    pts_all = _ping_points_after(start_dt)
+    pts_window = [(lbl, dt, bfo, bto) for (lbl, dt, bfo, bto) in pts_all if start_dt <= dt <= end_dt]
+    if len(pts_window) < 2:
+        return None, "Guided drift solve: not enough ping points to score.", None
+
+    drift_max_deg = float(drift_max_deg)
+
+    def try_candidate(h0_nominal: float, drift_deg: float, spd_turn: float):
+        h_eff = _wrap_heading_deg(float(h0_nominal) + float(drift_deg))
+
+        southern_legs = make_legs_from_schedule(h_eff, float(south_speed_knots), GUIDED_LEG_SCHEDULE_MIN)
+        preturn_legs, _turn_info = build_turn_legs(
+            speed_knots=float(spd_turn),
+            method=method,
+            heading_final_deg=float(h_eff),
+        )
+        full_legs = preturn_legs + southern_legs
+        full_legs = clip_legs_to_end_dt(full_legs, start_dt, end_dt)
+
+        s = score_legs_bfo_bto(
+            RADAR_FIX_LAT, RADAR_FIX_LON, method, start_dt, end_dt, full_legs,
+            alt_ft, vs_fpm, descent_start_dt,
+            weight_bfo, weight_bto,
+            pts_window=pts_window
+        )
+        if s is None:
+            return None, None, None
+
+        combined_plus = float(s["combined"]) + float(drift_weight) * (abs(float(drift_deg)) / DRIFT_SCALE_DEG)
+        return s, combined_plus, full_legs
+
+    # -------- Stage 1: COARSE search --------
+    best_h0 = None
+    best_d = None
+    best_turn_spd = None
+    best_full_legs = None
+    best_score = None
+    best_combined_plus = None
+
+    coarse_headings = _frange(GUIDED_HEADING_MIN, GUIDED_HEADING_MAX, COARSE_HEADING_STEP_DEG)
+
+    # Drift candidates (coarse)
+    if drift_max_deg <= 1e-9:
+        coarse_drifts = [0.0]
+    else:
+        coarse_drifts = list(np.arange(-drift_max_deg, drift_max_deg + 1e-9, COARSE_DRIFT_STEP_DEG))
+        if 0.0 not in coarse_drifts:
+            coarse_drifts.append(0.0)
+        coarse_drifts = sorted({round(float(x), 6) for x in coarse_drifts})
 
-                # add drift penalty (RMS here is just |d| for constant drift)
-                combined = float(s["combined"]) + float(drift_weight) * (abs(float(d)) / DRIFT_SCALE_DEG)
+    coarse_turn_speeds = _turn_speed_candidates(float(south_speed_knots), COARSE_TURN_SPEED_STEP_KT)
 
-                if best_score is None or combined < best_score["combined_plus"]:
+    for h0 in coarse_headings:
+        for d in coarse_drifts:
+            for spd_turn in coarse_turn_speeds:
+                s, combined_plus, legs = try_candidate(h0, d, spd_turn)
+                if s is None:
+                    continue
+                if best_combined_plus is None or float(combined_plus) < float(best_combined_plus):
                     best_score = dict(s)
-                    best_score["combined_plus"] = combined
-                    best_score["drift_used"] = float(d)
+                    best_combined_plus = float(combined_plus)
                     best_h0 = float(h0)
+                    best_d = float(d)
                     best_turn_spd = float(spd_turn)
-                    best_full_legs = full_legs
-
-        h0 += 1.0
+                    best_full_legs = legs
 
     if best_full_legs is None:
         return None, "Guided drift solve: not enough ping points to score.", None
 
+    # -------- Stage 2: REFINE around best --------
+    refine_headings = _refine_range(best_h0, REFINE_HEADING_HALF_WINDOW_DEG, 1.0, GUIDED_HEADING_MIN, GUIDED_HEADING_MAX)
+
+    # Refine drift around best_d with DRIFT_STEP_DEG (0.5)
+    d_lo = max(-drift_max_deg, best_d - REFINE_DRIFT_HALF_WINDOW_DEG)
+    d_hi = min(+drift_max_deg, best_d + REFINE_DRIFT_HALF_WINDOW_DEG)
+    refine_drifts = _frange(d_lo, d_hi, DRIFT_STEP_DEG)
+    if not refine_drifts:
+        refine_drifts = [best_d]
+
+    refine_turn_speeds = _refine_range(
+        best_turn_spd, REFINE_TURN_SPEED_HALF_WINDOW_KT, TURN_SPEED_STEP_KT,
+        max(TURN_SPEED_MIN_ABS_KT, float(south_speed_knots) - TURN_SPEED_SEARCH_DELTA_KT),
+        min(TURN_SPEED_MAX_ABS_KT, float(south_speed_knots) + TURN_SPEED_SEARCH_DELTA_KT),
+    )
+
+    for h0 in refine_headings:
+        for d in refine_drifts:
+            for spd_turn in refine_turn_speeds:
+                s, combined_plus, legs = try_candidate(h0, d, spd_turn)
+                if s is None:
+                    continue
+                if best_combined_plus is None or float(combined_plus) < float(best_combined_plus):
+                    best_score = dict(s)
+                    best_combined_plus = float(combined_plus)
+                    best_h0 = float(h0)
+                    best_d = float(d)
+                    best_turn_spd = float(spd_turn)
+                    best_full_legs = legs
+
     report = "\n".join([
         "**Guided mode: Straight + drift + computed turn (18:22→18:40), clipped to 00:20**",
+        f"- Search mode: **two-stage (coarse → refine)**",
         f"- Southern speed (speed profile): **{float(south_speed_knots):.1f} kt**",
         f"- Best turn speed (18:22→18:40): **{float(best_turn_spd):.1f} kt**",
         f"- Best nominal heading: **{best_h0:.1f}°**",
-        f"- Drift used: **{best_score.get('drift_used', 0.0):+.1f}°** | Drift penalty weight: **{float(drift_weight):.2f}**",
+        f"- Drift used: **{best_d:+.1f}°** | Drift penalty weight: **{float(drift_weight):.2f}**",
         f"- BFO points: **{best_score['n_bfo']}** | RMSE_BFO: **{best_score['rmse_bfo']:.2f} Hz**",
         f"- BTO points: **{best_score['n_bto']}** | RMSE_BTO: **{best_score['rmse_bto']:.1f} µs**" if best_score.get("rmse_bto") is not None else
         f"- BTO points: **{best_score['n_bto']}** | RMSE_BTO: n/a",
@@ -1345,80 +1527,6 @@ def solve_guided_straight_with_drift(
     return best_full_legs, report, start_dt
 
 
-# ================= Scoring helper (used in guided solvers) =================
-def score_legs_bfo_bto(
-    start_lat, start_lon, method, start_dt, end_dt, legs,
-    alt_ft, vs_fpm, descent_start_dt,
-    weight_bfo: float, weight_bto: float
-):
-    pts = _ping_points_after(start_dt)
-    pts = [(lbl, dt, bfo, bto) for (lbl, dt, bfo, bto) in pts if start_dt <= dt <= end_dt]
-    if len(pts) < 2:
-        return None
-
-    leg_secs = [float(m) * 60.0 for _, _, m in legs]
-    boundaries = np.cumsum([0.0] + leg_secs)
-    total_end = float(boundaries[-1])
-
-    leg_start_positions = _precompute_leg_starts(start_lat, start_lon, legs, method)
-
-    bfo_preds, bfo_meas = [], []
-    bto_preds, bto_meas = [], []
-
-    for _lbl, dt_ping, meas_bfo, meas_bto in pts:
-        t_sec = (dt_ping - start_dt).total_seconds()
-        if t_sec < 0 or t_sec > total_end:
-            continue
-
-        i = int(np.searchsorted(boundaries, t_sec, side="right") - 1)
-        i = max(0, min(i, len(legs) - 1))
-        t_inside = float(t_sec) - float(boundaries[i])
-
-        leg_start_lat, leg_start_lon = leg_start_positions[i]
-        hdg, spd, _ = legs[i]
-        lat, lon = _predict_state_from_leg_start(method, leg_start_lat, leg_start_lon, hdg, spd, t_inside)
-
-        alt_now_ft = altitude_ft_at_dt(dt_ping, start_dt, float(alt_ft), float(vs_fpm), descent_start_dt)
-        alt_m = alt_now_ft * 0.3048
-
-        vs_mps = float(vs_fpm) * 0.00508
-        if descent_start_dt is not None and dt_ping < descent_start_dt:
-            vs_mps = 0.0
-
-        spd_mps = float(spd) * 1852.0 / 3600.0
-        pred_bfo = float(fp.calculateBFO_at_time(spd_mps, float(hdg), float(lat), float(lon), alt_m, vs_mps, dt_ping))
-        bfo_preds.append(pred_bfo)
-        bfo_meas.append(float(meas_bfo))
-
-        if meas_bto is not None:
-            pred_bto = float(fp.calculateBTO_at_time(float(lat), float(lon), alt_m, dt_ping))
-            bto_preds.append(pred_bto)
-            bto_meas.append(float(meas_bto))
-
-    if len(bfo_meas) < 2:
-        return None
-
-    e_bfo = np.array(bfo_preds) - np.array(bfo_meas)
-    rmse_bfo = float(np.sqrt(np.mean(e_bfo * e_bfo)))
-
-    rmse_bto = None
-    if len(bto_meas) >= 2:
-        e_bto = np.array(bto_preds) - np.array(bto_meas)
-        rmse_bto = float(np.sqrt(np.mean(e_bto * e_bto)))
-
-    combined = float(weight_bfo) * (rmse_bfo / BFO_SCALE_HZ)
-    if rmse_bto is not None:
-        combined += float(weight_bto) * (rmse_bto / BTO_SCALE_US)
-
-    return {
-        "n_bfo": len(bfo_meas),
-        "n_bto": len(bto_meas),
-        "rmse_bfo": rmse_bfo,
-        "rmse_bto": rmse_bto,
-        "combined": combined,
-    }
-
-
 # ================= RUNNERS =================
 def _run_common(start_lat, start_lon, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice):
     # In guided mode, ensure the polyline ends at 00:20 by clipping legs to end_dt first.
@@ -1466,7 +1574,7 @@ def run_guided(
     weight_bfo, weight_bto,
     drift_max_deg, drift_weight
 ):
-    # This is the SOUTHERN cruise speed (post-18:40). Turn speed is now searched independently.
+    # This is the SOUTHERN cruise speed (post-18:40). Turn speed is searched independently.
     south_spd_knots = speed_from_profile(speed_profile, alt_ft, custom_mach, custom_knots)
 
     if (guided_scenario or "").startswith("Straight + drift"):
@@ -1527,7 +1635,8 @@ with gr.Blocks() as demo:
         f"- **Turn completion (fixed):** 18:40:00Z\n"
         f"- **Initial track (fixed):** {RADAR_INITIAL_TRACK_DEG:.1f}°\n"
         f"- **Final resting point:** **00:20:00Z** (trajectory clipped exactly at this time)\n\n"
-        f"**Turn behavior:** 18:22→18:40 turn is now solved with **adjustable turn speed** (southern speed still follows the selected speed profile)."
+        f"**Turn behavior:** 18:22→18:40 turn is solved with **adjustable turn speed**.\n"
+        f"**Performance:** guided solver uses **two-stage search (coarse → refine)** to run faster."
     )
 
     with gr.Row():