Update app.py

app.py

@@ -1,32 +1,19 @@
 # app.py
 # MH370 Flight Simulator — Leaflet map (Folium) + Ping Rings (KML)
-# Features:
-# (6) Multi-leg editor
-# (7) Add / Reset legs
-# (8) Stats panel
-# (13) Permanent labeled waypoints
-# (14) BFO analysis chart + MAE/RMSE
-# Guided mode scenarios:
-#   A) Straight (single heading+speed) with FIXED schedule
-#   A2) Straight (nominal heading) + small per-leg drift (±deg) with penalty
-# (REMOVED) Turn after Ping Ring 6
-# (REMOVED) Radar fix → turn completion @18:28Z → southern solve
 #
-# NEW: Altitude vs Time chart (visualize descent profile)
-# NEW: Validation table at schedule timestamps (lat/lon/hdg/spd + BFO/BTO measured vs calculated + errors)
-# NEW: Explicit weighting between BFO and BTO in guided solver (to emphasize BTO)
-# NEW: Heading-drift penalty (keeps drift small + defensible)
+# Guided scenarios (ACTIVE):
+#   A) Straight (single heading)  ✅
+#   A2) Straight + drift (per-leg ±deg, penalized) ✅
 #
-# === YOUR REQUESTED CHANGES (IMPLEMENTED) ===
-# 1) Overlay "Search areas.kmz" on the map (PERMANENT, always shown)
-# 2) Make ALL ping rings permanent (always shown)
-# 3) Remove ring toggles (no CheckboxGroup)
-# 4) Remove LayerControl entirely
-# 5) Color-code search items by name (Ocean Infinity / Australia / Malaysia / China / etc.)
-# 6) Remove guided scenarios:
-#    - "Turn after Ping Ring 6 (two headings)"
-#    - "Radar fix → turn completion @18:28Z → southern solve"
-#    + Remove the radar-fix UI controls
+# Changes implemented (your request):
+# 1) Last radar spot is FIXED:
+#       18:22:00Z @ 6.578N, 96.341E (cannot be changed)
+# 2) Turn completion is FIXED:
+#       18:40:00Z (final major turn completed by this time)
+# 3) Guided mode now automatically computes a realistic pre-turn path (18:22→18:40)
+#    and plots it on the map before the southern leg.
+# 4) Speed during the pre-turn is constrained to the user-selected speed.
+# 5) Validation table continues to output waypoints at schedule timestamps.
 
 import os
 import re
@@ -80,80 +67,80 @@ BTO_SCALE_US = 50.0
 
 # EXPLICIT WEIGHTS
 DEFAULT_WEIGHT_BFO = 1.0
-DEFAULT_WEIGHT_BTO = 2.0   # emphasize BTO by default (increase to care more about BTO)
+DEFAULT_WEIGHT_BTO = 2.0   # emphasize BTO by default
 
 # satLoc indices (confirmed by you)
 SATLOC_IDX_MEAS_BFO = 4
 SATLOC_IDX_MEAS_BTO = 5
 
-# Guided heading search (south-ish)
-GUIDED_HEADING_MIN = 150.0
-GUIDED_HEADING_MAX = 210.0
+# ===== Fixed Radar + Turn Completion =====
+RADAR_FIX_LAT = 6.578
+RADAR_FIX_LON = 96.341
+RADAR_FIX_TIME_UTC = datetime(2014, 3, 7, 18, 22, 0, tzinfo=timezone.utc)
+
+TURN_COMPLETE_TIME_UTC = datetime(2014, 3, 7, 18, 40, 0, tzinfo=timezone.utc)
+TURN_WINDOW_MIN = (TURN_COMPLETE_TIME_UTC - RADAR_FIX_TIME_UTC).total_seconds() / 60.0
 
-# Guided time window (southern leg window)
-GUIDED_START_LABEL = "18:28:00"       # 18:28:00Z
-GUIDED_END_LABEL = "24:20:00"         # 00:20:00Z represented as 24:20:00
+# Initial heading from radar panel (TRK 296°T)
+RADAR_INITIAL_TRACK_DEG = 296.0
 
-# Guided schedule (exact for the southern leg starting 18:28Z)
-GUIDED_LEG_SCHEDULE_MIN = [12.0, 60.0, 60.0, 60.0, 60.0, 90.0, 10.0]  # total 352 min
+# Turn modeling parameters (realistic constant-bank turn)
+TURN_BANK_MIN_DEG = 15.0
+TURN_BANK_MAX_DEG = 30.0
+TURN_BANK_DEFAULT_DEG = 25.0
+TURN_STEP_SEC = 30.0  # discretize turn into small straight segments for map + scoring
 
