Update app.py

app.py

@@ -2,8 +2,8 @@
 # MH370 Flight Simulator — Leaflet map (Folium) + Ping Rings (KML)
 #
 # Guided scenarios (ACTIVE):
-#   A) Straight heading (single southern heading)
-#   B) Variable Heading and Speed (southern headings AND speeds vary by segment)
+#   A) Straight heading
+#   B) Variable heading & speed  (beam search, BTO-first)
 #
 # Key behavior:
 # - Last radar spot FIXED: 18:22:00Z @ 6.578N, 96.341E
@@ -12,21 +12,15 @@
 # - Guided validation timestamps: 18:22, 18:40, 19:40, 20:40, 21:40, 22:40, 00:10, 00:20
 #
 # THIS VERSION:
-# - Guided solver is BTO-first "ring-fit"
+# - Solver is BTO-first "ring-fit"
 # - IMPORTANT: If a timestamp has no measured BTO (e.g. 18:40 in your satLoc),
 #   the solver automatically does NOT enforce BTO there.
 # - Turn speed range: 470–520 kt
-# - Southern segment speed range: 430–510 kt (per segment)
+# - Southern segment speed range: 430–510 kt
 #
-# PERFORMANCE UPDATE (Top-K polish for Straight heading):
-# - The expensive “polish” step is NOT run for every candidate anymore.
-# - We search fast first, keep top-K candidates, then polish ONLY those.
-#
-# NEW (Variable Heading and Speed mode):
-# - After 18:40, BOTH heading and speed can vary per ping-to-ping segment.
-# - Uses a fast beam search over heading choices + per-segment speed fit (root/abs-min),
-#   prioritizing BTO at measured ping rings.
-# - Heading changes are constrained (small window) to keep runtime reasonable.
+# PERFORMANCE:
+# - Straight heading mode keeps Top-K polish.
+# - Variable heading & speed uses beam search and skips polish by default (much faster).
 
 import os
 import re
@@ -74,13 +68,6 @@ RING_TIMES = {
     "Ping Ring 7": "24:10:00Z",
 }
 
-# Normalization (used for combining BFO + BTO into a single score)
-BFO_SCALE_HZ = 5.0
-BTO_SCALE_US = 50.0
-
-DEFAULT_WEIGHT_BFO = 1.0
-DEFAULT_WEIGHT_BTO = 2.0
-
 # satLoc indices
 SATLOC_IDX_MEAS_BFO = 4
 SATLOC_IDX_MEAS_BTO = 5
@@ -120,7 +107,7 @@ TURN_SPEED_MAX_KT = 520.0
 SOUTH_SPEED_MIN_KT = 430.0
 SOUTH_SPEED_MAX_KT = 510.0
 
-# Guided heading search (south-ish) — used for Straight heading mode
+# ===== Straight heading search =====
 GUIDED_HEADING_MIN = 175
 GUIDED_HEADING_MAX = 190
 COARSE_HEADING_STEP_DEG = 2.0
@@ -131,33 +118,25 @@ REFINE_HEADING_STEP_DEG = 0.5
 GUIDED_SOUTH_SEG_MIN = [60.0, 60.0, 60.0, 60.0, 90.0, 10.0]
 GUIDED_SOUTH_SEG_LABELS_END = ["19:40:00", "20:40:00", "21:40:00", "22:40:00", "24:10:00", "24:20:00"]
 
-# HARD BTO labels list (will be AUTO-FILTERED to those with measured BTO)
+# HARD BTO labels list (AUTO-FILTERED to those with measured BTO)
 HARD_BTO_LABELS = ["18:40:00", "19:40:00", "20:40:00", "21:40:00", "22:40:00", "24:10:00", "24:20:00"]
 
