Update app.py

app.py

@@ -4,6 +4,7 @@
 # Guided scenarios (ACTIVE):
 #   A) Straight heading
 #   B) Variable heading & speed  (beam search, BTO-first)
+#   C) Variable heading & speed (SE)  (beam search, BTO-first, heading constrained <180)
 #
 # Key behavior:
 # - Last radar spot FIXED: 18:22:00Z @ 6.578N, 96.341E
@@ -21,6 +22,7 @@
 # PERFORMANCE:
 # - Straight heading mode keeps Top-K polish.
 # - Variable heading & speed uses beam search and skips polish by default (much faster).
+# - SE mode is the same beam search but constrains headings to 150–179° (towards SE-ish, avoids 190° SW).
 
 import os
 import re
@@ -138,6 +140,12 @@ VAR_HEADING_DELTA_SET = [-6, -3, 0, 3, 6]  # candidate changes per segment (deg)
 VAR_BEAM_WIDTH = 12                  # keep top-N partial paths each segment
 VAR_SMOOTH_PENALTY_US_PER_DEG = 1.5  # small penalty to avoid wiggles (still BTO-first)
 
+# ===== SE constrained mode knobs (avoid SW headings like 190°) =====
+VAR_SE_HEADING_MIN = 150.0
+VAR_SE_HEADING_MAX = 179.0
+VAR_SE_FIRST_HEADING_STEP = 4.0
+VAR_SE_HEADING_DELTA_SET = [-6, -3, 0, 3, 6]   # same style, but clamped into 150–179
+
 # Search area colors (optional)
 SEARCH_AREA_COLORS = {
     "Ocean Infinity": "#ff3b3b",
@@ -1570,7 +1578,17 @@ def solve_guided_straight(method, alt_ft, vs_fpm, descent_start_choice):
 
 
 # ================= Guided Solver: Variable heading & speed (FAST beam search) =================
-def solve_guided_variable(method, alt_ft, vs_fpm, descent_start_choice):
+def solve_guided_variable(
+    method,
+    alt_ft,
+    vs_fpm,
+    descent_start_choice,
+    heading_min: float,
+    heading_max: float,
+    first_heading_step: float,
+    heading_delta_set: list[float],
+    label_prefix: str,
+):
     start_dt = _guided_start_dt()
     end_dt = _dt_from_label(GUIDED_FINAL_LABEL)
 
@@ -1589,12 +1607,8 @@ def solve_guided_variable(method, alt_ft, vs_fpm, descent_start_choice):
     turn_speeds = list(np.arange(TURN_SPEED_MIN_KT, TURN_SPEED_MAX_KT + 1e-9, VAR_TURN_SPEED_STEP))
 
     # initial (first south heading) candidates (coarse)
-    first_headings = _frange(VAR_HEADING_MIN, VAR_HEADING_MAX, VAR_FIRST_HEADING_STEP)
+    first_headings = _frange(float(heading_min), float(heading_max), float(first_heading_step))
 
-    # Beam state:
-    # {
-    #   lat, lon, headings[], speeds[], v_turn, max_abs, sum_abs, smooth_sum
-    # }
     best_global = None
     best_global_legs = None
     best_global_info = None
@@ -1615,7 +1629,6 @@ def solve_guided_variable(method, alt_ft, vs_fpm, descent_start_choice):
             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])
 
-            # initialize beam after turn
             beam = [{
                 "lat": lat0,
                 "lon": lon0,
@@ -1631,7 +1644,6 @@ def solve_guided_variable(method, alt_ft, vs_fpm, descent_start_choice):
                 "seg_end_errs": [],
             }]
 
-            # walk segments with beam search
             for mins, end_lbl in zip(GUIDED_SOUTH_SEG_MIN, GUIDED_SOUTH_SEG_LABELS_END):
                 dt_end = _dt_from_label(end_lbl)
                 meas = _lookup_measured_bto(dt_end)
@@ -1639,13 +1651,12 @@ def solve_guided_variable(method, alt_ft, vs_fpm, descent_start_choice):
 
                 for st in beam:
                     h_prev = float(st["h_prev"])
-                    # candidate headings around previous
+
                     cand_h = []
-                    for d in VAR_HEADING_DELTA_SET:
+                    for d in heading_delta_set:
                         h_try = h_prev + float(d)
-                        h_try = _clamp(h_try, VAR_HEADING_MIN, VAR_HEADING_MAX)
+                        h_try = _clamp(h_try, float(heading_min), float(heading_max))
                         cand_h.append(h_try)
-                    # unique small set
                     cand_h = sorted(list({round(x, 6): x for x in cand_h}.values()))
 
                     for h_try in cand_h:
@@ -1664,7 +1675,6 @@ def solve_guided_variable(method, alt_ft, vs_fpm, descent_start_choice):
                             vmax=SOUTH_SPEED_MAX_KT,
                         )
 
-                        # BTO-first objective: update errors only if measured exists
                         abs_err = 0.0 if meas is None or (err_seg != err_seg) else abs(float(err_seg))
                         smooth_pen = abs(float(h_try) - float(h_prev)) * VAR_SMOOTH_PENALTY_US_PER_DEG
 
@@ -1687,7 +1697,6 @@ def solve_guided_variable(method, alt_ft, vs_fpm, descent_start_choice):
                             "seg_end_errs": st["seg_end_errs"] + [float(err_seg)],
                         })
 
-                # prune beam
                 if not next_beam:
                     beam = []
                     break
@@ -1698,7 +1707,6 @@ def solve_guided_variable(method, alt_ft, vs_fpm, descent_start_choice):
             if not beam:
                 continue
 
