Update app.py

app.py

@@ -15,17 +15,16 @@
 # 1) Remove trajectory (red line) AFTER 00:20
 #    - In guided mode, we CLIP the simulated legs so the polyline ends exactly at 00:20Z.
 # 2) Restore BFO plot
+#    - Full BFO analysis computation + chart + MAE/RMSE markdown.
 #
-# PREVIOUS UPDATES:
-# 3) Plausible final major turn (18:22→18:40) can adjust BOTH heading and speed (turn speed searched)
+# TURN MODEL:
+# 3) Plausible final major turn (18:22→18:40) can adjust BOTH heading and speed
 # 4) Two-stage guided search (COARSE → REFINE)
-# 5) Southern trajectory speed is free (solver searches best speed vs BFO+BTO)
 #
 # NEW (THIS UPDATE):
-# 6) Removed the Speed Profile UI section entirely.
-#    - Guided solver still freely searches southern speed + turn speed to best match BFO+BTO.
-#    - Internally, we use a reasonable starting guess (Mach 0.82 at current altitude) only to center
-#      the search window — user no longer needs to choose a speed profile.
+# 5) Removed "Speed profile / Custom Mach / Custom knots" UI section entirely.
+#    - Guided solver freely chooses southern speed (and turn speed) to best match measured BFO+BTO.
+#    - A hidden internal speed guess (Mach 0.82 at current altitude) is used only to center the search window.
 
 import os
 import re
@@ -91,11 +90,13 @@ 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
 
 # Initial track shown in your radar annotation
 RADAR_INITIAL_TRACK_DEG = 296.0
 
 # ===== Guided validation timestamps of interest =====
+# (00:10 and 00:20 are represented as 24:10 and 24:20 in your SAT epoch helper)
 GUIDED_VALIDATION_LABELS = [
     "18:22:00",
     "18:40:00",
@@ -115,38 +116,40 @@ TURN_BANK_DEFAULT_DEG = 25.0
 TURN_STEP_SEC = 30.0
 
 # Turn-speed search parameters (turn only)
-TURN_SPEED_SEARCH_DELTA_KT = 40.0
-TURN_SPEED_STEP_KT = 5.0
-TURN_SPEED_MIN_ABS_KT = 350.0
-TURN_SPEED_MAX_ABS_KT = 550.0
+TURN_SPEED_SEARCH_DELTA_KT = 40.0     # search ± around the candidate southern speed
+TURN_SPEED_STEP_KT = 5.0              # refined candidate spacing
+TURN_SPEED_MIN_ABS_KT = 350.0         # hard min plausible
+TURN_SPEED_MAX_ABS_KT = 550.0         # hard max plausible
 
 # Southern-speed search parameters (southern speed is free)
-SOUTH_SPEED_SEARCH_DELTA_KT = 80.0
+SOUTH_SPEED_SEARCH_DELTA_KT = 120.0
 SOUTH_SPEED_MIN_ABS_KT = 330.0
 SOUTH_SPEED_MAX_ABS_KT = 530.0
 SOUTH_SPEED_STEP_KT = 2.5
 COARSE_SOUTH_SPEED_STEP_KT = 10.0
-REFINE_SOUTH_SPEED_HALF_WINDOW_KT = 12.5
+REFINE_SOUTH_SPEED_HALF_WINDOW_KT = 15.0
 
 # Guided heading search (south-ish)
 GUIDED_HEADING_MIN = 150.0
 GUIDED_HEADING_MAX = 210.0
-STRAIGHT_STEP_DEG = 0.5
+STRAIGHT_STEP_DEG = 0.5  # refined step
 
 # Southern schedule (kept)
 GUIDED_LEG_SCHEDULE_MIN = [12.0, 60.0, 60.0, 60.0, 60.0, 90.0, 10.0]
 
 # Drift
 DEFAULT_DRIFT_MAX_DEG = 2.0
-DRIFT_STEP_DEG = 0.5
+DRIFT_STEP_DEG = 0.5  # refined step
 DEFAULT_WEIGHT_DRIFT = 0.30
 DRIFT_SCALE_DEG = 1.0
 
 # ===== Two-stage search knobs =====
+# Stage 1 (coarse)
 COARSE_HEADING_STEP_DEG = 2.0
 COARSE_TURN_SPEED_STEP_KT = 10.0
 COARSE_DRIFT_STEP_DEG = 1.0
 
+# Stage 2 (refine around best)
 REFINE_HEADING_HALF_WINDOW_DEG = 2.0
 REFINE_TURN_SPEED_HALF_WINDOW_KT = 10.0
 REFINE_DRIFT_HALF_WINDOW_DEG = 1.0
@@ -449,11 +452,9 @@ def build_turn_legs(
 
     legs = []
 
-    # initial straight on radar track
     if straight_sec > 1.0:
         legs.append((h0, float(speed_knots), straight_sec / 60.0))
 
-    # discretized turn segments
     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))