-# ===== Performance knobs: Top-K polish (Straight heading mode) =====
-TOPK_POLISH = 5                 # polish only the best K candidates globally
-ENABLE_POLISH = True            # keep polish, but only for top-K
-POLISH_PASSES = 3               # fewer passes = faster
-POLISH_WINDOW_KT = 6.0          # +/- window around current segment speed
-POLISH_STEP_KT = 2.0            # step for coordinate search
-POLISH_OBJ_EPS = 1e-3           # secondary weight for sum(abs)
-
-# ===== Variable Heading and Speed mode knobs (fast) =====
-VAR_HEADING_GLOBAL_MIN = 170.0
-VAR_HEADING_GLOBAL_MAX = 195.0
-VAR_TURN_HEADING_COARSE_MIN = 175.0
-VAR_TURN_HEADING_COARSE_MAX = 190.0
-VAR_TURN_HEADING_STEP = 2.0          # coarse choice for heading at 18:40
-VAR_TURN_SPEED_STEP = 10.0           # coarse scan for turn speed
-VAR_BEAM_WIDTH = 8                   # keep small for speed
-VAR_HEADING_STEP = 1.5               # candidate headings per segment
-VAR_HEADING_WINDOW_DEG = 6.0         # +/- window around previous segment heading
-VAR_FIRST_WINDOW_DEG = 8.0           # first segment a bit wider
-VAR_MAX_CAND_PER_STATE = 9           # cap expansions
-VAR_ENABLE_LIGHT_REFINEMENT = True   # optional second-pass with smaller step
-VAR_REFINE_STEP = 1.0
-VAR_REFINE_WINDOW = 3.0
-VAR_TOPK_FINAL = 10                  # keep top N full trajectories before final scoring
+# ===== Performance knobs: Top-K polish (Straight mode only) =====
+TOPK_POLISH = 5
+ENABLE_POLISH_STRAIGHT = True
+POLISH_PASSES = 3
+POLISH_WINDOW_KT = 6.0
+POLISH_STEP_KT = 2.0
+POLISH_OBJ_EPS = 1e-3
+
+# ===== Variable heading & speed solver knobs (FAST) =====
+VAR_HEADING_MIN = 170.0
+VAR_HEADING_MAX = 200.0
+VAR_TURN_SPEED_STEP = 10.0          # coarse turn speed scan
+VAR_FIRST_HEADING_STEP = 4.0        # coarse first south heading grid
+VAR_HEADING_DELTA_SET = [-6, -3, 0, 3, 6]  # candidate changes per segment (deg)
+VAR_BEAM_WIDTH = 12                  # keep top-N partial paths each segment
+VAR_SMOOTH_PENALTY_US_PER_DEG = 1.5  # small penalty to avoid wiggles (still BTO-first)
 
 # Search area colors (optional)
 SEARCH_AREA_COLORS = {
@@ -700,7 +679,7 @@ def clip_legs_to_end_dt(legs, start_dt: datetime, end_dt: datetime):
     return out
 
 
-# ================= BFO ANALYSIS (RESTORED) =================
+# ================= BFO ANALYSIS =================
 def _ping_points_after(start_dt: datetime):
     pts = []
     for row in fp.satLoc:
@@ -1222,7 +1201,6 @@ def _fit_segment_speed(
     e_lo = float(err(vmin))
     e_hi = float(err(vmax))
 
-    # If sign change: bisection root (fast + tight)
     if (e_lo < 0.0 and e_hi > 0.0) or (e_lo > 0.0 and e_hi < 0.0):
         a, b = float(vmin), float(vmax)
         fa, fb = e_lo, e_hi
@@ -1240,8 +1218,7 @@ def _fit_segment_speed(
         lat1, lon1 = _simulate_one_leg_end(method, lat0, lon0, hdg, v_best, minutes)
         return float(v_best), float(err(v_best)), (lat1, lon1)
 
-    # No sign change: minimize |err| on bounds
-    v_best, _ = _golden_min_abs(err, vmin, vmax, iters=22)
+    v_best, _ = _golden_min_abs(err, vmin, vmax, iters=18)
     lat1, lon1 = _simulate_one_leg_end(method, lat0, lon0, hdg, v_best, minutes)
     return float(v_best), float(err(v_best)), (lat1, lon1)
 
@@ -1268,16 +1245,25 @@ def _compute_bto_errors_at_enforced(
     return errs
 
 
-def _build_legs_from_segment_lists(turn_legs, headings, speeds, minutes):
-    south_legs = []
+def _build_south_legs_piecewise_constant_heading(h_south: float, speeds: list[float], minutes: list[float]):
+    legs = []
+    for v, m in zip(speeds, minutes):
+        if float(m) <= 0:
+            continue
+        legs.append((float(h_south), float(v), float(m)))
+    return legs
+
+
+def _build_south_legs_variable(headings: list[float], speeds: list[float], minutes: list[float]):
+    legs = []
     for h, v, m in zip(headings, speeds, minutes):
         if float(m) <= 0:
             continue
-        south_legs.append((float(h), float(v), float(m)))
-    return turn_legs + south_legs
+        legs.append((float(h), float(v), float(m)))
+    return legs
 
 
-# ================= Straight heading mode: polish (unchanged logic) =================
+# ================= Top-K polish (Straight mode only) =================
 def _polish_south_speeds_topk(
     method: str,
     start_dt: datetime,
@@ -1300,38 +1286,35 @@ def _polish_south_speeds_topk(
 
     def build_full(speeds_now: list[float]):
         lat_cur, lon_cur = turn_end_lat, turn_end_lon
-        south_errs_local = []
+        seg_errs = []
         for mins, end_lbl, vseg in zip(GUIDED_SOUTH_SEG_MIN, GUIDED_SOUTH_SEG_LABELS_END, speeds_now):
             dt_end = _dt_from_label(end_lbl)
             lat_cur, lon_cur = _simulate_one_leg_end(method, lat_cur, lon_cur, h_south, vseg, mins)
             meas = _lookup_measured_bto(dt_end)
             if meas is None:
-                south_errs_local.append(float("nan"))
+                seg_errs.append(float("nan"))
             else:
                 bto_here = _bto_calc(method, lat_cur, lon_cur, dt_end, alt_ft, vs_fpm, start_dt, descent_start_dt)
-                south_errs_local.append(float(bto_here - meas))
+                seg_errs.append(float(bto_here - meas))
 
-        full_legs = clip_legs_to_end_dt(
-            turn_legs + [(float(h_south), float(v), float(m)) for v, m in zip(speeds_now, GUIDED_SOUTH_SEG_MIN)],
-            start_dt,
-            end_dt,
-        )
-        return full_legs, south_errs_local
+        south_legs = _build_south_legs_piecewise_constant_heading(h_south, speeds_now, GUIDED_SOUTH_SEG_MIN)
+        full_legs = clip_legs_to_end_dt(turn_legs + south_legs, start_dt, end_dt)
+        return full_legs, seg_errs
 
     def objective(full_legs):
         bto_errs = _compute_bto_errors_at_enforced(method, start_dt, alt_ft, vs_fpm, descent_start_dt, full_legs, enforced_dts)
         if not bto_errs:
-            return 1e9, []
+            return 1e9
         abs_arr = np.abs(np.array(bto_errs, dtype=float))
         max_abs = float(np.max(abs_arr))
         sum_abs = float(np.sum(abs_arr))
-        return float(max_abs + POLISH_OBJ_EPS * sum_abs), bto_errs
+        return float(max_abs + POLISH_OBJ_EPS * sum_abs)
 
-    full_legs, south_errs = build_full(speeds)
-    best_obj, _ = objective(full_legs)
+    full_legs, seg_errs = build_full(speeds)
+    best_obj = objective(full_legs)
     best_speeds = speeds[:]
     best_full = full_legs
-    best_south_errs = south_errs
+    best_seg_errs = seg_errs
 
     for _p in range(int(passes)):
         improved_any = False
@@ -1339,6 +1322,7 @@ def _polish_south_speeds_topk(
             v0 = float(best_speeds[i])
             v_lo = _clamp(v0 - float(window_kt), SOUTH_SPEED_MIN_KT, SOUTH_SPEED_MAX_KT)
             v_hi = _clamp(v0 + float(window_kt), SOUTH_SPEED_MIN_KT, SOUTH_SPEED_MAX_KT)
+
             cand = list(np.arange(v_lo, v_hi + 1e-9, float(step_kt)))
             if not cand:
                 continue
@@ -1346,37 +1330,34 @@ def _polish_south_speeds_topk(
             local_best_obj = best_obj
             local_best_speeds = best_speeds[:]
             local_best_full = best_full
-            local_best_south_errs = best_south_errs
+            local_best_seg_errs = best_seg_errs
 
             for v_try in cand:
                 sp = best_speeds[:]
                 sp[i] = float(v_try)
-                full_try, south_errs_try = build_full(sp)
-                obj_try, _ = objective(full_try)
+                full_try, seg_try = build_full(sp)
+                obj_try = objective(full_try)
                 if obj_try < local_best_obj - 1e-9:
                     local_best_obj = obj_try
                     local_best_speeds = sp
                     local_best_full = full_try
-                    local_best_south_errs = south_errs_try
+                    local_best_seg_errs = seg_try
 
             if local_best_obj < best_obj - 1e-9:
                 best_obj = local_best_obj
                 best_speeds = local_best_speeds
                 best_full = local_best_full
-                best_south_errs = local_best_south_errs
+                best_seg_errs = local_best_seg_errs
                 improved_any = True
 
         if not improved_any:
             break
 
-    return best_speeds, best_full, best_south_errs
+    return best_speeds, best_full, best_seg_errs
 
 
-# ================= Guided solver: Straight heading =================
-def solve_guided_straight_heading(
-    method, alt_ft, vs_fpm,
-    descent_start_choice, weight_bfo, weight_bto
-):
+# ================= Guided Solver: Straight heading =================
+def solve_guided_straight(method, alt_ft, vs_fpm, descent_start_choice):
     start_dt = _guided_start_dt()
     end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
 
@@ -1394,9 +1375,10 @@ def solve_guided_straight_heading(
     enforced_labels = _available_hard_bto_labels()
     if not enforced_labels:
         return None, "Guided solve: no measured BTO available at any enforced ring times.", None
+
     enforced_dts = [_dt_from_label(lbl) for lbl in enforced_labels]
 
-    def _evaluate(h_south: float, v_turn: float, do_polish: bool = False):
+    def _evaluate(h_south: float, v_turn: float, do_polish: bool):
         h_south = float(h_south)
         v_turn = float(v_turn)
 
@@ -1431,14 +1413,11 @@ def solve_guided_straight_heading(
             south_errs.append(float(err_seg))
             lat_cur, lon_cur = float(lat1), float(lon1)
 
-        full_legs = clip_legs_to_end_dt(
-            turn_legs + [(float(h_south), float(v), float(m)) for v, m in zip(south_speeds, GUIDED_SOUTH_SEG_MIN)],
-            start_dt,
-            end_dt,
-        )
+        south_legs = _build_south_legs_piecewise_constant_heading(float(h_south), south_speeds, GUIDED_SOUTH_SEG_MIN)
+        full_legs = clip_legs_to_end_dt(turn_legs + south_legs, start_dt, end_dt)
 
-        if do_polish and ENABLE_POLISH:
-            polished_speeds, polished_full, polished_seg_errs = _polish_south_speeds_topk(
+        if do_polish and ENABLE_POLISH_STRAIGHT:
+            south_speeds, full_legs, south_errs = _polish_south_speeds_topk(
                 method=method,
                 start_dt=start_dt,
                 end_dt=end_dt,
@@ -1449,13 +1428,7 @@ def solve_guided_straight_heading(
                 turn_legs=turn_legs,
                 enforced_dts=enforced_dts,
                 init_speeds=south_speeds,
-                passes=POLISH_PASSES,
-                window_kt=POLISH_WINDOW_KT,
-                step_kt=POLISH_STEP_KT,
             )
-            south_speeds = polished_speeds
-            full_legs = polished_full
-            south_errs = polished_seg_errs
 
         bto_errs = _compute_bto_errors_at_enforced(method, start_dt, alt_ft, vs_fpm, descent_start_dt, full_legs, enforced_dts)
         if not bto_errs:
@@ -1467,10 +1440,8 @@ def solve_guided_straight_heading(
         rmse = float(np.sqrt(np.mean(np.array(bto_errs, dtype=float) ** 2)))
 
         details = {
-            "mode": "Straight heading",
             "h_south": float(h_south),
             "v_turn": float(v_turn),
-            "south_headings": [float(h_south)] * len(GUIDED_SOUTH_SEG_MIN),
             "south_speeds": [float(v) for v in south_speeds],
             "south_errs_us": [float(e) for e in south_errs],
             "turn_info": turn_info,
@@ -1478,18 +1449,15 @@ def solve_guided_straight_heading(
             "max_abs_err_us": max_abs,
             "sum_abs_err_us": sum_abs,
             "rmse_bto_us": rmse,
-            "polished": bool(do_polish and ENABLE_POLISH),
+            "polished": bool(do_polish and ENABLE_POLISH_STRAIGHT),
         }
-        key = (max_abs, sum_abs, rmse)
-        return key, full_legs, details
+        return (max_abs, sum_abs, rmse), full_legs, details
 
     def best_for_heading(h_south: float):
-        h_south = float(h_south)
-
         coarse_turns = list(np.arange(TURN_SPEED_MIN_KT, TURN_SPEED_MAX_KT + 1e-9, 5.0))
         best_key = None
         best_legs = None
-        best_details = None
+        best_det = None
 
         for v in coarse_turns:
             out = _evaluate(h_south, v, do_polish=False)
@@ -1497,12 +1465,12 @@ def solve_guided_straight_heading(
                 continue
             key, legs, det = out
             if best_key is None or key < best_key:
-                best_key, best_legs, best_details = key, legs, det
+                best_key, best_legs, best_det = key, legs, det
 
         if best_key is None:
             return None
 
-        v0 = float(best_details["v_turn"])
+        v0 = float(best_det["v_turn"])
         v_lo = _clamp(v0 - 7.5, TURN_SPEED_MIN_KT, TURN_SPEED_MAX_KT)
         v_hi = _clamp(v0 + 7.5, TURN_SPEED_MIN_KT, TURN_SPEED_MAX_KT)
 
@@ -1513,32 +1481,33 @@ def solve_guided_straight_heading(
             (max_abs, sum_abs, _rmse), _legs, _det = out2
             return float(max_abs) + POLISH_OBJ_EPS * float(sum_abs)
 
-        v_best, _ = _golden_min_abs(obj, v_lo, v_hi, iters=18)
+        v_best, _ = _golden_min_abs(obj, v_lo, v_hi, iters=16)
         out3 = _evaluate(h_south, v_best, do_polish=False)
         if out3 is None:
-            return best_key, best_legs, best_details
-        key3, legs3, det3 = out3
-        return key3, legs3, det3
+            return best_key, best_legs, best_det
+        return out3
 
+    # Stage 1
     coarse_headings = _frange(GUIDED_HEADING_MIN, GUIDED_HEADING_MAX, COARSE_HEADING_STEP_DEG)
-    global_best = None
-    global_legs = None
-    global_det = None
-
     candidates = []
+    best = None
+    best_legs = None
+    best_det = None
+
     for h in coarse_headings:
         out = best_for_heading(h)
         if out is None:
             continue
         key, legs, det = out
         candidates.append((key, float(det["h_south"]), float(det["v_turn"])))
-        if global_best is None or key < global_best:
-            global_best, global_legs, global_det = key, legs, det
+        if best is None or key < best:
+            best, best_legs, best_det = key, legs, det
 
-    if global_legs is None:
-        return None, "Guided solve: no solution found within speed bounds.", None
+    if best_legs is None:
+        return None, "Guided solve: no solution found within bounds.", None
 
-    h0 = float(global_det["h_south"])
+    # Stage 2
+    h0 = float(best_det["h_south"])
     refine_headings = _refine_range(h0, REFINE_HEADING_HALF_WINDOW_DEG, REFINE_HEADING_STEP_DEG, GUIDED_HEADING_MIN, GUIDED_HEADING_MAX)
     for h in refine_headings:
         out = best_for_heading(h)
@@ -1546,9 +1515,10 @@ def solve_guided_straight_heading(
             continue
         key, legs, det = out
         candidates.append((key, float(det["h_south"]), float(det["v_turn"])))
-        if global_best is None or key < global_best:
-            global_best, global_legs, global_det = key, legs, det
+        if best is None or key < best:
+            best, best_legs, best_det = key, legs, det
 
+    # Top-K polish
     candidates_sorted = sorted(candidates, key=lambda x: x[0])
     uniq = []
     seen = set()
@@ -1561,20 +1531,15 @@ def solve_guided_straight_heading(
         if len(uniq) >= max(1, int(TOPK_POLISH)):
             break
 
-    best_final_key = global_best
-    best_final_legs = global_legs
-    best_final_det = global_det
-
-    if ENABLE_POLISH and uniq:
+    best_final_key, best_final_legs, best_final_det = best, best_legs, best_det
+    if ENABLE_POLISH_STRAIGHT and uniq:
         for _key, hh, vv in uniq:
             outp = _evaluate(hh, vv, do_polish=True)
             if outp is None:
                 continue
             keyp, legsp, detp = outp
             if best_final_key is None or keyp < best_final_key:
-                best_final_key = keyp
-                best_final_legs = legsp
-                best_final_det = detp
+                best_final_key, best_final_legs, best_final_det = keyp, legsp, detp
 
     south_speeds = best_final_det["south_speeds"]
     south_errs = best_final_det["south_errs_us"]
@@ -1584,33 +1549,28 @@ def solve_guided_straight_heading(
         "**Guided mode: Straight heading + computed turn (18:22→18:40), clipped to 00:20**",
         "- Solver mode: **BTO-first ring-fit**",
         f"- Best southern heading: **{best_final_det['h_south']:.2f}°**",
-        f"- Turn speed range: {TURN_SPEED_MIN_KT:.0f}–{TURN_SPEED_MAX_KT:.0f} kt | Best: **{best_final_det['v_turn']:.2f} kt**",
-        f"- Polish: **{'ON (Top-K only)' if ENABLE_POLISH else 'OFF'}** | Applied to winner: **{'YES' if polished_flag else 'NO'}**",
+        f"- Turn speed: **{best_final_det['v_turn']:.2f} kt** (range {TURN_SPEED_MIN_KT:.0f}–{TURN_SPEED_MAX_KT:.0f})",
+        f"- Polish: **{'ON (Top-K)' if ENABLE_POLISH_STRAIGHT else 'OFF'}** | Applied to winner: **{'YES' if polished_flag else 'NO'}**",
         "",
-        "**Southern per-segment speeds (each constrained to 430–510 kt):**",
-        f"- 18:40→19:40: **{south_speeds[0]:.2f} kt** (segment end err {south_errs[0]:+.2f} µs)",
-        f"- 19:40→20:40: **{south_speeds[1]:.2f} kt** (segment end err {south_errs[1]:+.2f} µs)",
-        f"- 20:40→21:40: **{south_speeds[2]:.2f} kt** (segment end err {south_errs[2]:+.2f} µs)",
-        f"- 21:40→22:40: **{south_speeds[3]:.2f} kt** (segment end err {south_errs[3]:+.2f} µs)",
-        f"- 22:40→00:10: **{south_speeds[4]:.2f} kt** (segment end err {south_errs[4]:+.2f} µs)",
-        f"- 00:10→00:20: **{south_speeds[5]:.2f} kt** (segment end err {south_errs[5]:+.2f} µs)",
+        "**Southern per-segment speeds:**",
+        f"- 18:40→19:40: **{south_speeds[0]:.2f} kt** (end err {south_errs[0]:+.2f} µs)",
+        f"- 19:40→20:40: **{south_speeds[1]:.2f} kt** (end err {south_errs[1]:+.2f} µs)",
+        f"- 20:40→21:40: **{south_speeds[2]:.2f} kt** (end err {south_errs[2]:+.2f} µs)",
+        f"- 21:40→22:40: **{south_speeds[3]:.2f} kt** (end err {south_errs[3]:+.2f} µs)",
+        f"- 22:40→00:10: **{south_speeds[4]:.2f} kt** (end err {south_errs[4]:+.2f} µs)",
+        f"- 00:10→00:20: **{south_speeds[5]:.2f} kt** (end err {south_errs[5]:+.2f} µs)",
         "",
-        f"- Enforced BTO timestamps (measured available): **{', '.join(best_final_det['enforced_labels'])}**",
+        f"- Enforced BTO timestamps: **{', '.join(best_final_det['enforced_labels'])}**",
         f"- Max |BTO error| at enforced times: **{best_final_det['max_abs_err_us']:.2f} µs**",
         f"- RMSE_BTO at enforced times: **{best_final_det['rmse_bto_us']:.2f} µs**",
         "",
         "*If 18:40 has no measured BTO in your satLoc, it is automatically not enforced.*",
-        f"*Performance: polish runs only for top-{TOPK_POLISH} candidates now.*",
     ]
-
     return best_final_legs, "\n".join(report_lines), start_dt
 
 
-# ================= Guided solver: Variable heading + speed (fast beam search) =================
-def solve_guided_variable_heading_speed(
-    method, alt_ft, vs_fpm,
-    descent_start_choice, weight_bfo, weight_bto
-):
+# ================= Guided Solver: Variable heading & speed (FAST beam search) =================
+def solve_guided_variable(method, alt_ft, vs_fpm, descent_start_choice):
     start_dt = _guided_start_dt()
     end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
 
@@ -1625,239 +1585,174 @@ def solve_guided_variable_heading_speed(
         return None, "Guided solve: no measured BTO available at any enforced ring times.", None
     enforced_dts = [_dt_from_label(lbl) for lbl in enforced_labels]
 
-    # -------- Beam search for south segments (after a given 18:40 heading) --------
-    def beam_south_from_turn_end(lat0, lon0, h0):
-        h0 = float(h0)
-
-        def clamp_h(h):
-            return _clamp(float(h), VAR_HEADING_GLOBAL_MIN, VAR_HEADING_GLOBAL_MAX)
-
-        # state: lat, lon, prev_h, headings[], speeds[], seg_end_errs[], key(max_abs,sum_abs)
-        beam = [{
-            "lat": float(lat0),
-            "lon": float(lon0),
-            "prev_h": float(h0),
-            "headings": [],
-            "speeds": [],
-            "seg_errs": [],
-            "max_abs": 0.0,
-            "sum_abs": 0.0,
-        }]
-
-        for idx, (mins, end_lbl) in enumerate(zip(GUIDED_SOUTH_SEG_MIN, GUIDED_SOUTH_SEG_LABELS_END)):
-            dt_end = _dt_from_label(end_lbl)
-            next_states = []
+    # turn speed candidates (coarse)
+    turn_speeds = list(np.arange(TURN_SPEED_MIN_KT, TURN_SPEED_MAX_KT + 1e-9, VAR_TURN_SPEED_STEP))
 
-            for st in beam:
-                prev_h = float(st["prev_h"])
-                window = VAR_FIRST_WINDOW_DEG if idx == 0 else VAR_HEADING_WINDOW_DEG
-
-                # Candidate headings around prev_h
-                cand = _frange(clamp_h(prev_h - window), clamp_h(prev_h + window), VAR_HEADING_STEP)
-
-                # If too many, subsample evenly (keeps speed bounded)
-                if len(cand) > VAR_MAX_CAND_PER_STATE:
-                    take = VAR_MAX_CAND_PER_STATE
-                    if take <= 1:
-                        cand = [cand[len(cand)//2]]
-                    else:
-                        xs = np.linspace(0, len(cand) - 1, take)
-                        cand = [cand[int(round(x))] for x in xs]
-
-                for h_try in cand:
-                    v_seg, err_seg, (lat1, lon1) = _fit_segment_speed(
-                        method=method,
-                        lat0=st["lat"],
-                        lon0=st["lon"],
-                        hdg=float(h_try),
-                        minutes=float(mins),
-                        dt_end=dt_end,
-                        alt_ft=alt_ft,
-                        vs_fpm=vs_fpm,
-                        start_dt=start_dt,
-                        descent_start_dt=descent_start_dt,
-                        vmin=SOUTH_SPEED_MIN_KT,
-                        vmax=SOUTH_SPEED_MAX_KT,
-                    )
-
-                    # Use measured seg-end error if available; otherwise don't count it in partial score
-                    meas = _lookup_measured_bto(dt_end)
-                    if meas is None or (isinstance(err_seg, float) and np.isnan(err_seg)):
-                        e_abs = 0.0
-                        e_signed = float("nan")
-                    else:
-                        e_signed = float(err_seg)
-                        e_abs = abs(float(err_seg))
-
-                    max_abs = max(float(st["max_abs"]), float(e_abs))
-                    sum_abs = float(st["sum_abs"]) + float(e_abs)
-
-                    next_states.append({
-                        "lat": float(lat1),
-                        "lon": float(lon1),
-                        "prev_h": float(h_try),
-                        "headings": st["headings"] + [float(h_try)],
-                        "speeds": st["speeds"] + [float(v_seg)],
-                        "seg_errs": st["seg_errs"] + [float(e_signed) if not (isinstance(e_signed, float) and np.isnan(e_signed)) else float("nan")],
-                        "max_abs": float(max_abs),
-                        "sum_abs": float(sum_abs),
-                    })
-
-            if not next_states:
-                return []
-
-            # Keep best by (max_abs, sum_abs) — segment-level heuristic
-            next_states.sort(key=lambda s: (s["max_abs"], s["sum_abs"]))
-            beam = next_states[:max(1, int(VAR_BEAM_WIDTH))]
-
-        return beam
-
-    # -------- Evaluate a candidate: choose 18:40 heading + turn speed, then beam search headings --------
-    def evaluate_candidate(h40, v_turn, do_refine=False):
-        h40 = float(h40)
-        v_turn = float(v_turn)
+    # initial (first south heading) candidates (coarse)
+    first_headings = _frange(VAR_HEADING_MIN, VAR_HEADING_MAX, VAR_FIRST_HEADING_STEP)
 
-        turn_legs, turn_info = build_turn_legs(
-            speed_knots=float(v_turn),
-            method=method,
-            heading_final_deg=float(h40),
-        )
-        pts_turn, _, _ = simulate_path(RADAR_FIX_LAT, RADAR_FIX_LON, turn_legs, method)
-        lat_turn_end, lon_turn_end = float(pts_turn[-1][0]), float(pts_turn[-1][1])
-
-        beams = beam_south_from_turn_end(lat_turn_end, lon_turn_end, h40)
-        if not beams:
-            return []
-
-        finals = []
-        for st in beams:
-            full_legs = clip_legs_to_end_dt(
-                _build_legs_from_segment_lists(turn_legs, st["headings"], st["speeds"], GUIDED_SOUTH_SEG_MIN),
-                start_dt,
-                end_dt,
+    # Beam state:
+    # {
+    #   lat, lon, headings[], speeds[], v_turn, max_abs, sum_abs, smooth_sum
+    # }
+    best_global = None
+    best_global_legs = None
+    best_global_info = None
+
+    def score_from_errors(errs: list[float]):
+        if not errs:
+            return None
+        abs_arr = np.abs(np.array(errs, dtype=float))
+        return float(np.max(abs_arr)), float(np.sum(abs_arr)), float(np.sqrt(np.mean(abs_arr * abs_arr)))
+
+    for v_turn in turn_speeds:
+        for h1 in first_headings:
+            turn_legs, turn_info = build_turn_legs(
+                speed_knots=float(v_turn),
+                method=method,
+                heading_final_deg=float(h1),
             )
-            bto_errs = _compute_bto_errors_at_enforced(method, start_dt, alt_ft, vs_fpm, descent_start_dt, full_legs, enforced_dts)
-            if not bto_errs:
-                continue
-            abs_arr = np.abs(np.array(bto_errs, dtype=float))
-            max_abs = float(np.max(abs_arr))
-            sum_abs = float(np.sum(abs_arr))
-            rmse = float(np.sqrt(np.mean(np.array(bto_errs, dtype=float) ** 2)))
-
-            finals.append({
-                "key": (max_abs, sum_abs, rmse),
-                "legs": full_legs,
-                "det": {
-                    "mode": "Variable Heading and Speed",
-                    "h40": float(h40),
-                    "v_turn": float(v_turn),
-                    "south_headings": [float(h) for h in st["headings"]],
-                    "south_speeds": [float(v) for v in st["speeds"]],
-                    "south_errs_us": [float(e) for e in st["seg_errs"]],
-                    "turn_info": turn_info,
-                    "enforced_labels": enforced_labels,
-                    "max_abs_err_us": max_abs,
-                    "sum_abs_err_us": sum_abs,
-                    "rmse_bto_us": rmse,
-                }
-            })
-
-        finals.sort(key=lambda x: x["key"])
-        finals = finals[:max(1, int(VAR_TOPK_FINAL))]
-
-        # Optional refinement: re-run a tighter beam around the best headings (cheap-ish)
-        if do_refine and VAR_ENABLE_LIGHT_REFINEMENT and finals:
-            best = finals[0]["det"]
-            # Build tighter beams seeded by each segment heading (local windows)
-            # We re-run beam with smaller step/window, but still centered on previous heading (which follows best).
-            # To keep code simple, just temporarily override constants inside a nested closure.
-            old_step = VAR_HEADING_STEP
-            old_win = VAR_HEADING_WINDOW_DEG
-            old_first = VAR_FIRST_WINDOW_DEG
-            old_bw = VAR_BEAM_WIDTH
-            try:
-                # tighten
-                globals()["VAR_HEADING_STEP"] = float(VAR_REFINE_STEP)
-                globals()["VAR_HEADING_WINDOW_DEG"] = float(VAR_REFINE_WINDOW)
-                globals()["VAR_FIRST_WINDOW_DEG"] = float(VAR_REFINE_WINDOW + 1.0)
-                globals()["VAR_BEAM_WIDTH"] = max(6, int(VAR_BEAM_WIDTH))  # keep similar
-                # rerun from same turn end with the same h40/v_turn
-                finals2 = evaluate_candidate(h40, v_turn, do_refine=False)
-                if finals2:
-                    finals = sorted(finals + finals2, key=lambda x: x["key"])[:max(1, int(VAR_TOPK_FINAL))]
-            finally:
-                globals()["VAR_HEADING_STEP"] = old_step
-                globals()["VAR_HEADING_WINDOW_DEG"] = old_win
-                globals()["VAR_FIRST_WINDOW_DEG"] = old_first
-                globals()["VAR_BEAM_WIDTH"] = old_bw
-
-        return finals
-
-    # -------- Coarse global search over (h40, v_turn) --------
-    h40_list = _frange(VAR_TURN_HEADING_COARSE_MIN, VAR_TURN_HEADING_COARSE_MAX, VAR_TURN_HEADING_STEP)
-    vturn_list = _frange(TURN_SPEED_MIN_KT, TURN_SPEED_MAX_KT, VAR_TURN_SPEED_STEP)
-
-    best = None  # dict with key/legs/det
-    pool = []
-
-    for h40 in h40_list:
-        for vt in vturn_list:
-            finals = evaluate_candidate(h40, vt, do_refine=False)
-            if not finals:
+            pts_turn, _, _ = simulate_path(RADAR_FIX_LAT, RADAR_FIX_LON, turn_legs, method)
+            lat0, lon0 = float(pts_turn[-1][0]), float(pts_turn[-1][1])
+
+            # initialize beam after turn
+            beam = [{
+                "lat": lat0,
+                "lon": lon0,
+                "headings": [],
+                "speeds": [],
+                "h_prev": float(h1),
+                "v_turn": float(v_turn),
+                "turn_legs": turn_legs,
+                "turn_info": turn_info,
+                "max_abs": 0.0,
+                "sum_abs": 0.0,
+                "smooth_sum": 0.0,
+                "seg_end_errs": [],
+            }]
+
+            # walk segments with beam search
+            for mins, end_lbl in zip(GUIDED_SOUTH_SEG_MIN, GUIDED_SOUTH_SEG_LABELS_END):
+                dt_end = _dt_from_label(end_lbl)
+                meas = _lookup_measured_bto(dt_end)
+                next_beam = []
+
+                for st in beam:
+                    h_prev = float(st["h_prev"])
+                    # candidate headings around previous
+                    cand_h = []
+                    for d in VAR_HEADING_DELTA_SET:
+                        h_try = h_prev + float(d)
+                        h_try = _clamp(h_try, VAR_HEADING_MIN, VAR_HEADING_MAX)
+                        cand_h.append(h_try)
+                    # unique small set
+                    cand_h = sorted(list({round(x, 6): x for x in cand_h}.values()))
+
+                    for h_try in cand_h:
+                        v_seg, err_seg, (lat1, lon1) = _fit_segment_speed(
+                            method=method,
+                            lat0=float(st["lat"]),
+                            lon0=float(st["lon"]),
+                            hdg=float(h_try),
+                            minutes=float(mins),
+                            dt_end=dt_end,
+                            alt_ft=alt_ft,
+                            vs_fpm=vs_fpm,
+                            start_dt=start_dt,
+                            descent_start_dt=descent_start_dt,
+                            vmin=SOUTH_SPEED_MIN_KT,
+                            vmax=SOUTH_SPEED_MAX_KT,
+                        )
+
+                        # BTO-first objective: update errors only if measured exists
+                        abs_err = 0.0 if meas is None or (err_seg != err_seg) else abs(float(err_seg))
+                        smooth_pen = abs(float(h_try) - float(h_prev)) * VAR_SMOOTH_PENALTY_US_PER_DEG
+
+                        max_abs = max(float(st["max_abs"]), float(abs_err))
+                        sum_abs = float(st["sum_abs"]) + float(abs_err)
+                        smooth_sum = float(st["smooth_sum"]) + float(smooth_pen)
+
+                        next_beam.append({
+                            "lat": float(lat1),
+                            "lon": float(lon1),
+                            "headings": st["headings"] + [float(h_try)],
+                            "speeds": st["speeds"] + [float(v_seg)],
+                            "h_prev": float(h_try),
+                            "v_turn": float(st["v_turn"]),
+                            "turn_legs": st["turn_legs"],
+                            "turn_info": st["turn_info"],
+                            "max_abs": max_abs,
+                            "sum_abs": sum_abs,
+                            "smooth_sum": smooth_sum,
+                            "seg_end_errs": st["seg_end_errs"] + [float(err_seg)],
+                        })
+
+                # prune beam
+                if not next_beam:
+                    beam = []
+                    break
+
+                next_beam.sort(key=lambda x: (x["max_abs"], x["sum_abs"], x["smooth_sum"]))
+                beam = next_beam[:max(1, int(VAR_BEAM_WIDTH))]
+
+            if not beam:
                 continue
-            # keep the best from this pair
-            pool.append(finals[0])
-            if best is None or finals[0]["key"] < best["key"]:
-                best = finals[0]
-
-    if best is None:
-        return None, "Guided solve (Variable): no solution found within bounds.", None
-
-    # Pick top few pairs and refine only those (fast)
-    pool.sort(key=lambda x: x["key"])
-    pool = pool[:5]
-    refined_best = best
-    for cand in pool:
-        det = cand["det"]
-        finals = evaluate_candidate(det["h40"], det["v_turn"], do_refine=True)
-        if finals and (finals[0]["key"] < refined_best["key"]):
-            refined_best = finals[0]
-
-    det = refined_best["det"]
-    hs = det["south_headings"]
-    vs = det["south_speeds"]
-    es = det["south_errs_us"]
-
-    def fmt_err(e):
-        if e is None:
-            return "n/a"
-        if isinstance(e, float) and np.isnan(e):
-            return "n/a"
-        return f"{float(e):+.2f} µs"
+
+            # Evaluate final beam states using enforced timestamps (full recompute for safety)
+            for st in beam:
+                south_legs = _build_south_legs_variable(st["headings"], st["speeds"], GUIDED_SOUTH_SEG_MIN)
+                full_legs = clip_legs_to_end_dt(st["turn_legs"] + south_legs, start_dt, end_dt)
+
+                bto_errs = _compute_bto_errors_at_enforced(method, start_dt, alt_ft, vs_fpm, descent_start_dt, full_legs, enforced_dts)
+                if not bto_errs:
+                    continue
+
+                max_abs, sum_abs, rmse = score_from_errors(bto_errs)
+                key = (max_abs, sum_abs, st["smooth_sum"], rmse)
+
+                if best_global is None or key < best_global:
+                    best_global = key
+                    best_global_legs = full_legs
+                    best_global_info = {
+                        "v_turn": float(st["v_turn"]),
+                        "turn_info": st["turn_info"],
+                        "headings": [float(x) for x in st["headings"]],
+                        "speeds": [float(x) for x in st["speeds"]],
+                        "seg_end_errs": [float(x) for x in st["seg_end_errs"]],
+                        "enforced_labels": enforced_labels,
+                        "max_abs_err_us": float(max_abs),
+                        "sum_abs_err_us": float(sum_abs),
+                        "rmse_bto_us": float(rmse),
+                    }
+
+    if best_global_legs is None:
+        return None, "Guided solve: Variable mode found no solution within bounds.", None
+
+    hs = best_global_info["headings"]
+    vs = best_global_info["speeds"]
+    es = best_global_info["seg_end_errs"]
 
     report_lines = [
-        "**Guided mode: Variable Heading and Speed + computed turn (18:22→18:40), clipped to 00:20**",
-        "- Solver mode: **BTO-first ring-fit** (beam search headings + per-segment speed fit)",
-        f"- Heading @ 18:40 (post-turn): **{det['h40']:.2f}°**",
-        f"- Turn speed range: {TURN_SPEED_MIN_KT:.0f}–{TURN_SPEED_MAX_KT:.0f} kt | Best: **{det['v_turn']:.2f} kt**",
-        f"- Beam width: **{VAR_BEAM_WIDTH}** | Heading step: **{VAR_HEADING_STEP:.1f}°** | Window: **±{VAR_HEADING_WINDOW_DEG:.1f}°**",
+        "**Guided mode: Variable heading & speed + computed turn (18:22→18:40), clipped to 00:20**",
+        "- Solver mode: **BTO-first ring-fit (beam search)**",
+        f"- Turn speed: **{best_global_info['v_turn']:.2f} kt** (range {TURN_SPEED_MIN_KT:.0f}–{TURN_SPEED_MAX_KT:.0f})",
+        f"- Beam width: **{VAR_BEAM_WIDTH}** | Heading deltas: **{VAR_HEADING_DELTA_SET}°** | Smooth penalty: **{VAR_SMOOTH_PENALTY_US_PER_DEG:.2f} µs/deg**",
         "",
-        "**Per-segment heading + speed (end-of-segment BTO err where measured):**",
-        f"- 18:40→19:40: **{hs[0]:.1f}°**, **{vs[0]:.2f} kt** (err {fmt_err(es[0])})",
-        f"- 19:40→20:40: **{hs[1]:.1f}°**, **{vs[1]:.2f} kt** (err {fmt_err(es[1])})",
-        f"- 20:40→21:40: **{hs[2]:.1f}°**, **{vs[2]:.2f} kt** (err {fmt_err(es[2])})",
-        f"- 21:40→22:40: **{hs[3]:.1f}°**, **{vs[3]:.2f} kt** (err {fmt_err(es[3])})",
-        f"- 22:40→00:10: **{hs[4]:.1f}°**, **{vs[4]:.2f} kt** (err {fmt_err(es[4])})",
-        f"- 00:10→00:20: **{hs[5]:.1f}°**, **{vs[5]:.2f} kt** (err {fmt_err(es[5])})",
+        "**Per-segment heading & speed:**",
+        f"- 18:40→19:40: **{hs[0]:.2f}°**, **{vs[0]:.2f} kt** (end err {es[0]:+.2f} µs)",
+        f"- 19:40→20:40: **{hs[1]:.2f}°**, **{vs[1]:.2f} kt** (end err {es[1]:+.2f} µs)",
+        f"- 20:40→21:40: **{hs[2]:.2f}°**, **{vs[2]:.2f} kt** (end err {es[2]:+.2f} µs)",
+        f"- 21:40→22:40: **{hs[3]:.2f}°**, **{vs[3]:.2f} kt** (end err {es[3]:+.2f} µs)",
+        f"- 22:40→00:10: **{hs[4]:.2f}°**, **{vs[4]:.2f} kt** (end err {es[4]:+.2f} µs)",
+        f"- 00:10→00:20: **{hs[5]:.2f}°**, **{vs[5]:.2f} kt** (end err {es[5]:+.2f} µs)",
         "",
-        f"- Enforced BTO timestamps (measured available): **{', '.join(det['enforced_labels'])}**",
-        f"- Max |BTO error| at enforced times: **{det['max_abs_err_us']:.2f} µs**",
-        f"- RMSE_BTO at enforced times: **{det['rmse_bto_us']:.2f} µs**",
+        f"- Enforced BTO timestamps: **{', '.join(best_global_info['enforced_labels'])}**",
+        f"- Max |BTO error| at enforced times: **{best_global_info['max_abs_err_us']:.2f} µs**",
+        f"- RMSE_BTO at enforced times: **{best_global_info['rmse_bto_us']:.2f} µs**",
         "",
         "*If 18:40 has no measured BTO in your satLoc, it is automatically not enforced.*",
     ]
-
-    return refined_best["legs"], "\n".join(report_lines), start_dt
+    return best_global_legs, "\n".join(report_lines), start_dt
 
 
 # ================= RUNNERS =================
@@ -1899,23 +1794,11 @@ def run_sim_manual(start_lat, start_lon, legs_df, method, start_time_str, alt_ft
     return gr.update(), "", html_map, stats_md, bfo_fig, bfo_md, alt_fig, gr.update(headers=headers, value=rows)
 
 
-def run_guided(
-    guided_mode,
-    start_lat, start_lon, method, alt_ft, vs_fpm, descent_start_choice,
-    weight_bfo, weight_bto
-):
-    if (guided_mode or "").startswith("Variable"):
-        legs, report_md, start_dt = solve_guided_variable_heading_speed(
-            method,
-            alt_ft, vs_fpm,
-            descent_start_choice, weight_bfo, weight_bto
-        )
+def run_guided(guided_mode, start_lat, start_lon, method, alt_ft, vs_fpm, descent_start_choice):
+    if guided_mode == "Straight heading":
+        legs, report_md, start_dt = solve_guided_straight(method, alt_ft, vs_fpm, descent_start_choice)
     else:
-        legs, report_md, start_dt = solve_guided_straight_heading(
-            method,
-            alt_ft, vs_fpm,
-            descent_start_choice, weight_bfo, weight_bto
-        )
+        legs, report_md, start_dt = solve_guided_variable(method, alt_ft, vs_fpm, descent_start_choice)
 
     if legs is None:
         fig = go.Figure()
@@ -1961,9 +1844,15 @@ with gr.Blocks() as demo:
         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 speed bounds:** {TURN_SPEED_MIN_KT:.0f}–{TURN_SPEED_MAX_KT:.0f} kt\n"
-        f"**Southern speed bounds:** {SOUTH_SPEED_MIN_KT:.0f}–{SOUTH_SPEED_MAX_KT:.0f} kt (per segment)\n"
-        f"**Ring-fit goal:** match BTO at ping times where measured BTO exists (auto-detected from satLoc).\n"
-        f"**Straight heading perf:** polish runs only for **top-{TOPK_POLISH}** candidates."
+        f"**Southern speed bounds:** {SOUTH_SPEED_MIN_KT:.0f}–{SOUTH_SPEED_MAX_KT:.0f} kt\n"
+        f"**Straight mode:** Top-K polish (top-{TOPK_POLISH})\n"
+        f"**Variable mode:** beam search (width {VAR_BEAM_WIDTH}) for speed"
+    )
+
+    guided_mode = gr.Dropdown(
+        ["Straight heading", "Variable heading & speed"],
+        value="Straight heading",
+        label="Guided scenario",
     )
 
     with gr.Row():
@@ -1982,23 +1871,6 @@ with gr.Blocks() as demo:
             label="When does descent start? (VS applies after this time)",
         )
 
-    gr.Markdown("### Guided mode (Recommended)")
-    guided_mode = gr.Dropdown(
-        ["Straight heading", "Variable Heading and Speed"],
-        value="Straight heading",
-        label="Guided scenario",
-    )
-    gr.Markdown(
-        "- **Straight heading**: one southern heading after 18:40; speeds vary per segment; optional Top-K polish.\n"
-        "- **Variable Heading and Speed**: headings + speeds vary per segment; uses fast beam search to keep runtime reasonable.\n"
-        "- If 18:40 has no measured BTO in your satLoc, it is **automatically skipped** for enforcement."
-    )
-
-    gr.Markdown("### Guided scoring weights (for reporting only)")
-    with gr.Row():
-        weight_bfo = gr.Slider(0.0, 5.0, value=DEFAULT_WEIGHT_BFO, step=0.1, label="Weight: BFO")
-        weight_bto = gr.Slider(0.0, 10.0, value=DEFAULT_WEIGHT_BTO, step=0.1, label="Weight: BTO")
-
     with gr.Row():
         guided_btn = gr.Button("Generate: Guided scenario")
         manual_btn = gr.Button("Simulate: Manual legs")
@@ -2045,11 +1917,7 @@ with gr.Blocks() as demo:
 
     guided_btn.click(
         run_guided,
-        inputs=[
-            guided_mode,
-            start_lat, start_lon, method, alt_ft, vs_fpm, descent_start_choice,
-            weight_bfo, weight_bto
-        ],
+        inputs=[guided_mode, start_lat, start_lon, method, alt_ft, vs_fpm, descent_start_choice],
         outputs=[legs_df, status_md, out_map, stats, bfo_plot, bfo_score, alt_plot, validation_df],
     )