Update app.py

app.py

@@ -17,6 +17,11 @@
 # - Turn speed range: 470–520 kt
 # - Southern segment speed range: 430–510 kt (per segment)
 # - Waypoints at ping times are driven to ping rings for those timestamps with measured BTO.
+#
+# NEW (per your request):
+# - Adds a fast "global polish" step over the 6 southern segment speeds ONLY
+#   (coordinate descent), to reduce max |BTO error| at enforced endpoints.
+#   This helps when greedy segment-fit hits the speed floor (430 kt) but still leaves residual error.
 
 import os
 import re
@@ -127,6 +132,11 @@ BTO_TARGET_TIGHT_US = 1.0  # purely informational
 # HARD BTO labels list (will be 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"]
 
+# ===== Global polish (southern speeds only) =====
+POLISH_PASSES = 5              # small number keeps it fast
+POLISH_WINDOW_KT = 6.0         # explore +/- window around current speed
+POLISH_STEP_KT = 1.0           # 1 kt grid within window (fast + robust)
+
 # Search area colors (optional)
 SEARCH_AREA_COLORS = {
     "Ocean Infinity": "#ff3b3b",
@@ -1223,6 +1233,120 @@ def _build_south_legs_piecewise(h_south: float, speeds: list[float], minutes: li
     return legs
 
 
+def _simulate_south_endpoints(
+    method: str,
+    lat0: float,
+    lon0: float,
+    hdg: float,
+    speeds: list[float],
+    minutes: list[float],
+):
+    lat, lon = float(lat0), float(lon0)
+    endpoints = []
+    for v, m in zip(speeds, minutes):
+        lat, lon = _simulate_one_leg_end(method, lat, lon, float(hdg), float(v), float(m))
+        endpoints.append((float(lat), float(lon)))
+    return endpoints
+
+
+def _bto_errors_at_south_endpoints(
+    method: str,
+    endpoints: list[tuple[float, float]],
+    alt_ft: float,
+    vs_fpm: float,
+    start_dt: datetime,
+    descent_start_dt: datetime | None,
+):
+    errs = []
+    labels_used = []
+    for (lat, lon), end_lbl in zip(endpoints, GUIDED_SOUTH_SEG_LABELS_END):
+        dt_end = _dt_from_label(end_lbl)
+        meas = _lookup_measured_bto(dt_end)
+        if meas is None:
+            continue
+        bto = _bto_calc(method, lat, lon, dt_end, alt_ft, vs_fpm, start_dt, descent_start_dt)
+        errs.append(float(bto - meas))
+        labels_used.append(end_lbl)
+    return labels_used, errs
+
+
+def _bto_obj_from_errs(errs: list[float]):
+    if not errs:
+        return None
+    arr = np.array(errs, dtype=float)
+    max_abs = float(np.max(np.abs(arr)))
+    sum_abs = float(np.sum(np.abs(arr)))
+    rmse = float(np.sqrt(np.mean(arr * arr)))
+    # primary max abs, secondary sum abs
+    score = float(max_abs) + 1e-3 * float(sum_abs)
+    return score, max_abs, sum_abs, rmse
+
+
+def _polish_south_speeds(
+    method: str,
+    lat0: float,
+    lon0: float,
+    hdg: float,
+    speeds_init: list[float],
+    alt_ft: float,
+    vs_fpm: float,
+    start_dt: datetime,
+    descent_start_dt: datetime | None,
+):
+    speeds = [float(v) for v in speeds_init]
+    best_endpoints = _simulate_south_endpoints(method, lat0, lon0, hdg, speeds, GUIDED_SOUTH_SEG_MIN)
+    _lbls, errs = _bto_errors_at_south_endpoints(method, best_endpoints, alt_ft, vs_fpm, start_dt, descent_start_dt)
+    obj0 = _bto_obj_from_errs(errs)
+    if obj0 is None:
+        return speeds, errs, {"polish_passes": 0, "improved": False}
+
+    best_score = obj0[0]
+    improved_any = False
+
+    for _pass in range(int(POLISH_PASSES)):
+        improved_this_pass = False
+
+        for i in range(len(speeds)):
+            v0 = float(speeds[i])
+            v_lo = _clamp(v0 - POLISH_WINDOW_KT, SOUTH_SPEED_MIN_KT, SOUTH_SPEED_MAX_KT)
+            v_hi = _clamp(v0 + POLISH_WINDOW_KT, SOUTH_SPEED_MIN_KT, SOUTH_SPEED_MAX_KT)
+
+            cand_vs = _frange(v_lo, v_hi, POLISH_STEP_KT)
+            if not cand_vs:
+                continue
+
+            local_best_v = v0
+            local_best_score = best_score
+
+            # try each candidate on this coordinate
+            for v_try in cand_vs:
+                tmp = speeds[:]
+                tmp[i] = float(v_try)
+                endpoints = _simulate_south_endpoints(method, lat0, lon0, hdg, tmp, GUIDED_SOUTH_SEG_MIN)
+                _lbls2, errs2 = _bto_errors_at_south_endpoints(method, endpoints, alt_ft, vs_fpm, start_dt, descent_start_dt)
+                obj2 = _bto_obj_from_errs(errs2)
+                if obj2 is None:
+                    continue
+                score2 = obj2[0]
+                if score2 + 1e-12 < local_best_score:
+                    local_best_score = score2
+                    local_best_v = float(v_try)
+
+            if local_best_v != v0:
+                speeds[i] = local_best_v
+                best_score = local_best_score
+                improved_this_pass = True
+                improved_any = True
+
+        if not improved_this_pass:
+            break
+
+    # final errors for reporting
+    final_endpoints = _simulate_south_endpoints(method, lat0, lon0, hdg, speeds, GUIDED_SOUTH_SEG_MIN)
+    _lbls3, final_errs = _bto_errors_at_south_endpoints(method, final_endpoints, alt_ft, vs_fpm, start_dt, descent_start_dt)
+    return speeds, final_errs, {"polish_passes": int(POLISH_PASSES), "improved": bool(improved_any)}
+
+
 # ================= Guided Solver =================
 def solve_guided_straight(
     method, alt_ft, vs_fpm,
@@ -1256,9 +1380,10 @@ def solve_guided_straight(
             heading_final_deg=float(h_south),
         )
         pts_turn, _, _ = simulate_path(RADAR_FIX_LAT, RADAR_FIX_LON, turn_legs, method)
-        lat_cur, lon_cur = pts_turn[-1]
+        lat_turn_end, lon_turn_end = pts_turn[-1]
 
-        # Fit south segments sequentially (per segment speed)
+        # Fit south segments sequentially (greedy per segment)
+        lat_cur, lon_cur = float(lat_turn_end), float(lon_turn_end)
         south_speeds = []
         south_errs = []
         for mins, end_lbl in zip(GUIDED_SOUTH_SEG_MIN, GUIDED_SOUTH_SEG_LABELS_END):
@@ -1281,10 +1406,24 @@ def solve_guided_straight(
             south_errs.append(float(err_seg))
             lat_cur, lon_cur = float(lat1), float(lon1)
 
-        south_legs = _build_south_legs_piecewise(float(h_south), south_speeds, GUIDED_SOUTH_SEG_MIN)
+        # ---- NEW: global polish on southern segment speeds only ----
+        south_speeds_pol, enforced_errs_pol, polish_info = _polish_south_speeds(
+            method=method,
+            lat0=float(lat_turn_end),
+            lon0=float(lon_turn_end),
+            hdg=float(h_south),
+            speeds_init=south_speeds,
+            alt_ft=alt_ft,
+            vs_fpm=vs_fpm,
+            start_dt=start_dt,
+            descent_start_dt=descent_start_dt,
+        )
+
+        # Build full legs with polished speeds
+        south_legs = _build_south_legs_piecewise(float(h_south), south_speeds_pol, GUIDED_SOUTH_SEG_MIN)
         full_legs = clip_legs_to_end_dt(turn_legs + south_legs, start_dt, end_dt)
 
-        # Compute BTO errors at enforced timestamps
+        # Compute BTO errors at enforced timestamps (from full legs for safety)
         bto_errs = []
         for dt_k in enforced_dts:
             meas = _lookup_measured_bto(dt_k)
@@ -1299,27 +1438,29 @@ def solve_guided_straight(
         if not bto_errs:
             return None
 
-        max_abs = float(np.max(np.abs(bto_errs)))
-        sum_abs = float(np.sum(np.abs(bto_errs)))
-        rmse = float(np.sqrt(np.mean(np.array(bto_errs) ** 2)))
+        obj = _bto_obj_from_errs(bto_errs)
+        if obj is None:
+            return None
+        _score, max_abs, sum_abs, rmse = obj
 
         details = {
             "h_south": float(h_south),
             "v_turn": float(v_turn),
-            "south_speeds": south_speeds,
-            "south_errs_us": south_errs,
+            "south_speeds": [float(v) for v in south_speeds_pol],
+            "south_errs_us": south_errs,  # greedy segment-end err (may include nan if missing meas)
             "turn_info": turn_info,
             "enforced_labels": enforced_labels,
-            "max_abs_err_us": max_abs,
-            "sum_abs_err_us": sum_abs,
-            "rmse_bto_us": rmse,
+            "max_abs_err_us": float(max_abs),
+            "sum_abs_err_us": float(sum_abs),
+            "rmse_bto_us": float(rmse),
+            "polish": polish_info,
         }
         return (max_abs, sum_abs, rmse), full_legs, details
 
     def best_for_heading(h_south: float):
         h_south = float(h_south)
 
-        # Coarse scan turn speed (fast, avoids expensive nested golden everywhere)
+        # Coarse scan turn speed
         coarse_turns = list(np.arange(TURN_SPEED_MIN_KT, TURN_SPEED_MAX_KT + 1e-9, 5.0))
         best_key = None
         best_legs = None
@@ -1346,7 +1487,6 @@ def solve_guided_straight(
             if out2 is None:
                 return 1e9
             (max_abs, sum_abs, _rmse), _legs, _det = out2
-            # primary max abs, secondary sum abs
             return float(max_abs) + 1e-3 * float(sum_abs)
 
         v_best, _ = _golden_min_abs(obj, v_lo, v_hi, iters=22)
@@ -1387,21 +1527,24 @@ def solve_guided_straight(
 
     # Reporting
     south_speeds = global_det["south_speeds"]
-    south_errs = global_det["south_errs_us"]
+    greedy_seg_end_errs = global_det["south_errs_us"]
+    polish_info = global_det.get("polish", {}) or {}
 
     report_lines = [
         "**Guided mode: Straight + computed turn (18:22→18:40), clipped to 00:20**",
-        "- Solver mode: **BTO-first ring-fit (fast)**",
+        "- Solver mode: **BTO-first ring-fit (fast) + global polish (southern speeds)**",
         f"- Best southern heading: **{global_det['h_south']:.2f}°**",
         f"- Turn speed range: {TURN_SPEED_MIN_KT:.0f}–{TURN_SPEED_MAX_KT:.0f} kt | Best: **{global_det['v_turn']:.2f} kt**",
         "",
+        f"**Polish:** passes={POLISH_PASSES}, window=±{POLISH_WINDOW_KT:.0f} kt, step={POLISH_STEP_KT:.0f} kt | improved={polish_info.get('improved', False)}",
+        "",
         "**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)",
+        f"- 18:40→19:40: **{south_speeds[0]:.2f} kt** (greedy end err {greedy_seg_end_errs[0]:+.2f} µs)",
+        f"- 19:40→20:40: **{south_speeds[1]:.2f} kt** (greedy end err {greedy_seg_end_errs[1]:+.2f} µs)",
+        f"- 20:40→21:40: **{south_speeds[2]:.2f} kt** (greedy end err {greedy_seg_end_errs[2]:+.2f} µs)",
+        f"- 21:40→22:40: **{south_speeds[3]:.2f} kt** (greedy end err {greedy_seg_end_errs[3]:+.2f} µs)",
+        f"- 22:40→00:10: **{south_speeds[4]:.2f} kt** (greedy end err {greedy_seg_end_errs[4]:+.2f} µs)",
+        f"- 00:10→00:20: **{south_speeds[5]:.2f} kt** (greedy end err {greedy_seg_end_errs[5]:+.2f} µs)",
         "",
         f"- Enforced BTO timestamps (measured available): **{', '.join(global_det['enforced_labels'])}**",
         f"- Max |BTO error| at enforced times: **{global_det['max_abs_err_us']:.2f} µs**",
@@ -1507,7 +1650,8 @@ with gr.Blocks() as demo:
         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)."
+        f"**Ring-fit goal:** match BTO at ping times where measured BTO exists (auto-detected from satLoc).\n"
+        f"**Global polish:** {POLISH_PASSES} passes, ±{POLISH_WINDOW_KT:.0f} kt window, {POLISH_STEP_KT:.0f} kt step (southern speeds only)."
     )
 
     with gr.Row():
@@ -1530,6 +1674,7 @@ with gr.Blocks() as demo:
     gr.Markdown(
         "- Guided mode has **no speed inputs**.\n"
         "- Solver uses **fast BTO-first ring-fit** (turn speed + per-segment southern speeds).\n"
+        "- Then runs a **global polish** step to reduce max |BTO error| across enforced endpoints.\n"
         "- If 18:40 has no measured BTO in your satLoc, it is **automatically skipped** for enforcement."
     )