@@ -694,6 +695,72 @@ def clip_legs_to_end_dt(legs, start_dt: datetime, end_dt: datetime):
     return out
 
 
+# ================= INTERNAL SPEED HELPERS (no UI) =================
+def isa_speed_of_sound_mps(alt_m: float) -> float:
+    T0 = 288.15
+    L = -0.0065
+    h_trop = 11000.0
+    if alt_m <= h_trop:
+        T = T0 + L * alt_m
+    else:
+        T = 216.65
+    gamma = 1.4
+    R = 287.05
+    return math.sqrt(gamma * R * T)
+
+
+def mach_to_tas_knots(mach: float, alt_ft: float) -> float:
+    alt_m = float(alt_ft) * 0.3048
+    a = isa_speed_of_sound_mps(alt_m)
+    tas_mps = float(mach) * a
+    return tas_mps / 0.514444
+
+
+def _turn_speed_candidates(south_speed_knots: float, step_kt: float):
+    base = float(south_speed_knots)
+    lo = max(TURN_SPEED_MIN_ABS_KT, base - float(TURN_SPEED_SEARCH_DELTA_KT))
+    hi = min(TURN_SPEED_MAX_ABS_KT, base + float(TURN_SPEED_SEARCH_DELTA_KT))
+    step = max(1.0, float(step_kt))
+    if hi < lo:
+        lo, hi = hi, lo
+    cand = list(np.arange(lo, hi + 1e-9, step))
+    if all(abs(c - base) > 1e-9 for c in cand):
+        cand.append(base)
+    return sorted({round(float(c), 6) for c in cand})
+
+
+def _south_speed_candidates(base_guess_knots: float, step_kt: float):
+    base = float(base_guess_knots)
+    lo = max(SOUTH_SPEED_MIN_ABS_KT, base - float(SOUTH_SPEED_SEARCH_DELTA_KT))
+    hi = min(SOUTH_SPEED_MAX_ABS_KT, base + float(SOUTH_SPEED_SEARCH_DELTA_KT))
+    step = max(1.0, float(step_kt))
+    if hi < lo:
+        lo, hi = hi, lo
+    cand = list(np.arange(lo, hi + 1e-9, step))
+    if all(abs(c - base) > 1e-9 for c in cand):
+        cand.append(base)
+    return sorted({round(float(c), 6) for c in cand})
+
+
+def _clamp(x, lo, hi):
+    return max(lo, min(hi, x))
+
+
+def _frange(lo: float, hi: float, step: float):
+    step = float(step)
+    if step <= 0:
+        return []
+    n = int(math.floor((hi - lo) / step + 1e-9)) + 1
+    out = [lo + i * step for i in range(max(0, n))]
+    return [x for x in out if x <= hi + 1e-9]
+
+
+def _refine_range(center: float, half_window: float, step: float, lo: float, hi: float):
+    lo2 = _clamp(center - half_window, lo, hi)
+    hi2 = _clamp(center + half_window, lo, hi)
+    return _frange(lo2, hi2, step)
+
+
 # ================= BFO ANALYSIS (RESTORED) =================
 def _ping_points_after(start_dt: datetime):
     pts = []
@@ -947,7 +1014,6 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
         control=True,
     ).add_to(m)
 