-# Guided scenario-specific search resolution
+# ===== Guided heading search (southern-ish) =====
+GUIDED_HEADING_MIN = 150.0
+GUIDED_HEADING_MAX = 210.0
 STRAIGHT_STEP_DEG = 0.5
 
+# ===== Guided schedule for southern leg =====
+# This schedule applies AFTER 18:40, but total sim starts at 18:22 including the turn window.
+GUIDED_LEG_SCHEDULE_MIN = [12.0, 60.0, 60.0, 60.0, 60.0, 90.0, 10.0]  # 352 min
+
+
 # ================= HEADING DRIFT =================
-DEFAULT_DRIFT_MAX_DEG = 2.0          # typical: 1–2 degrees
-DRIFT_STEP_DEG = 0.5                # discrete search step for deltas
-DEFAULT_WEIGHT_DRIFT = 0.30         # penalty strength in "combined score" units
-DEFAULT_DRIFT_ITERS = 2             # coordinate descent passes
-DRIFT_SCALE_DEG = 1.0               # normalization for drift penalty (rms_deg / scale)
+DEFAULT_DRIFT_MAX_DEG = 2.0
+DRIFT_STEP_DEG = 0.5
+DEFAULT_WEIGHT_DRIFT = 0.30
+DEFAULT_DRIFT_ITERS = 2
+DRIFT_SCALE_DEG = 1.0
+
 
 # ================= SEARCH AREA COLORS =================
 SEARCH_AREA_COLORS = {
     "Ocean Infinity": "#ff3b3b",       # red
     "Australia": "#1f77b4",            # blue
-    "Malays": "#2ca02c",               # green (covers Malaysia/Malaysian)
+    "Malays": "#2ca02c",               # green (Malaysia/Malaysian)
     "China": "#ff7f0e",                # orange
     "Seabed Constructor": "#9467bd",   # purple
     "Fugro": "#8c564b",                # brown
 }
-DEFAULT_SEARCH_COLOR = "#00ffff"      # fallback cyan
+DEFAULT_SEARCH_COLOR = "#00ffff"
 
 
 # ================= PATH RESOLUTION =================
 def resolve_local_or_mnt(path_like: str) -> str:
-    """
-    Try:
-      1) as given
-      2) same dir as app.py
-      3) /mnt/data/<filename>   (common upload mount)
-      4) /mnt/data/<path_like>  (if they passed a relative path with dirs)
-    Returns best guess path (may still not exist).
-    """
     p = (path_like or "").strip()
     if not p:
         return p
-
     if os.path.exists(p):
         return p
-
     here = os.path.dirname(os.path.abspath(__file__)) if "__file__" in globals() else os.getcwd()
     p2 = os.path.join(here, p)
     if os.path.exists(p2):
         return p2
-
     base = os.path.basename(p)
     p3 = os.path.join("/mnt/data", base)
     if os.path.exists(p3):
         return p3
-
     p4 = os.path.join("/mnt/data", p)
     if os.path.exists(p4):
         return p4
-
     return p
 
 
-# ================= SEARCH AREA COLOR PICKER =================
 def color_for_search_area(name: str) -> str:
     lname = (name or "").lower()
     for key, color in SEARCH_AREA_COLORS.items():
@@ -165,7 +152,6 @@ def color_for_search_area(name: str) -> str:
 # ================= KML =================
 def load_ping_rings_from_kml(path: str):
     path = resolve_local_or_mnt(path)
