Update app.py

app.py

@@ -8,25 +8,25 @@
 # (14) BFO analysis chart + MAE/RMSE
 # Guided mode scenarios:
 #   A) Straight (single heading+speed) with FIXED schedule
-#   A2) NEW: Straight (nominal heading) + small per-leg drift (±deg) with penalty
-#   B) Turn after Ping Ring 6 (two headings: legs 1-5, legs 6-7)
-#   C) Radar fix → user-chosen turn completion point (by 18:28Z) → southern leg solve (kept; you can ignore)
+#   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)
-# Esri Ocean + Satellite basemaps with layer control
-# Ping ring timestamps (Option A) shown in ring tooltip
-# FIX: robust KML loading + no empty default selection crash
 #
 # === YOUR REQUESTED CHANGES (IMPLEMENTED) ===
 # 1) Overlay "Search areas.kmz" on the map (PERMANENT, always shown)
-#    - Supports Points + LineStrings + Polygons (and MultiGeometry variants)
-#    - Tries /mnt/data/ automatically if file not found next to app.py
 # 2) Make ALL ping rings permanent (always shown)
 # 3) Remove ring toggles (no CheckboxGroup)
 # 4) Remove LayerControl entirely
-# 5) NEW: Color-code search items by name (Ocean Infinity / Australia / Malaysia / China / etc.)
+# 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
 
 import os
 import re
@@ -99,26 +99,15 @@ GUIDED_LEG_SCHEDULE_MIN = [12.0, 60.0, 60.0, 60.0, 60.0, 90.0, 10.0]  # total 35
 
 # Guided scenario-specific search resolution
 STRAIGHT_STEP_DEG = 0.5
-TURN_H1_STEP_DEG = 1.0
-TURN_DELTA_STEP_DEG = 1.0
-TURN_DELTA_MAX_DEG = 10.0  # heading2 = heading1 +/- up to 10 degrees
-
-# Optional: speed search around profile (kept for future extension)
-SPEED_SEARCH_PLUS_MINUS_KT = 15.0
-SPEED_SEARCH_STEP_KT = 5.0
 
-# ================= HEADING DRIFT (NEW) =================
-# We allow small per-leg deviations around a nominal heading, but add a penalty
-# so it doesn't "free-run" into overfitting.
+# ================= 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)
 
