Update app.py

app.py

@@ -6,7 +6,6 @@
 #   B) Variable heading & speed  (beam search, BTO-first)
 #   C) Variable heading & speed (SE bias after 22:40)  (beam search, BTO-first + tiny east bias only after 22:40)
 #   D) Variable heading, CONSTANT southern speed (443 kt)  (beam search, BTO-first)
-#   E) Variable heading & speed (force BTO+BFO ~= 0 where measured)  (segment-wise: BTO forced via speed-fit, BFO forced via heading root)
 #
 # Key behavior:
 # - Last radar spot FIXED: 18:22:00Z @ 6.578N, 96.341E
@@ -16,7 +15,6 @@
 #
 # THIS VERSION (changes requested):
 # - Mode D constant southern speed changed from 447 kt -> 443 kt
-# - NEW Mode E: variable heading & speed trying to force BOTH BTO and BFO errors to 0 (where measured)
 # - NEW Map feature: show lat/lon under mouse cursor (Leaflet MousePosition plugin)
 
 import os
@@ -152,16 +150,6 @@ SE_EAST_DIVERGE_START_SEG_INDEX = 4          # seg 4 starts after 22:40
 SE_VAR_EAST_DELTA_SET = [-8, -4, -2, 0, 2]   # prefer small decreases (eastward) after 22:40
 SE_EAST_BIAS_PENALTY_US_PER_DEG = 0.8        # small; BTO still dominates
 