-    # Search areas
     search_area_pts_for_bounds = []
     for area in SEARCH_AREAS:
         nm = area.get("name", "Search area")
@@ -993,7 +1059,6 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
                 tooltip=nm,
             ).add_to(m)
 
-    # Ping rings — permanent
     for ring_name in sorted(PING_RINGS.keys()):
         ring_pts = PING_RINGS.get(ring_name)
         if not ring_pts:
@@ -1002,11 +1067,9 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
         tooltip = f"{ring_name} ({ring_time})" if ring_time else ring_name
         folium.PolyLine(ring_pts, weight=2, opacity=0.6, color="yellow", tooltip=tooltip).add_to(m)
 
-    # Flight path (polyline)
     folium.PolyLine(path_pts, color="white", weight=8, opacity=0.3).add_to(m)
     folium.PolyLine(path_pts, color="red", weight=4, opacity=1.0, tooltip="Flight path").add_to(m)
 
-    # Start marker
     folium.CircleMarker(
         location=path_pts[0],
         radius=7,
@@ -1019,7 +1082,6 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
         ),
     ).add_to(m)
 
-    # Manual mode can show an "End" marker. Guided mode: no extra end marker.
     if not is_guided:
         folium.CircleMarker(
             location=path_pts[-1],
@@ -1033,7 +1095,6 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
             ),
         ).add_to(m)
 
-    # Validation markers (authoritative)
     marker_times = _map_marker_times(start_dt, legs)
     marker_pts_for_bounds = []
 
@@ -1088,7 +1149,6 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
                 popup=folium.Popup("<br>".join(popup_lines), max_width=360),
             ).add_to(m)
 
-    # Permanent labels
     for name, lat, lon in WAYPOINTS:
         add_permanent_label(m, name, float(lat), float(lon))
 