-# ================= SEARCH AREA COLORS (NEW) =================
-# Match is case-insensitive and substring-based.
-# Example: "Ocean Infinity Search 2018" will match "Ocean Infinity".
+# ================= SEARCH AREA COLORS =================
 SEARCH_AREA_COLORS = {
     "Ocean Infinity": "#ff3b3b",       # red
     "Australia": "#1f77b4",            # blue
@@ -129,16 +118,6 @@ SEARCH_AREA_COLORS = {
 }
 DEFAULT_SEARCH_COLOR = "#00ffff"      # fallback cyan
 
-# ================= RADAR FIX (LAST KNOWN PRIMARY RADAR POINT) =================
-# You provided:
-# Start: 2014-03-07 18:22:12Z @ 6.578°N, 96.341°E, FL350
-RADAR_FIX_LAT = 6.578
-RADAR_FIX_LON = 96.341
-RADAR_FIX_TIME_UTC = datetime(2014, 3, 7, 18, 22, 12, tzinfo=timezone.utc)
-
-# Turn completion must be NO LATER than 18:28Z (straight after this)
-TURN_COMPLETE_TIME_UTC = datetime(2014, 3, 7, 18, 28, 0, tzinfo=timezone.utc)
-
 
 # ================= PATH RESOLUTION =================
 def resolve_local_or_mnt(path_like: str) -> str:
@@ -154,28 +133,23 @@ def resolve_local_or_mnt(path_like: str) -> str:
     if not p:
         return p
 
-    # 1) as given
     if os.path.exists(p):
         return p
 
-    # 2) relative to this file
     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
 
-    # 3) /mnt/data/filename
     base = os.path.basename(p)
     p3 = os.path.join("/mnt/data", base)
     if os.path.exists(p3):
         return p3
 
-    # 4) /mnt/data/<path_like>
     p4 = os.path.join("/mnt/data", p)
     if os.path.exists(p4):
         return p4
 
-    # fallback: return original (so error message shows expected name)
     return p
 
 
@@ -251,10 +225,6 @@ def _kml_ns_from_root(root):
 
 
 def _parse_kml_coordinates_text(txt: str):
-    """
-    Parse KML coordinates into [(lat, lon), ...]
-    Accepts lon,lat or lon,lat,alt.
-    """
     pts = []
     if not txt:
         return pts
@@ -277,14 +247,6 @@ def load_search_areas_from_kmz(kmz_path: str):
     - Placemark -> LineString
     - Placemark -> Polygon
     - MultiGeometry versions of the above
-
-    Returns list of dicts:
-      {
-        "name": str,
-        "points": [(lat,lon), ...],
-        "lines":  [ [(lat,lon), ...], ... ],
-        "polygons":[ [(lat,lon), ...], ... ]
-      }
     """
     kmz_path = resolve_local_or_mnt(kmz_path)
 
@@ -315,7 +277,6 @@ def load_search_areas_from_kmz(kmz_path: str):
         lines = []
         polys = []
 
-        # Points
         for pt in pm.findall(".//kml:Point", ns):
             coords = pt.find(".//kml:coordinates", ns)
             if coords is None or coords.text is None:
@@ -324,7 +285,6 @@ def load_search_areas_from_kmz(kmz_path: str):
             if pts:
                 points.extend(pts[:1])
 
-        # LineStrings
         for ls in pm.findall(".//kml:LineString", ns):
             coords = ls.find(".//kml:coordinates", ns)
             if coords is None or coords.text is None:
@@ -333,7 +293,6 @@ def load_search_areas_from_kmz(kmz_path: str):
             if len(pts) >= 2:
                 lines.append(pts)
 
-        # Polygons
         for poly in pm.findall(".//kml:Polygon", ns):
             outer = poly.find(".//kml:outerBoundaryIs/kml:LinearRing/kml:coordinates", ns)
             if outer is None or outer.text is None:
@@ -490,13 +449,6 @@ def add_permanent_label(m, name, lat, lon):
 
 
 def build_leaflet_map(path_pts, legs, seg_dists_m):
-    """
-    UPDATED:
-    - Ping rings are permanent (all rings drawn)
-    - Search areas KMZ is permanent (Points + LineStrings + Polygons)
-    - Search areas are color-coded by placemark name (Ocean Infinity / Australia / Malaysia / China / etc.)
-    - No LayerControl
-    """
     start_lat, start_lon = path_pts[0]
     m = folium.Map(
         location=[start_lat, start_lon],
@@ -505,7 +457,6 @@ def build_leaflet_map(path_pts, legs, seg_dists_m):
         control_scale=True,
     )
 
-    # Basemaps (kept; without LayerControl user won't toggle, but you requested removing LayerControl)
     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}",
@@ -528,7 +479,6 @@ def build_leaflet_map(path_pts, legs, seg_dists_m):
         nm = area.get("name", "Search area")
         col = color_for_search_area(nm)
 
-        # Points (e.g., hotspots)
         for (la, lo) in area.get("points", []) or []:
             search_area_pts_for_bounds.append((la, lo))
             folium.CircleMarker(
@@ -542,7 +492,6 @@ def build_leaflet_map(path_pts, legs, seg_dists_m):
                 tooltip=nm,
             ).add_to(m)
 
-        # LineStrings (e.g., proposed search outlines, arcs)
         for line in area.get("lines", []) or []:
             if not line:
                 continue
@@ -555,7 +504,6 @@ def build_leaflet_map(path_pts, legs, seg_dists_m):
                 tooltip=nm,
             ).add_to(m)
 
-        # Polygons (if any)
         for poly in area.get("polygons", []) or []:
             if not poly:
                 continue
@@ -650,8 +598,6 @@ def build_leaflet_map(path_pts, legs, seg_dists_m):
     for name, lat, lon in WAYPOINTS:
         add_permanent_label(m, name, float(lat), float(lon))
 
-    # NO LayerControl (removed)
-
     waypoint_pts = [(float(lat), float(lon)) for _, lat, lon in WAYPOINTS]
     all_ring_pts = []
     for k in PING_RINGS:
@@ -660,7 +606,7 @@ def build_leaflet_map(path_pts, legs, seg_dists_m):
     bounds = _all_bounds(
         [path_pts]
         + [waypoint_pts]
-        + [all_ring_pts]  # all rings
+        + [all_ring_pts]
         + ([search_area_pts_for_bounds] if search_area_pts_for_bounds else [])
     )
     if bounds:
@@ -777,63 +723,7 @@ def _predict_state_from_leg_start(method, leg_start_lat, leg_start_lon, hdg_deg,
     return float(lat), float(lon)
 
 
-def _wrap_heading_deg(h: float) -> float:
-    return float(h) % 360.0
-
-
-def _deg2rad(x: float) -> float:
-    return float(x) * math.pi / 180.0
-
-
-def _rad2deg(x: float) -> float:
-    return float(x) * 180.0 / math.pi
-
-
-def gc_distance_m_and_bearing_deg(lat1, lon1, lat2, lon2):
-    """
-    Great-circle (spherical) distance + initial bearing.
-    Used to compute the radar-fix turn leg parameters robustly without needing inverse routines in fp.
-    """
-    R = 6371000.0
-    phi1 = _deg2rad(lat1)
-    phi2 = _deg2rad(lat2)
-    dphi = _deg2rad(lat2 - lat1)
-    dlmb = _deg2rad(lon2 - lon1)
-
-    a = math.sin(dphi / 2.0) ** 2 + math.cos(phi1) * math.cos(phi2) * (math.sin(dlmb / 2.0) ** 2)
-    c = 2.0 * math.atan2(math.sqrt(a), math.sqrt(max(0.0, 1.0 - a)))
-    dist_m = R * c
-
-    y = math.sin(dlmb) * math.cos(phi2)
-    x = math.cos(phi1) * math.sin(phi2) - math.sin(phi1) * math.cos(phi2) - math.sin(phi1) * math.cos(phi2) * math.cos(dlmb)
-    brng = (math.atan2(y, x) + 2.0 * math.pi) % (2.0 * math.pi)
-    bearing_deg = _rad2deg(brng)
-    return float(dist_m), float(bearing_deg)
-
-
-def compute_turn_leg_from_radar_fix(turn_lat, turn_lon, method):
-    """
-    Compute a single straight leg from the radar fix (18:22:12Z) to the user-selected
-    turn completion point at 18:28:00Z.
-    Returns (heading_deg, speed_knots, minutes, distance_km).
-    """
-    dt_sec = (TURN_COMPLETE_TIME_UTC - RADAR_FIX_TIME_UTC).total_seconds()
-    if dt_sec <= 0:
-        return None
-
-    dist_m, bearing_deg = gc_distance_m_and_bearing_deg(
-        float(RADAR_FIX_LAT), float(RADAR_FIX_LON),
-        float(turn_lat), float(turn_lon)
-    )
-
-    speed_mps = dist_m / dt_sec
-    speed_knots = speed_mps / 0.514444
-    minutes = dt_sec / 60.0
-
-    return float(bearing_deg), float(speed_knots), float(minutes), float(dist_m / 1000.0)
-
-
-# ================= BFO ANALYSIS (with descent profile) =================
+# ================= BFO ANALYSIS =================
 def bfo_analysis_with_legs(start_lat, start_lon, legs, method, start_time_str, alt_ft, vs_fpm, descent_start_choice):
     start_dt = _parse_start_time(start_time_str)
     pts = _ping_points_after(start_dt)
@@ -956,7 +846,7 @@ def speed_from_profile(profile: str, alt_ft: float, custom_mach: float, custom_k
     return mach_to_tas_knots(0.82, alt_ft)
 
 
-# ================= GUIDED SCORING (general legs) =================
+# ================= GUIDED SCORING =================
 def make_legs_from_schedule(headings, speed_knots, schedule_minutes):
     legs = []
     if isinstance(headings, (int, float)):
@@ -1080,6 +970,10 @@ 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):
@@ -1105,7 +999,6 @@ def _coordinate_descent_deltas(
     best_s = None
     best_d = deltas[:]
 
-    # simple coordinate descent
     for _it in range(max(1, int(iters))):
         improved = False
         for j in range(n):
@@ -1131,7 +1024,6 @@ def _coordinate_descent_deltas(
 
             deltas[j] = best_local_dj
 
-            # track best overall
             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[:]
@@ -1140,7 +1032,6 @@ def _coordinate_descent_deltas(
         if not improved:
             break
 
-    # final score (ensure consistency)
     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(
@@ -1158,9 +1049,6 @@ def _to_label_utc(dt: datetime) -> str:
 
 
 def _lookup_measured_at_dt(dt_ping: datetime):
-    """
-    Return measured (BFO,BTO) nearest in time to dt_ping.
-    """
     if hasattr(fp, "nearest_measured_for_time"):
         idx = fp.nearest_measured_for_time(dt_ping)[0]
         row = fp.satLoc[idx]
@@ -1168,7 +1056,6 @@ def _lookup_measured_at_dt(dt_ping: datetime):
         meas_bto = row[SATLOC_IDX_MEAS_BTO]
         return meas_bfo, meas_bto
 
-    # fallback: brute force nearest
     best_i = None
     best_dt = None
     for i, row in enumerate(fp.satLoc):
@@ -1196,18 +1083,15 @@ 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)]
@@ -1244,7 +1128,6 @@ 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))
 
@@ -1271,8 +1154,6 @@ def build_validation_table(
 
 
 # ================= GUIDED SOLVERS =================
-# (UNCHANGED BELOW — only wiring changes later)
-
 def solve_guided_straight(
     start_lat, start_lon, method, speed_knots, alt_ft, vs_fpm,
     descent_start_choice, weight_bfo, weight_bto
@@ -1353,8 +1234,6 @@ def solve_guided_straight_with_drift(
             f"Guided schedule mismatch: schedule totals {total_sched_min:.1f} min but window is {total_window_min:.1f} min."
         ), None
 
-    base_step = 1.0 if float(drift_max_deg) > 0 else STRAIGHT_STEP_DEG
-
     best_s = None
     best_legs = None
     best_h0 = None
@@ -1384,7 +1263,7 @@ def solve_guided_straight_with_drift(
             best_h0 = float(h0)
             best_deltas = deltas
 
-        h0 += float(base_step)
+        h0 += 1.0  # coarse sweep when drift is enabled
 
     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
@@ -1404,7 +1283,7 @@ def solve_guided_straight_with_drift(
         f"- Start: lat **{float(start_lat):.2f}**, lon **{float(start_lon):.2f}**",
         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 if float(drift_max_deg)>0 else STRAIGHT_STEP_DEG}°)",
+        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 "",
@@ -1416,156 +1295,6 @@ def solve_guided_straight_with_drift(
     return best_legs, report, start_dt
 
 
-def solve_guided_turn_after_ping6(
-    start_lat, start_lon, 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()
-
-    descent_start_dt = None
-    if (descent_start_choice or "").startswith("After Ping Ring 6"):
-        descent_start_dt = dt_ping6_utc()
-    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
-
-    n = len(GUIDED_LEG_SCHEDULE_MIN)
-    if n != 7:
-        return None, "Turn scenario expects 7 legs in the schedule.", None
-
-    best = None
-    best_h1 = None
-    best_h2 = None
-
-    h1 = GUIDED_HEADING_MIN
-    while h1 <= GUIDED_HEADING_MAX + 1e-9:
-        delta = -TURN_DELTA_MAX_DEG
-        while delta <= TURN_DELTA_MAX_DEG + 1e-9:
-            h2 = (float(h1) + float(delta)) % 360.0
-            headings = [h1]*5 + [h2]*2
-            legs = make_legs_from_schedule(headings, float(speed_knots), GUIDED_LEG_SCHEDULE_MIN)
-
-            s = score_legs_bfo_bto(
-                start_lat, start_lon, method, start_dt, end_dt, 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_h1 = float(h1)
-                best_h2 = float(h2)
-
-            delta += TURN_DELTA_STEP_DEG
-        h1 += TURN_H1_STEP_DEG
-
-    if best is None:
-        return None, f"Guided solve: not enough ping points between {GUIDED_START_LABEL} and {GUIDED_END_LABEL} to score.", None
-
-    headings = [best_h1]*5 + [best_h2]*2
-    legs = make_legs_from_schedule(headings, float(speed_knots), GUIDED_LEG_SCHEDULE_MIN)
-
-    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"
-
-    report = "\n".join([
-        "**Guided mode: Turn after Ping Ring 6 (two headings)**",
-        f"- Window: **{GUIDED_START_LABEL}Z → 00:20:00Z**",
-        f"- Start: lat **{float(start_lat):.2f}**, lon **{float(start_lon):.2f}**",
-        f"- Legs: **{sched_txt}**",
-        f"- Speed: **{float(speed_knots):.1f} kt**",
-        f"- Heading legs 1–5 (to Ping Ring 6): **{best_h1:.1f}°**",
-        f"- Heading legs 6–7 (Ping Ring 6 → end): **{best_h2:.1f}°** (searched delta ±{TURN_DELTA_MAX_DEG:.0f}°)",
-        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
-
-
-def solve_guided_radar_fix_turn_then_southern(
-    turn_complete_lat, turn_complete_lon,
-    method,
-    speed_knots_southern,
-    alt_ft, vs_fpm,
-    descent_start_choice, weight_bfo, weight_bto
-):
-    out = compute_turn_leg_from_radar_fix(float(turn_complete_lat), float(turn_complete_lon), method)
-    if out is None:
-        return None, "Invalid radar-fix turn time window.", None
-
-    turn_hdg, turn_spd_kt, turn_minutes, turn_dist_km = out
-
-    if not (200.0 <= turn_spd_kt <= 650.0):
-        return None, (
-            f"Turn leg implies **{turn_spd_kt:.0f} kt** from radar fix to completion @18:28Z. "
-            f"That’s implausible — move the completion point closer/farther."
-        ), None
-
-    start_dt = dt_guided_start_utc()
-    end_dt = dt_guided_end_utc()
-
-    descent_start_dt = None
-    if (descent_start_choice or "").startswith("After Ping Ring 6"):
-        descent_start_dt = dt_ping6_utc()
-    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
-    h = GUIDED_HEADING_MIN
-    while h <= GUIDED_HEADING_MAX + 1e-9:
-        southern_legs = make_legs_from_schedule(h, float(speed_knots_southern), GUIDED_LEG_SCHEDULE_MIN)
-        s = score_legs_bfo_bto(
-            float(turn_complete_lat), float(turn_complete_lon),
-            method, start_dt, end_dt, southern_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
-
-    if best is None or best_h is None:
-        return None, "Radar-fix scenario: not enough ping points in 18:28→00:20 window to solve southern heading.", None
-
-    southern_legs = make_legs_from_schedule(best_h, float(speed_knots_southern), GUIDED_LEG_SCHEDULE_MIN)
-    all_legs = [(turn_hdg, turn_spd_kt, turn_minutes)] + southern_legs
-
-    rbto = best["rmse_bto"]
-    rbto_txt = f"{rbto:.1f} µs" if rbto is not None else "n/a"
-
-    report = "\n".join([
-        "**Guided mode: Radar fix → turn completion (by 18:28Z) → southern solve**",
-        f"- Radar fix: **18:22:12Z** @ lat **{RADAR_FIX_LAT:.3f}**, lon **{RADAR_FIX_LON:.3f}**",
-        f"- Turn completion (fixed time): **18:28:00Z** @ lat **{float(turn_complete_lat):.3f}**, lon **{float(turn_complete_lon):.3f}**",
-        f"- Turn leg: heading **{turn_hdg:.1f}°**, speed **{turn_spd_kt:.1f} kt**, duration **{turn_minutes:.2f} min**, distance **{turn_dist_km:.1f} km**",
-        "",
-        f"- Southern speed: **{float(speed_knots_southern):.1f} kt**",
-        f"- Southern best heading: **{best_h:.1f}°** (searched {GUIDED_HEADING_MIN:.0f}–{GUIDED_HEADING_MAX:.0f}°, step {STRAIGHT_STEP_DEG}°)",
-        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 all_legs, report, RADAR_FIX_TIME_UTC
-
-
 # ================= RUNNERS =================
 def _run_common(start_lat, start_lon, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice):
     path_pts, seg_dists_m, total_time_min = simulate_path(start_lat, start_lon, legs, method)
@@ -1604,7 +1333,6 @@ def run_guided(
     start_lat, start_lon, method, alt_ft, vs_fpm, descent_start_choice,
     speed_profile, custom_mach, custom_knots, guided_scenario,
     weight_bfo, weight_bto,
-    turn_complete_lat, turn_complete_lon,
     drift_max_deg, drift_weight
 ):
     spd_knots = speed_from_profile(speed_profile, alt_ft, custom_mach, custom_knots)
@@ -1617,26 +1345,6 @@ def run_guided(
         )
         sim_start_lat = start_lat
         sim_start_lon = start_lon
-
-    elif (guided_scenario or "").startswith("Radar fix"):
-        legs, report_md, start_dt = solve_guided_radar_fix_turn_then_southern(
-            turn_complete_lat, turn_complete_lon,
-            method,
-            spd_knots,
-            alt_ft, vs_fpm,
-            descent_start_choice, weight_bfo, weight_bto
-        )
-        sim_start_lat = RADAR_FIX_LAT
-        sim_start_lon = RADAR_FIX_LON
-
-    elif (guided_scenario or "").startswith("Turn after Ping Ring 6"):
-        legs, report_md, start_dt = solve_guided_turn_after_ping6(
-            start_lat, start_lon, method, spd_knots, alt_ft, vs_fpm,
-            descent_start_choice, weight_bfo, weight_bto
-        )
-        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,
@@ -1686,8 +1394,6 @@ with gr.Blocks() as demo:
         start_lon = gr.Slider(70, 115, value=95.69, label="Start Longitude (used for scenarios A/B)")
         method = gr.Dropdown(["VINCENTY", "RHUMB"], value="VINCENTY", label="Method")
 
-    # REMOVED: rings CheckboxGroup (all rings are permanent now)
-
     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")
@@ -1705,8 +1411,6 @@ with gr.Blocks() as demo:
             [
                 "Straight (single heading)",
                 "Straight + drift (per-leg ±deg, penalized)",
-                "Turn after Ping Ring 6 (two headings)",
-                "Radar fix → turn completion @18:28Z → southern solve"
             ],
             value="Straight (single heading)",
             label="Scenario",
@@ -1724,16 +1428,6 @@ with gr.Blocks() as demo:
         drift_max_deg = gr.Slider(0.0, 5.0, value=DEFAULT_DRIFT_MAX_DEG, step=0.1, label="Max drift per leg (±deg)")
         drift_weight = gr.Slider(0.0, 2.0, value=DEFAULT_WEIGHT_DRIFT, step=0.05, label="Drift penalty weight (higher = less drift)")
 
-    gr.Markdown("### Radar-fix turn completion point (Scenario C only)")
-    gr.Markdown(
-        f"- Radar fix is fixed at **18:22:12Z @ {RADAR_FIX_LAT:.3f}, {RADAR_FIX_LON:.3f}**\n"
-        f"- Turn completion time is fixed at **18:28:00Z** (latest allowed)\n"
-        f"- You choose the **completion latitude/longitude** below."
-    )
-    with gr.Row():
-        turn_complete_lat = gr.Slider(-10, 15, value=6.76, step=0.01, label="Turn completion latitude (°)")
-        turn_complete_lon = gr.Slider(70, 115, value=95.69, step=0.01, label="Turn completion longitude (°)")
-
     gr.Markdown("### Guided scoring weights")
     with gr.Row():
         weight_bfo = gr.Slider(0.0, 5.0, value=DEFAULT_WEIGHT_BFO, step=0.1, label="Weight: BFO")
@@ -1789,7 +1483,6 @@ with gr.Blocks() as demo:
             start_lat, start_lon, method, alt_ft, vs_fpm, descent_start_choice,
             speed_profile, custom_mach, custom_knots, guided_scenario,
             weight_bfo, weight_bto,
-            turn_complete_lat, turn_complete_lon,
             drift_max_deg, drift_weight
         ],
         outputs=[legs_df, status_md, out_map, stats, bfo_plot, bfo_score, alt_plot, validation_df],