-# ===== NEW: "force BTO+BFO to 0" knobs =====
-ZERO_H_SCAN_HALF_WINDOW_DEG = 14.0   # scan around previous heading for sign change
-ZERO_H_SCAN_STEP_DEG = 0.5
-ZERO_H_BISECT_ITERS = 22
-ZERO_BTO_TOL_US = 0.2               # practical tolerance; speed-fit tries to hit near 0 already
-ZERO_BFO_TOL_HZ = 0.02              # practical tolerance
-ZERO_TURN_H_STEP_DEG = 2.0          # coarse grid for turn-end fit
-ZERO_TURN_V_STEP_KT = 10.0          # coarse grid for turn speed
-ZERO_SCORE_BFO_TO_BTO_US = 20.0     # convert 1 Hz ~ 20 us for scoring
-
 # Search area colors (optional)
 SEARCH_AREA_COLORS = {
     "Ocean Infinity": "#ff3b3b",
@@ -1284,19 +1272,6 @@ def _bto_calc(method: str, lat: float, lon: float, dt_ping: datetime, alt_ft: fl
     return float(fp.calculateBTO_at_time(float(lat), float(lon), alt_m, dt_ping))
 
 
-def _bfo_calc(method: str, lat: float, lon: float, dt_ping: datetime, hdg: float, spd_kt: float,
-              alt_ft: float, vs_fpm: float, start_dt: datetime, descent_start_dt: datetime | None):
-    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
-
-    spd_mps = float(spd_kt) * 1852.0 / 3600.0
-    return float(fp.calculateBFO_at_time(float(spd_mps), float(hdg), float(lat), float(lon), float(alt_m), float(vs_mps), dt_ping))
-
-
 def _golden_min_abs(fn, lo: float, hi: float, iters: int = 24):
     grc = (math.sqrt(5.0) - 1.0) / 2.0
     a, b = float(lo), float(hi)
@@ -1351,7 +1326,7 @@ def _fit_segment_speed(
         for _ in range(26):
             m = 0.5 * (a + b)
             fm = float(err(m))
-            if abs(fm) < float(ZERO_BTO_TOL_US):
+            if abs(fm) < 0.2:
                 a = b = m
                 break
             if (fa < 0 and fm > 0) or (fa > 0 and fm < 0):
@@ -1951,246 +1926,6 @@ def solve_guided_constant_speed(method, alt_ft, vs_fpm, descent_start_choice):
     return best_global_legs, "", start_dt
 
 
-# ================= NEW Guided Solver: Force BTO + BFO =================
-def _fit_heading_speed_force_bto_bfo(
-    method: str,
-    lat0: float,
-    lon0: float,
-    h_prev: float,
-    minutes: float,
-    dt_end: datetime,
-    alt_ft: float,
-    vs_fpm: float,
-    start_dt: datetime,
-    descent_start_dt: datetime | None,
-):
-    # Measurements at dt_end
-    bfo_meas, bto_meas = _lookup_measured_at_dt(dt_end)
-    if dt_end == dt_0020_utc():
-        try:
-            bfo_meas = float(MEASURED_BFO_0020_HZ)
-        except Exception:
-            pass
-
-    have_bto = (bto_meas is not None)
-    have_bfo = (bfo_meas is not None)
-
-    # If we can't force both, fallback to "BTO only" speed fit and keep heading near previous
-    if not (have_bto and have_bfo):
-        h_use = _clamp(float(h_prev), VAR_HEADING_MIN, VAR_HEADING_MAX)
-        v_use, bto_err, (lat1, lon1) = _fit_segment_speed(
-            method=method,
-            lat0=float(lat0),
-            lon0=float(lon0),
-            hdg=float(h_use),
-            minutes=float(minutes),
-            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,
-        )
-        bfo_err = float("nan")
-        if have_bfo:
-            bfo_calc = _bfo_calc(method, lat1, lon1, dt_end, h_use, v_use, alt_ft, vs_fpm, start_dt, descent_start_dt)
-            bfo_err = float(bfo_calc - float(bfo_meas))
-        return float(h_use), float(v_use), float(bto_err), float(bfo_err), (float(lat1), float(lon1))
-
-    bto_meas = float(bto_meas)
-    bfo_meas = float(bfo_meas)
-
-    # g(h) = BFO error after choosing v(h) that enforces BTO (via speed-fit)
-    def eval_at_h(h):
-        h = _clamp(float(h), VAR_HEADING_MIN, VAR_HEADING_MAX)
-        v, bto_err, (lat1, lon1) = _fit_segment_speed(
-            method=method,
-            lat0=float(lat0),
-            lon0=float(lon0),
-            hdg=float(h),
-            minutes=float(minutes),
-            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,
-        )
-        bfo_calc = _bfo_calc(method, lat1, lon1, dt_end, h, v, alt_ft, vs_fpm, start_dt, descent_start_dt)
-        return float(bfo_calc - bfo_meas), float(v), float(bto_err), (float(lat1), float(lon1))
-
-    # Scan around previous heading for sign change (so we can bisection to drive BFO error -> 0)
-    h_center = _clamp(float(h_prev), VAR_HEADING_MIN, VAR_HEADING_MAX)
-    h_lo = _clamp(h_center - float(ZERO_H_SCAN_HALF_WINDOW_DEG), VAR_HEADING_MIN, VAR_HEADING_MAX)
-    h_hi = _clamp(h_center + float(ZERO_H_SCAN_HALF_WINDOW_DEG), VAR_HEADING_MIN, VAR_HEADING_MAX)
-    hs = _frange(h_lo, h_hi, ZERO_H_SCAN_STEP_DEG)
-    if not hs:
-        hs = [h_center]
-
-    vals = []
-    for h in hs:
-        be, v, bto_e, (la, lo2) = eval_at_h(h)
-        vals.append((h, be, v, bto_e, la, lo2))
-
-    # Try to find bracket with sign change
-    bracket = None
-    for i in range(len(vals) - 1):
-        h0, e0, *_ = vals[i]
-        h1, e1, *_ = vals[i + 1]
-        if (e0 == 0.0) or (e1 == 0.0):
-            bracket = (h0, h0) if abs(e0) <= abs(e1) else (h1, h1)
-            break
-        if (e0 < 0 and e1 > 0) or (e0 > 0 and e1 < 0):
-            bracket = (h0, h1)
-            break
-
-    if bracket is None:
-        # No sign change -> pick best abs error from scan, optionally refine by golden min abs
-        best = min(vals, key=lambda t: abs(float(t[1])))
-        h_best = float(best[0])
-        # small local refine by golden around neighbors if possible
-        h_l = _clamp(h_best - 2.0, h_lo, h_hi)
-        h_r = _clamp(h_best + 2.0, h_lo, h_hi)
-
-        def abs_bfo(h):
-            return abs(eval_at_h(h)[0])
-
-        if h_r - h_l > 1e-6:
-            h_best, _ = _golden_min_abs(lambda x: abs_bfo(x), h_l, h_r, iters=14)
-
-        bfo_err, v_best, bto_err, (lat1, lon1) = eval_at_h(h_best)
-        return float(h_best), float(v_best), float(bto_err), float(bfo_err), (float(lat1), float(lon1))
-
-    a, b = bracket
-    if abs(b - a) < 1e-9:
-        bfo_err, v_best, bto_err, (lat1, lon1) = eval_at_h(a)
-        return float(a), float(v_best), float(bto_err), float(bfo_err), (float(lat1), float(lon1))
-
-    fa, *_ = eval_at_h(a)
-    fb, *_ = eval_at_h(b)
-
-    # Bisection on heading to drive BFO error to 0
-    left, right = float(a), float(b)
-    fL, fR = float(fa), float(fb)
-    best_h = left
-    best_abs = abs(fL)
-
-    for _ in range(int(ZERO_H_BISECT_ITERS)):
-        mid = 0.5 * (left + right)
-        fM, vM, btoM, (laM, loM) = eval_at_h(mid)
-
-        if abs(float(fM)) < best_abs:
-            best_abs = abs(float(fM))
-            best_h = float(mid)
-
-        if abs(float(fM)) <= float(ZERO_BFO_TOL_HZ):
-            best_h = float(mid)
-            break
-
-        if (fL < 0 and fM > 0) or (fL > 0 and fM < 0):
-            right, fR = float(mid), float(fM)
-        else:
-            left, fL = float(mid), float(fM)
-
-    bfo_err, v_best, bto_err, (lat1, lon1) = eval_at_h(best_h)
-    return float(best_h), float(v_best), float(bto_err), float(bfo_err), (float(lat1), float(lon1))
-
-
-def solve_guided_force_bto_bfo(method, alt_ft, vs_fpm, descent_start_choice):
-    start_dt = _guided_start_dt()
-    end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
-    descent_start_dt = _descent_start_dt_from_choice(descent_start_choice)
-
-    # ---- Step 1: choose (v_turn, h1) to best match BOTH BTO & BFO at 18:40 end-of-turn (best-effort)
-    dt_1840 = TURN_COMPLETE_TIME_UTC
-    bfo_meas_1840, bto_meas_1840 = _lookup_measured_at_dt(dt_1840)
-
-    # If missing, fall back to a reasonable default search like variable mode start
-    have_turn_meas = (bto_meas_1840 is not None) and (bfo_meas_1840 is not None)
-    if dt_1840 == dt_0020_utc():
-        try:
-            bfo_meas_1840 = float(MEASURED_BFO_0020_HZ)
-        except Exception:
-            pass
-
-    v_candidates = list(np.arange(TURN_SPEED_MIN_KT, TURN_SPEED_MAX_KT + 1e-9, float(ZERO_TURN_V_STEP_KT)))
-    h_candidates = list(np.arange(VAR_HEADING_MIN, VAR_HEADING_MAX + 1e-9, float(ZERO_TURN_H_STEP_DEG)))
-
-    best_score = None
-    best_turn = None  # (v_turn, h1, turn_legs, turn_end_latlon)
-
-    if not have_turn_meas:
-        # just pick something consistent with your previous modes
-        for v_turn in v_candidates:
-            for h1 in h_candidates:
-                turn_legs, _ = build_turn_legs(float(v_turn), method, float(h1))
-                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])
-                score = 0.0
-                if best_score is None or score < best_score:
-                    best_score = score
-                    best_turn = (float(v_turn), float(h1), turn_legs, (lat0, lon0))
-    else:
-        bto_meas_1840 = float(bto_meas_1840)
-        bfo_meas_1840 = float(bfo_meas_1840)
-
-        for v_turn in v_candidates:
-            for h1 in h_candidates:
-                turn_legs, _ = build_turn_legs(float(v_turn), method, float(h1))
-                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])
-
-                bto_calc = _bto_calc(method, lat0, lon0, dt_1840, alt_ft, vs_fpm, start_dt, descent_start_dt)
-                bfo_calc = _bfo_calc(method, lat0, lon0, dt_1840, float(h1), float(v_turn), alt_ft, vs_fpm, start_dt, descent_start_dt)
-
-                bto_err = float(bto_calc - bto_meas_1840)
-                bfo_err = float(bfo_calc - bfo_meas_1840)
-
-                score = abs(bto_err) + float(ZERO_SCORE_BFO_TO_BTO_US) * abs(bfo_err)
-
-                if best_score is None or score < best_score:
-                    best_score = score
-                    best_turn = (float(v_turn), float(h1), turn_legs, (lat0, lon0))
-
-    if best_turn is None:
-        return None, "Guided solve: Force BTO+BFO could not initialize turn.", None
-
-    v_turn_best, h1_best, turn_legs_best, (lat_cur, lon_cur) = best_turn
-
-    # ---- Step 2: sequentially solve each south segment to force BTO (via speed) and BFO (via heading)
-    headings = []
-    speeds = []
-    h_prev = float(h1_best)
-
-    for mins, end_lbl in zip(GUIDED_SOUTH_SEG_MIN, GUIDED_SOUTH_SEG_LABELS_END):
-        dt_end = _dt_from_label(end_lbl)
-
-        h_seg, v_seg, bto_err, bfo_err, (lat1, lon1) = _fit_heading_speed_force_bto_bfo(
-            method=method,
-            lat0=float(lat_cur),
-            lon0=float(lon_cur),
-            h_prev=float(h_prev),
-            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,
-        )
-
-        headings.append(float(h_seg))
-        speeds.append(float(v_seg))
-        lat_cur, lon_cur = float(lat1), float(lon1)
-        h_prev = float(h_seg)
-
-    south_legs = _build_south_legs_variable(headings, speeds, GUIDED_SOUTH_SEG_MIN)
-    full_legs = clip_legs_to_end_dt(turn_legs_best + south_legs, start_dt, end_dt)
-
-    return full_legs, "", start_dt
-
-
 # ================= RUNNERS =================
 def _run_common(start_lat, start_lon, legs, method, start_dt, alt_ft, vs_fpm, descent_start_choice):
     if start_dt == RADAR_FIX_TIME_UTC:
@@ -2239,7 +1974,8 @@ def run_guided(guided_mode, start_lat, start_lon, method, alt_ft, vs_fpm, descen
     elif guided_mode.startswith("Variable heading (constant"):
         legs, _report_md, start_dt = solve_guided_constant_speed(method, alt_ft, vs_fpm, descent_start_choice)
     else:
-        legs, _report_md, start_dt = solve_guided_force_bto_bfo(method, alt_ft, vs_fpm, descent_start_choice)
+        # Safety fallback: if an unknown label appears, just run Straight heading.
+        legs, _report_md, start_dt = solve_guided_straight(method, alt_ft, vs_fpm, descent_start_choice)
 
     if legs is None:
         fig = go.Figure()
@@ -2286,7 +2022,6 @@ with gr.Blocks() as demo:
             "Variable heading & speed",
             "Variable heading & speed (SE after 22:40)",
             f"Variable heading (constant {CONST_SOUTH_SPEED_KT:.0f} kt)",
-            "Variable heading & speed (force BTO+BFO = 0)",
         ],
         value="Straight heading",
         label="Guided scenario",