@@ -1119,90 +1179,6 @@ def build_leaflet_map(path_pts, legs, method, start_dt):
     """
 
 
-# ================= Speed helpers (internal) =================
-def isa_speed_of_sound_mps(alt_m: float) -> float:
-    T0 = 288.15
-    L = -0.0065
-    h_trop = 11000.0
-    if alt_m <= h_trop:
-        T = T0 + L * alt_m
-    else:
-        T = 216.65
-    gamma = 1.4
-    R = 287.05
-    return math.sqrt(gamma * R * T)
-
-
-def mach_to_tas_knots(mach: float, alt_ft: float) -> float:
-    alt_m = float(alt_ft) * 0.3048
-    a = isa_speed_of_sound_mps(alt_m)
-    tas_mps = float(mach) * a
-    return tas_mps / 0.514444
-
-
-def default_speed_guess_knots(alt_ft: float) -> float:
-    # Only used to center the search window; solver still picks the best speed.
-    return mach_to_tas_knots(0.82, alt_ft)
-
-
-def _turn_speed_candidates(south_speed_knots: float, step_kt: float):
-    base = float(south_speed_knots)
-    lo = max(TURN_SPEED_MIN_ABS_KT, base - float(TURN_SPEED_SEARCH_DELTA_KT))
-    hi = min(TURN_SPEED_MAX_ABS_KT, base + float(TURN_SPEED_SEARCH_DELTA_KT))
-    step = max(1.0, float(step_kt))
-    if hi < lo:
-        lo, hi = hi, lo
-    cand = list(np.arange(lo, hi + 1e-9, step))
-    if all(abs(c - base) > 1e-9 for c in cand):
-        cand.append(base)
-    return sorted({round(float(c), 6) for c in cand})
-
-
-def _south_speed_candidates(base_guess_knots: float, step_kt: float):
-    base = float(base_guess_knots)
-    lo = max(SOUTH_SPEED_MIN_ABS_KT, base - float(SOUTH_SPEED_SEARCH_DELTA_KT))
-    hi = min(SOUTH_SPEED_MAX_ABS_KT, base + float(SOUTH_SPEED_SEARCH_DELTA_KT))
-    step = max(1.0, float(step_kt))
-    if hi < lo:
-        lo, hi = hi, lo
-    cand = list(np.arange(lo, hi + 1e-9, step))
-    if all(abs(c - base) > 1e-9 for c in cand):
-        cand.append(base)
-    return sorted({round(float(c), 6) for c in cand})
-
-
-def _clamp(x, lo, hi):
-    return max(lo, min(hi, x))
-
-
-def _frange(lo: float, hi: float, step: float):
-    step = float(step)
-    if step <= 0:
-        return []
-    n = int(math.floor((hi - lo) / step + 1e-9)) + 1
-    out = [lo + i * step for i in range(max(0, n))]
-    return [x for x in out if x <= hi + 1e-9]
-
-
-def _refine_range(center: float, half_window: float, step: float, lo: float, hi: float):
-    lo2 = _clamp(center - half_window, lo, hi)
-    hi2 = _clamp(center + half_window, lo, hi)
-    return _frange(lo2, hi2, step)
-
-
-# ================= Guided Legs Creation =================
-def make_legs_from_schedule(headings, speed_knots, schedule_minutes):
-    legs = []
-    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:
-            continue
-        legs.append((float(hdg), float(speed_knots), float(m)))
-    return legs
-
-
 # ================= Scoring helper (used in guided solvers) =================
 def score_legs_bfo_bto(
     start_lat, start_lon, method, start_dt, end_dt, legs,
@@ -1282,6 +1258,19 @@ def score_legs_bfo_bto(
     }
 
 
+# ================= Guided Legs Creation =================
+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:
+            continue
+        legs.append((float(hdg), float(speed_knots), float(m)))
+    return legs
+
+
 # ================= Guided Solvers =================
 def _guided_start_dt():
     return RADAR_FIX_TIME_UTC
@@ -1307,12 +1296,14 @@ def solve_guided_straight(
 
     def try_candidate(h_south: float, spd_south: float, spd_turn: float):
         southern_legs = make_legs_from_schedule(h_south, float(spd_south), GUIDED_LEG_SCHEDULE_MIN)
-        preturn_legs, _ = build_turn_legs(
+        preturn_legs, _turn_info = build_turn_legs(
             speed_knots=float(spd_turn),
             method=method,
             heading_final_deg=float(h_south),
         )
-        full_legs = clip_legs_to_end_dt(preturn_legs + southern_legs, start_dt, end_dt)
+        full_legs = preturn_legs + southern_legs
+        full_legs = clip_legs_to_end_dt(full_legs, start_dt, end_dt)
+
         s = score_legs_bfo_bto(
             RADAR_FIX_LAT, RADAR_FIX_LON, method, start_dt, end_dt, full_legs,
             alt_ft, vs_fpm, descent_start_dt,
@@ -1321,8 +1312,9 @@ def solve_guided_straight(
         )
         return s, full_legs
 
-    # -------- Stage 1: COARSE search --------
-    best_h = best_south_spd = best_turn_spd = None
+    best_h = None
+    best_south_spd = None
+    best_turn_spd = None
     best_full_legs = None
     best_score = None
 
@@ -1344,8 +1336,9 @@ def solve_guided_straight(
     if best_full_legs is None:
         return None, "Guided solve: not enough ping points to score.", None
 
-    # -------- Stage 2: REFINE around best --------
-    refine_headings = _refine_range(best_h, REFINE_HEADING_HALF_WINDOW_DEG, STRAIGHT_STEP_DEG, GUIDED_HEADING_MIN, GUIDED_HEADING_MAX)
+    refine_headings = _refine_range(
+        best_h, REFINE_HEADING_HALF_WINDOW_DEG, STRAIGHT_STEP_DEG, GUIDED_HEADING_MIN, GUIDED_HEADING_MAX
+    )
 
     refine_south_speeds = _refine_range(
         best_south_spd, REFINE_SOUTH_SPEED_HALF_WINDOW_KT, SOUTH_SPEED_STEP_KT,
@@ -1409,12 +1402,13 @@ def solve_guided_straight_with_drift(
         h_eff = _wrap_heading_deg(float(h0_nominal) + float(drift_deg))
 
         southern_legs = make_legs_from_schedule(h_eff, float(spd_south), GUIDED_LEG_SCHEDULE_MIN)
-        preturn_legs, _ = build_turn_legs(
+        preturn_legs, _turn_info = build_turn_legs(
             speed_knots=float(spd_turn),
             method=method,
             heading_final_deg=float(h_eff),
         )
-        full_legs = clip_legs_to_end_dt(preturn_legs + southern_legs, start_dt, end_dt)
+        full_legs = preturn_legs + southern_legs
+        full_legs = clip_legs_to_end_dt(full_legs, start_dt, end_dt)
 
         s = score_legs_bfo_bto(
             RADAR_FIX_LAT, RADAR_FIX_LON, method, start_dt, end_dt, full_legs,
@@ -1428,8 +1422,10 @@ def solve_guided_straight_with_drift(
         combined_plus = float(s["combined"]) + float(drift_weight) * (abs(float(drift_deg)) / DRIFT_SCALE_DEG)
         return s, combined_plus, full_legs
 
-    # -------- Stage 1: COARSE search --------
-    best_h0 = best_d = best_south_spd = best_turn_spd = None
+    best_h0 = None
+    best_d = None
+    best_south_spd = None
+    best_turn_spd = None
     best_full_legs = None
     best_score = None
     best_combined_plus = None
@@ -1466,9 +1462,7 @@ def solve_guided_straight_with_drift(
     if best_full_legs is None:
         return None, "Guided drift solve: not enough ping points to score.", None
 
-    # -------- Stage 2: REFINE around best --------
     refine_headings = _refine_range(best_h0, REFINE_HEADING_HALF_WINDOW_DEG, 1.0, GUIDED_HEADING_MIN, GUIDED_HEADING_MAX)
-
     d_lo = max(-drift_max_deg, best_d - REFINE_DRIFT_HALF_WINDOW_DEG)
     d_hi = min(+drift_max_deg, best_d + REFINE_DRIFT_HALF_WINDOW_DEG)
     refine_drifts = _frange(d_lo, d_hi, DRIFT_STEP_DEG) or [best_d]
@@ -1559,7 +1553,8 @@ def run_guided(
     start_lat, start_lon, method, alt_ft, vs_fpm, descent_start_choice,
     guided_scenario, weight_bfo, weight_bto, drift_max_deg, drift_weight
 ):
-    south_speed_guess = default_speed_guess_knots(alt_ft)
+    # Hidden internal guess only to center search window (solver freely chooses speed)
+    south_speed_guess = mach_to_tas_knots(0.82, float(alt_ft))
 
     if (guided_scenario or "").startswith("Straight + drift"):
         legs, report_md, start_dt = solve_guided_straight_with_drift(
@@ -1618,8 +1613,7 @@ with gr.Blocks() as demo:
         f"- **Turn completion (fixed):** 18:40:00Z\n"
         f"- **Initial track (fixed):** {RADAR_INITIAL_TRACK_DEG:.1f}°\n"
         f"- **Final resting point:** **00:20:00Z** (trajectory clipped exactly at this time)\n\n"
-        f"**Turn behavior:** 18:22→18:40 turn is solved with **adjustable turn speed**.\n"
-        f"**Southern behavior:** after 18:40, **southern speed is solved (free)** to best match BFO+BTO.\n"
+        f"**Speed behavior:** after 18:40, **southern speed is solved (free)** to best match measured BFO+BTO.\n"
         f"**Performance:** guided solver uses **two-stage search (coarse → refine)**."
     )
 
@@ -1640,15 +1634,14 @@ with gr.Blocks() as demo:
         )
 
     gr.Markdown("### Guided mode (Recommended)")
-    with gr.Row():
-        guided_scenario = gr.Dropdown(
-            [
-                "Straight (single heading)",
-                "Straight + drift (per-leg ±deg, penalized)",
-            ],
-            value="Straight (single heading)",
-            label="Scenario",
-        )
+    guided_scenario = gr.Dropdown(
+        [
+            "Straight (single heading)",
+            "Straight + drift (per-leg ±deg, penalized)",
+        ],
+        value="Straight (single heading)",
+        label="Scenario",
+    )
 
     gr.Markdown("### Heading drift settings (for “Straight + drift” scenario)")
     with gr.Row():