-            # Evaluate final beam states using enforced timestamps (full recompute for safety)
             for st in beam:
                 south_legs = _build_south_legs_variable(st["headings"], st["speeds"], GUIDED_SOUTH_SEG_MIN)
                 full_legs = clip_legs_to_end_dt(st["turn_legs"] + south_legs, start_dt, end_dt)
@@ -1723,20 +1731,25 @@ def solve_guided_variable(method, alt_ft, vs_fpm, descent_start_choice):
                         "max_abs_err_us": float(max_abs),
                         "sum_abs_err_us": float(sum_abs),
                         "rmse_bto_us": float(rmse),
+                        "heading_min": float(heading_min),
+                        "heading_max": float(heading_max),
+                        "deltas": [float(x) for x in heading_delta_set],
+                        "label_prefix": str(label_prefix),
                     }
 
     if best_global_legs is None:
-        return None, "Guided solve: Variable mode found no solution within bounds.", None
+        return None, f"Guided solve: {label_prefix} found no solution within bounds.", None
 
     hs = best_global_info["headings"]
     vs = best_global_info["speeds"]
     es = best_global_info["seg_end_errs"]
 
     report_lines = [
-        "**Guided mode: Variable heading & speed + computed turn (18:22→18:40), clipped to 00:20**",
+        f"**Guided mode: {best_global_info['label_prefix']} + computed turn (18:22→18:40), clipped to 00:20**",
         "- Solver mode: **BTO-first ring-fit (beam search)**",
+        f"- Heading bounds: **{best_global_info['heading_min']:.1f}–{best_global_info['heading_max']:.1f}°**",
         f"- Turn speed: **{best_global_info['v_turn']:.2f} kt** (range {TURN_SPEED_MIN_KT:.0f}–{TURN_SPEED_MAX_KT:.0f})",
-        f"- Beam width: **{VAR_BEAM_WIDTH}** | Heading deltas: **{VAR_HEADING_DELTA_SET}°** | Smooth penalty: **{VAR_SMOOTH_PENALTY_US_PER_DEG:.2f} µs/deg**",
+        f"- Beam width: **{VAR_BEAM_WIDTH}** | Heading deltas: **{best_global_info['deltas']}°** | Smooth penalty: **{VAR_SMOOTH_PENALTY_US_PER_DEG:.2f} µs/deg**",
         "",
         "**Per-segment heading & speed:**",
         f"- 18:40→19:40: **{hs[0]:.2f}°**, **{vs[0]:.2f} kt** (end err {es[0]:+.2f} µs)",
@@ -1755,6 +1768,34 @@ def solve_guided_variable(method, alt_ft, vs_fpm, descent_start_choice):
     return best_global_legs, "\n".join(report_lines), start_dt
 
 
+def solve_guided_variable_default(method, alt_ft, vs_fpm, descent_start_choice):
+    return solve_guided_variable(
+        method=method,
+        alt_ft=alt_ft,
+        vs_fpm=vs_fpm,
+        descent_start_choice=descent_start_choice,
+        heading_min=VAR_HEADING_MIN,
+        heading_max=VAR_HEADING_MAX,
+        first_heading_step=VAR_FIRST_HEADING_STEP,
+        heading_delta_set=VAR_HEADING_DELTA_SET,
+        label_prefix="Variable heading & speed",
+    )
+
+
+def solve_guided_variable_se(method, alt_ft, vs_fpm, descent_start_choice):
+    return solve_guided_variable(
+        method=method,
+        alt_ft=alt_ft,
+        vs_fpm=vs_fpm,
+        descent_start_choice=descent_start_choice,
+        heading_min=VAR_SE_HEADING_MIN,
+        heading_max=VAR_SE_HEADING_MAX,
+        first_heading_step=VAR_SE_FIRST_HEADING_STEP,
+        heading_delta_set=VAR_SE_HEADING_DELTA_SET,
+        label_prefix="Variable heading & speed (SE)",
+    )
+
+
 # ================= 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:
@@ -1797,8 +1838,10 @@ def run_sim_manual(start_lat, start_lon, legs_df, method, start_time_str, alt_ft
 def run_guided(guided_mode, start_lat, start_lon, method, alt_ft, vs_fpm, descent_start_choice):
     if guided_mode == "Straight heading":
         legs, report_md, start_dt = solve_guided_straight(method, alt_ft, vs_fpm, descent_start_choice)
+    elif guided_mode == "Variable heading & speed":
+        legs, report_md, start_dt = solve_guided_variable_default(method, alt_ft, vs_fpm, descent_start_choice)
     else:
-        legs, report_md, start_dt = solve_guided_variable(method, alt_ft, vs_fpm, descent_start_choice)
+        legs, report_md, start_dt = solve_guided_variable_se(method, alt_ft, vs_fpm, descent_start_choice)
 
     if legs is None:
         fig = go.Figure()
@@ -1846,11 +1889,12 @@ with gr.Blocks() as demo:
         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\n"
         f"**Straight mode:** Top-K polish (top-{TOPK_POLISH})\n"
-        f"**Variable mode:** beam search (width {VAR_BEAM_WIDTH}) for speed"
+        f"**Variable mode:** beam search (width {VAR_BEAM_WIDTH})\n"
+        f"**SE mode:** beam search with heading constrained to {VAR_SE_HEADING_MIN:.0f}–{VAR_SE_HEADING_MAX:.0f}° (avoids 190° SW)"
     )
 
     guided_mode = gr.Dropdown(
-        ["Straight heading", "Variable heading & speed"],
+        ["Straight heading", "Variable heading & speed", "Variable heading & speed (SE)"],
         value="Straight heading",
         label="Guided scenario",
     )