-
     if not os.path.exists(path):
         raise FileNotFoundError(
             f"KML file not found: '{path}'. Put it in the Space root (same folder as app.py)."
@@ -241,15 +227,7 @@ def _parse_kml_coordinates_text(txt: str):
 
 
 def load_search_areas_from_kmz(kmz_path: str):
-    """
-    Load features from a KMZ (KML inside zip). Supports:
-    - Placemark -> Point
-    - Placemark -> LineString
-    - Placemark -> Polygon
-    - MultiGeometry versions of the above
-    """
     kmz_path = resolve_local_or_mnt(kmz_path)
-
     if not os.path.exists(kmz_path):
         raise FileNotFoundError(
             f"KMZ file not found: '{kmz_path}'. Put it next to app.py (Space root) or ensure it's mounted in /mnt/data."
@@ -263,7 +241,6 @@ def load_search_areas_from_kmz(kmz_path: str):
                 break
         if not kml_name:
             raise ValueError("KMZ contains no .kml file.")
-
         root = ET.fromstring(zf.read(kml_name))
 
     ns = _kml_ns_from_root(root)
@@ -273,9 +250,7 @@ def load_search_areas_from_kmz(kmz_path: str):
         name_el = pm.find("kml:name", ns)
         pm_name = (name_el.text.strip() if (name_el is not None and name_el.text) else "Search area")
 
-        points = []
-        lines = []
-        polys = []
+        points, lines, polys = [], [], []
 
         for pt in pm.findall(".//kml:Point", ns):
             coords = pt.find(".//kml:coordinates", ns)
@@ -370,6 +345,116 @@ def reset_legs():
     return gr.update(value=[row[:] for row in DEFAULT_LEGS])
 
 
+# ================= GEO HELPERS =================
+def _wrap_heading_deg(h: float) -> float:
+    return float(h) % 360.0
+
+
+def _shortest_signed_delta_deg(h_from: float, h_to: float) -> float:
+    # result in [-180, +180]
+    return ((float(h_to) - float(h_from) + 540.0) % 360.0) - 180.0
+
+
+def _turn_rate_deg_per_sec(speed_knots: float, bank_deg: float) -> float:
+    # omega = g*tan(bank)/V
+    g = 9.80665
+    V = max(10.0, float(speed_knots) * 0.514444)  # m/s
+    bank = math.radians(max(1e-3, float(bank_deg)))
+    omega = g * math.tan(bank) / V  # rad/s
+    return float(omega * 180.0 / math.pi)
+
+
+def build_turn_legs(
+    speed_knots: float,
+    method: str,
+    heading_final_deg: float,
+    bank_pref_deg: float = TURN_BANK_DEFAULT_DEG,
+    step_sec: float = TURN_STEP_SEC
+):
+    """
+    Build legs from radar fix (18:22) to turn completion (18:40).
+
+    Model:
+      - straight segment on RADAR_INITIAL_TRACK_DEG
+      - then constant-bank turn to heading_final_deg
+      - ends exactly at 18:40
+
+    Returns:
+      legs_turn, info_dict
+    """
+    total_sec = (TURN_COMPLETE_TIME_UTC - RADAR_FIX_TIME_UTC).total_seconds()
+    if total_sec <= 0:
+        return [], {"error": "Invalid turn window."}
+
+    h0 = float(RADAR_INITIAL_TRACK_DEG)
+    h1 = _wrap_heading_deg(float(heading_final_deg))
+    delta = _shortest_signed_delta_deg(h0, h1)
+    sign = 1.0 if delta >= 0 else -1.0
+    delta_abs = abs(delta)
+
+    # choose bank angle so turn duration fits window
+    bank_candidates = [float(bank_pref_deg)] + list(np.linspace(TURN_BANK_MIN_DEG, TURN_BANK_MAX_DEG, 9))
+    best_bank = None
+    best_turn_sec = None
+
+    for b in bank_candidates:
+        rate = _turn_rate_deg_per_sec(speed_knots, b)
+        if rate <= 1e-6:
+            continue
+        t_turn = delta_abs / rate
+        if t_turn <= total_sec + 1e-6:
+            # prefer bank close to preferred
+            if best_bank is None:
+                best_bank, best_turn_sec = b, t_turn
+            else:
+                if abs(b - bank_pref_deg) < abs(best_bank - bank_pref_deg):
+                    best_bank, best_turn_sec = b, t_turn
+
+    # fallback: max bank
+    if best_bank is None:
+        best_bank = TURN_BANK_MAX_DEG
+        best_turn_sec = delta_abs / max(1e-6, _turn_rate_deg_per_sec(speed_knots, best_bank))
+        best_turn_sec = min(best_turn_sec, total_sec)
+
+    turn_sec = float(best_turn_sec)
+    straight_sec = max(0.0, float(total_sec) - turn_sec)
+
+    legs = []
+
+    # straight leg (if any)
+    if straight_sec > 1.0:
+        legs.append((h0, float(speed_knots), straight_sec / 60.0))
+
+    # turn legs discretized
+    if turn_sec > 1.0 and delta_abs > 1e-6:
+        step_sec = max(5.0, float(step_sec))
+        n = int(math.ceil(turn_sec / step_sec))
+        if n < 1:
+            n = 1
+        # actual step sizes: equal steps except last adjusted
+        remaining = turn_sec
+        for i in range(n):
+            this = min(step_sec, remaining)
+            remaining -= this
+
+            # heading at midpoint of segment:
+            frac_mid = ( (i + 0.5) / n )
+            hdg_mid = _wrap_heading_deg(h0 + sign * delta_abs * frac_mid)
+
+            legs.append((hdg_mid, float(speed_knots), this / 60.0))
+
+    info = {
+        "h0": h0,
+        "h1": h1,
+        "delta_deg": delta,
+        "bank_deg": float(best_bank),
+        "straight_min": straight_sec / 60.0,
+        "turn_min": turn_sec / 60.0,
+        "total_min": total_sec / 60.0,
+    }
+    return legs, info
+
+
 # ================= SIM CORE + STATS =================
 def simulate_path(start_lat, start_lon, legs, method):
     lat, lon = float(start_lat), float(start_lon)
@@ -378,11 +463,11 @@ def simulate_path(start_lat, start_lon, legs, method):
     total_time_min = 0.0
 
     for heading, speed_knots, minutes in legs:
-        dist_m = speed_knots * 1852.0 * (minutes / 60.0)
+        dist_m = float(speed_knots) * 1852.0 * (float(minutes) / 60.0)
         if method == "VINCENTY":
-            (lat, lon), _ = fp.vincenty_direct((lat, lon), heading, dist_m)
+            (lat, lon), _ = fp.vincenty_direct((lat, lon), float(heading), dist_m)
         else:
-            lat, lon = fp.rhumb_direct((lat, lon), heading, dist_m)
+            lat, lon = fp.rhumb_direct((lat, lon), float(heading), dist_m)
 
         pts.append((lat, lon))
         seg_dists_m.append(dist_m)
@@ -457,6 +542,7 @@ def build_leaflet_map(path_pts, legs, seg_dists_m):
         control_scale=True,
     )
 
+    # Basemaps (no LayerControl requested)
     folium.TileLayer("OpenStreetMap", name="OpenStreetMap", overlay=False, control=True).add_to(m)
     folium.TileLayer(
         tiles="https://server.arcgisonline.com/ArcGIS/rest/services/Ocean/World_Ocean_Base/MapServer/tile/{z}/{y}/{x}",
@@ -660,14 +746,6 @@ def _parse_start_time(s: str) -> datetime:
     return dt.astimezone(timezone.utc)
 
 
-def dt_guided_start_utc() -> datetime:
-    return fp._time_label_to_dt(GUIDED_START_LABEL, fp.SAT_EPOCH_UTC)
-
-
-def dt_guided_end_utc() -> datetime:
-    return fp._time_label_to_dt(GUIDED_END_LABEL, fp.SAT_EPOCH_UTC)
-
-
 def dt_ping6_utc() -> datetime:
     return fp._time_label_to_dt("22:40:00", fp.SAT_EPOCH_UTC)
 
@@ -713,7 +791,7 @@ def build_altitude_plot(start_dt: datetime, total_time_min: float, alt0_ft: floa
     return fig
 
 
-# ================= GEO HELPERS =================
+# ================= PREDICT STATE =================
 def _predict_state_from_leg_start(method, leg_start_lat, leg_start_lon, hdg_deg, spd_knots, t_inside_leg_sec):
     dist_m = float(spd_knots) * 1852.0 * (float(t_inside_leg_sec) / 3600.0)
     if method == "VINCENTY":
@@ -754,6 +832,7 @@ def bfo_analysis_with_legs(start_lat, start_lon, legs, method, start_time_str, a
         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 = t_sec - boundaries[i]
@@ -851,7 +930,6 @@ def make_legs_from_schedule(headings, speed_knots, schedule_minutes):
     legs = []
     if isinstance(headings, (int, float)):
         headings = [float(headings)] * len(schedule_minutes)
-
     for hdg, m in zip(headings, schedule_minutes):
         m = float(m)
         if m <= 0:
@@ -899,11 +977,11 @@ def score_legs_bfo_bto(
 
         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
@@ -970,15 +1048,8 @@ def score_legs_bfo_bto_with_drift(
     return s
 
 
-def _wrap_heading_deg(h: float) -> float:
-    return float(h) % 360.0
-
-
 def _apply_base_plus_deltas(base_headings, deltas_deg):
-    headings = []
-    for b, d in zip(base_headings, deltas_deg):
-        headings.append(_wrap_heading_deg(float(b) + float(d)))
-    return headings
+    return [_wrap_heading_deg(float(b) + float(d)) for b, d in zip(base_headings, deltas_deg)]
 
 
 def _coordinate_descent_deltas(
@@ -998,49 +1069,58 @@ def _coordinate_descent_deltas(
 
     best_s = None
     best_d = deltas[:]
+    best_legs = None
 
     for _it in range(max(1, int(iters))):
         improved = False
         for j in range(n):
             best_local_s = None
             best_local_dj = deltas[j]
+            best_local_legs = None
+
             for dv in cand:
                 trial = deltas[:]
                 trial[j] = float(dv)
                 trial_headings = _apply_base_plus_deltas(base_headings, trial)
-                legs = make_legs_from_schedule(trial_headings, float(speed_knots), schedule_minutes)
+
+                # southern legs
+                southern_legs = make_legs_from_schedule(trial_headings, float(speed_knots), schedule_minutes)
+
+                # pre-turn legs built to align with the FIRST southern heading at 18:40
+                preturn_legs, _info = build_turn_legs(
+                    speed_knots=float(speed_knots),
+                    method=method,
+                    heading_final_deg=float(trial_headings[0]),
+                )
+
+                full_legs = preturn_legs + southern_legs
 
                 s = score_legs_bfo_bto_with_drift(
-                    start_lat, start_lon, method, start_dt, end_dt, legs,
+                    start_lat, start_lon, method, start_dt, end_dt, full_legs,
                     alt_ft, vs_fpm, descent_start_dt,
                     weight_bfo, weight_bto,
                     drift_weight, trial
                 )
                 if s is None:
                     continue
+
                 if best_local_s is None or s["combined"] < best_local_s["combined"]:
                     best_local_s = s
                     best_local_dj = float(dv)
+                    best_local_legs = full_legs
 
             deltas[j] = best_local_dj
 
             if best_local_s is not None and (best_s is None or best_local_s["combined"] < best_s["combined"]):
                 best_s = best_local_s
                 best_d = deltas[:]
+                best_legs = best_local_legs
                 improved = True
 
         if not improved:
             break
 
-    final_headings = _apply_base_plus_deltas(base_headings, best_d)
-    final_legs = make_legs_from_schedule(final_headings, float(speed_knots), schedule_minutes)
-    final_s = score_legs_bfo_bto_with_drift(
-        start_lat, start_lon, method, start_dt, end_dt, final_legs,
-        alt_ft, vs_fpm, descent_start_dt,
-        weight_bfo, weight_bto,
-        drift_weight, best_d
-    )
-    return final_legs, final_s, best_d
+    return best_legs, best_s, best_d
 
 
 # ================= VALIDATION TABLE =================
@@ -1083,15 +1163,18 @@ def build_validation_table(
     elif (descent_start_choice or "").startswith("After Ping Ring 7"):
         descent_start_dt = dt_ping7_utc()
 
+    # Schedule timestamps: start + cumulative leg minutes
     times = [start_dt]
     cum = 0.0
     for (_h, _s, m) in legs:
         cum += float(m)
         times.append(start_dt + timedelta(minutes=cum))
 
+    # boundaries for segment lookup
     leg_secs = [float(m) * 60.0 for _, _, m in legs]
     boundaries = np.cumsum([0.0] + leg_secs)
 
+    # precompute leg start positions
     cur_lat = float(start_lat)
     cur_lon = float(start_lon)
     leg_start_positions = [(cur_lat, cur_lon)]
@@ -1128,6 +1211,7 @@ def build_validation_table(
 
         bfo_meas, bto_meas = _lookup_measured_at_dt(dt_k)
 
+        # errors (calc - meas)
         bfo_err = None if bfo_meas is None else (float(bfo_calc) - float(bfo_meas))
         bto_err = None if bto_meas is None else (float(bto_calc) - float(bto_meas))
 
@@ -1154,12 +1238,21 @@ def build_validation_table(
 
 
 # ================= GUIDED SOLVERS =================
+def _guided_start_dt():
+    return RADAR_FIX_TIME_UTC
+
+
+def _guided_end_dt():
+    total_min = TURN_WINDOW_MIN + float(np.sum(GUIDED_LEG_SCHEDULE_MIN))
+    return RADAR_FIX_TIME_UTC + timedelta(minutes=total_min)
+
+
 def solve_guided_straight(
-    start_lat, start_lon, method, speed_knots, alt_ft, vs_fpm,
+    method, speed_knots, alt_ft, vs_fpm,
     descent_start_choice, weight_bfo, weight_bto
 ):
-    start_dt = dt_guided_start_utc()
-    end_dt = dt_guided_end_utc()
+    start_dt = _guided_start_dt()
+    end_dt = _guided_end_dt()
 
     descent_start_dt = None
     if (descent_start_choice or "").startswith("After Ping Ring 6"):
@@ -1167,59 +1260,76 @@ def solve_guided_straight(
     elif (descent_start_choice or "").startswith("After Ping Ring 7"):
         descent_start_dt = dt_ping7_utc()
 
-    total_sched_min = float(np.sum(GUIDED_LEG_SCHEDULE_MIN))
-    total_window_min = (end_dt - start_dt).total_seconds() / 60.0
-    if abs(total_sched_min - total_window_min) > 0.01:
-        return None, (
-            f"Guided schedule mismatch: schedule totals {total_sched_min:.1f} min but window is {total_window_min:.1f} min."
-        ), None
-
     best = None
     best_h = None
+    best_full_legs = None
+    best_turn_info = None
 
     h = GUIDED_HEADING_MIN
     while h <= GUIDED_HEADING_MAX + 1e-9:
-        legs = make_legs_from_schedule(h, float(speed_knots), GUIDED_LEG_SCHEDULE_MIN)
+        southern_legs = make_legs_from_schedule(h, float(speed_knots), GUIDED_LEG_SCHEDULE_MIN)
+
+        preturn_legs, turn_info = build_turn_legs(
+            speed_knots=float(speed_knots),
+            method=method,
+            heading_final_deg=float(h),
+        )
+        full_legs = preturn_legs + southern_legs
+
         s = score_legs_bfo_bto(
-            start_lat, start_lon, method, start_dt, end_dt, legs,
+            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 not None and (best is None or s["combined"] < best["combined"]):
             best = s
             best_h = float(h)
-        h += STRAIGHT_STEP_DEG
+            best_full_legs = full_legs
+            best_turn_info = turn_info
 
-    if best is None:
-        return None, f"Guided solve: not enough ping points between {GUIDED_START_LABEL} and {GUIDED_END_LABEL} to score.", None
+        h += STRAIGHT_STEP_DEG
 
-    legs = make_legs_from_schedule(best_h, float(speed_knots), GUIDED_LEG_SCHEDULE_MIN)
+    if best is None or best_full_legs is None:
+        return None, f"Guided solve: not enough ping points to score in window {start_dt.strftime('%H:%MZ')} → {end_dt.strftime('%H:%MZ')}.", None
 
     rbto = best["rmse_bto"]
     rbto_txt = f"{rbto:.1f} µs" if rbto is not None else "n/a"
     sched_txt = ", ".join([f"{m:.0f}" for m in GUIDED_LEG_SCHEDULE_MIN]) + " min"
 
+    tinfo = best_turn_info or {}
     report = "\n".join([
-        "**Guided mode: Straight (single heading)**",
-        f"- Window: **{GUIDED_START_LABEL}Z → 00:20:00Z**",
-        f"- Start: lat **{float(start_lat):.2f}**, lon **{float(start_lon):.2f}**",
+        "**Guided mode: Straight (single heading) + computed turn (18:22→18:40)**",
+        f"- Radar fix (fixed): **18:22:00Z** @ lat **{RADAR_FIX_LAT:.3f}**, lon **{RADAR_FIX_LON:.3f}**",
+        f"- Turn completion (fixed): **18:40:00Z**",
+        f"- Initial track (fixed): **{RADAR_INITIAL_TRACK_DEG:.1f}°**",
+        f"- Speed (constrained): **{float(speed_knots):.1f} kt**",
+        f"- Best southern heading: **{best_h:.1f}°** (searched {GUIDED_HEADING_MIN:.0f}–{GUIDED_HEADING_MAX:.0f}°, step {STRAIGHT_STEP_DEG}°)",
+        "",
+        "**Computed turn model**",
+        f"- Bank angle: **{tinfo.get('bank_deg', TURN_BANK_DEFAULT_DEG):.1f}°**",
+        f"- Heading change: **{tinfo.get('delta_deg', 0.0):+.1f}°**",
+        f"- Straight-before-turn: **{tinfo.get('straight_min', 0.0):.2f} min**",
+        f"- Turn duration: **{tinfo.get('turn_min', 0.0):.2f} min**",
+        "",
+        "**Southern schedule**",
         f"- Legs: **{sched_txt}**",
-        f"- Speed: **{float(speed_knots):.1f} kt**",
-        f"- Best heading: **{best_h:.1f}°** (searched {GUIDED_HEADING_MIN:.0f}–{GUIDED_HEADING_MAX:.0f}°, step {STRAIGHT_STEP_DEG}°)",
+        "",
+        "**Fit**",
         f"- Weights: BFO **{float(weight_bfo):.2f}**, BTO **{float(weight_bto):.2f}**",
         f"- BFO points: **{best['n_bfo']}** | RMSE_BFO: **{best['rmse_bfo']:.2f} Hz**",
         f"- BTO points: **{best['n_bto']}** | RMSE_BTO: **{rbto_txt}**",
     ])
-    return legs, report, start_dt
+
+    return best_full_legs, report, start_dt
 
 
 def solve_guided_straight_with_drift(
-    start_lat, start_lon, method, speed_knots, alt_ft, vs_fpm,
+    method, speed_knots, alt_ft, vs_fpm,
     descent_start_choice, weight_bfo, weight_bto,
     drift_max_deg, drift_weight
 ):
-    start_dt = dt_guided_start_utc()
-    end_dt = dt_guided_end_utc()
+    start_dt = _guided_start_dt()
+    end_dt = _guided_end_dt()
 
     descent_start_dt = None
     if (descent_start_choice or "").startswith("After Ping Ring 6"):
@@ -1227,17 +1337,11 @@ def solve_guided_straight_with_drift(
     elif (descent_start_choice or "").startswith("After Ping Ring 7"):
         descent_start_dt = dt_ping7_utc()
 
-    total_sched_min = float(np.sum(GUIDED_LEG_SCHEDULE_MIN))
-    total_window_min = (end_dt - start_dt).total_seconds() / 60.0
-    if abs(total_sched_min - total_window_min) > 0.01:
-        return None, (
-            f"Guided schedule mismatch: schedule totals {total_sched_min:.1f} min but window is {total_window_min:.1f} min."
-        ), None
-
     best_s = None
     best_legs = None
     best_h0 = None
     best_deltas = None
+    best_turn_info = None
 
     n = len(GUIDED_LEG_SCHEDULE_MIN)
 
@@ -1245,9 +1349,9 @@ def solve_guided_straight_with_drift(
     while h0 <= GUIDED_HEADING_MAX + 1e-9:
         base_headings = [float(h0)] * n
 
-        legs, s, deltas = _coordinate_descent_deltas(
-            start_lat, start_lon, method, start_dt, end_dt,
-            speed_knots, GUIDED_LEG_SCHEDULE_MIN,
+        full_legs, s, deltas = _coordinate_descent_deltas(
+            RADAR_FIX_LAT, RADAR_FIX_LON, method, start_dt, end_dt,
+            float(speed_knots), GUIDED_LEG_SCHEDULE_MIN,
             alt_ft, vs_fpm, descent_start_dt,
             weight_bfo, weight_bto,
             float(drift_weight),
@@ -1257,16 +1361,25 @@ def solve_guided_straight_with_drift(
             DEFAULT_DRIFT_ITERS
         )
 
-        if s is not None and (best_s is None or s["combined"] < best_s["combined"]):
+        if s is not None and full_legs is not None and (best_s is None or s["combined"] < best_s["combined"]):
             best_s = s
-            best_legs = legs
+            best_legs = full_legs
             best_h0 = float(h0)
             best_deltas = deltas
 
-        h0 += 1.0  # coarse sweep when drift is enabled
+            # compute turn info based on first southern heading (base + delta[0])
+            trial_headings = _apply_base_plus_deltas(base_headings, deltas)
+            _, turn_info = build_turn_legs(
+                speed_knots=float(speed_knots),
+                method=method,
+                heading_final_deg=float(trial_headings[0]),
+            )
+            best_turn_info = turn_info
+
+        h0 += 1.0
 
     if best_s is None or best_legs is None:
-        return None, f"Guided drift solve: not enough ping points between {GUIDED_START_LABEL} and {GUIDED_END_LABEL} to score.", None
+        return None, f"Guided drift solve: not enough ping points to score in window {start_dt.strftime('%H:%MZ')} → {end_dt.strftime('%H:%MZ')}.", None
 
     rbto = best_s["rmse_bto"]
     rbto_txt = f"{rbto:.1f} µs" if rbto is not None else "n/a"
@@ -1277,16 +1390,29 @@ def solve_guided_straight_with_drift(
     if best_deltas is not None:
         drift_str = ", ".join([f"{d:+.1f}°" for d in best_deltas])
 
+    tinfo = best_turn_info or {}
+
     report = "\n".join([
-        "**Guided mode: Straight + small per-leg heading drift (penalized)**",
-        f"- Window: **{GUIDED_START_LABEL}Z → 00:20:00Z**",
-        f"- Start: lat **{float(start_lat):.2f}**, lon **{float(start_lon):.2f}**",
+        "**Guided mode: Straight + drift (penalized) + computed turn (18:22→18:40)**",
+        f"- Radar fix (fixed): **18:22:00Z** @ lat **{RADAR_FIX_LAT:.3f}**, lon **{RADAR_FIX_LON:.3f}**",
+        f"- Turn completion (fixed): **18:40:00Z**",
+        f"- Initial track (fixed): **{RADAR_INITIAL_TRACK_DEG:.1f}°**",
+        f"- Speed (constrained): **{float(speed_knots):.1f} kt**",
+        "",
+        "**Computed turn model (uses first drifted heading at 18:40)**",
+        f"- Bank angle: **{tinfo.get('bank_deg', TURN_BANK_DEFAULT_DEG):.1f}°**",
+        f"- Heading change: **{tinfo.get('delta_deg', 0.0):+.1f}°**",
+        f"- Straight-before-turn: **{tinfo.get('straight_min', 0.0):.2f} min**",
+        f"- Turn duration: **{tinfo.get('turn_min', 0.0):.2f} min**",
+        "",
+        "**Southern schedule**",
         f"- Legs: **{sched_txt}**",
-        f"- Speed: **{float(speed_knots):.1f} kt**",
         f"- Nominal heading H₀: **{best_h0:.1f}°** (searched {GUIDED_HEADING_MIN:.0f}–{GUIDED_HEADING_MAX:.0f}°, step 1.0°)",
         f"- Drift bounds: **±{float(drift_max_deg):.1f}°** | Drift penalty weight: **{float(drift_weight):.2f}**",
         f"- Drift RMS: **{rms_drift:.2f}°**",
         f"- Drift per leg (Δ): {drift_str}" if drift_str else "",
+        "",
+        "**Fit**",
         f"- Weights: BFO **{float(weight_bfo):.2f}**, BTO **{float(weight_bto):.2f}**",
         f"- BFO points: **{best_s['n_bfo']}** | RMSE_BFO: **{best_s['rmse_bfo']:.2f} Hz**",
         f"- BTO points: **{best_s['n_bto']}** | RMSE_BTO: **{rbto_txt}**",
@@ -1335,23 +1461,20 @@ def run_guided(
     weight_bfo, weight_bto,
     drift_max_deg, drift_weight
 ):
+    # Speed constrained to user-selected speed
     spd_knots = speed_from_profile(speed_profile, alt_ft, custom_mach, custom_knots)
 
     if (guided_scenario or "").startswith("Straight + drift"):
         legs, report_md, start_dt = solve_guided_straight_with_drift(
-            start_lat, start_lon, method, spd_knots, alt_ft, vs_fpm,
+            method, spd_knots, alt_ft, vs_fpm,
             descent_start_choice, weight_bfo, weight_bto,
             drift_max_deg, drift_weight
         )
-        sim_start_lat = start_lat
-        sim_start_lon = start_lon
     else:
         legs, report_md, start_dt = solve_guided_straight(
-            start_lat, start_lon, method, spd_knots, alt_ft, vs_fpm,
+            method, spd_knots, alt_ft, vs_fpm,
             descent_start_choice, weight_bfo, weight_bto
         )
-        sim_start_lat = start_lat
-        sim_start_lon = start_lon
 
     if legs is None:
         fig = go.Figure()
@@ -1365,9 +1488,11 @@ def run_guided(
         ], value=[])
         return gr.update(), f"### ❌ {report_md}", "", "", fig, "", alt_fig, empty_table
 
+    # Guided ALWAYS starts at fixed radar spot
     html_map, stats_md, bfo_fig, bfo_md, alt_fig, headers, rows = _run_common(
-        sim_start_lat, sim_start_lon, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice
+        RADAR_FIX_LAT, RADAR_FIX_LON, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice
     )
+
     return gr.update(value=legs_to_rows(legs)), report_md, html_map, stats_md, bfo_fig, bfo_md, alt_fig, gr.update(headers=headers, value=rows)
 
 
@@ -1389,14 +1514,22 @@ with gr.Blocks() as demo:
             "Make sure `Search areas.kmz` is uploaded and `SEARCH_AREAS_KMZ` matches exactly."
         )
 
+    gr.Markdown(
+        "### Fixed Radar + Turn Completion\n"
+        f"- **Last radar spot (fixed):** 18:22:00Z @ **{RADAR_FIX_LAT:.3f}N, {RADAR_FIX_LON:.3f}E**\n"
+        f"- **Turn completion (fixed):** 18:40:00Z\n"
+        f"- **Initial track (fixed):** {RADAR_INITIAL_TRACK_DEG:.1f}°\n"
+        f"- Guided scenarios compute a realistic turn between 18:22→18:40 and then the southern leg."
+    )
+
     with gr.Row():
-        start_lat = gr.Slider(-10, 15, value=6.76, label="Start Latitude (used for scenarios A/B)")
-        start_lon = gr.Slider(70, 115, value=95.69, label="Start Longitude (used for scenarios A/B)")
+        start_lat = gr.Slider(-10, 15, value=6.76, label="Start Latitude (Manual only)")
+        start_lon = gr.Slider(70, 115, value=95.69, label="Start Longitude (Manual only)")
         method = gr.Dropdown(["VINCENTY", "RHUMB"], value="VINCENTY", label="Method")
 
     gr.Markdown("### BFO/BTO Settings")
     with gr.Row():
-        start_time_str = gr.Textbox(value=f"{GUIDED_START_LABEL}Z", label="Simulation start time (UTC) — Manual mode")
+        start_time_str = gr.Textbox(value="18:22:00Z", label="Simulation start time (UTC) — Manual mode")
         alt_ft = gr.Number(value=35000, label="Altitude at start (ft)")
         vs_fpm = gr.Number(value=0, label="Vertical speed (ft/min) (negative = descent)")
         descent_start_choice = gr.Dropdown(
@@ -1418,7 +1551,7 @@ with gr.Blocks() as demo:
         speed_profile = gr.Dropdown(
             ["MRC Mach 0.82", "LRC Mach 0.84", "ECON Mach 0.80", "Custom Mach", "Custom knots"],
             value="MRC Mach 0.82",
-            label="Speed profile",
+            label="Speed profile (constrains speed during turn + southern leg)",
         )
         custom_mach = gr.Number(value=0.82, label="Custom Mach (if selected)")
         custom_knots = gr.Number(value=470, label="Custom knots (if selected)")