Add NBM Viewer (CSV) emulation: client + percentiles + PoE; integrate new tab

.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+__pycache__/
+*.pyc
+research/

README.md

@@ -19,6 +19,11 @@ How it works
 - Retrieval: It opens the dataset via xarray+pydap and extracts a time series at the nearest grid point to your selected lat/lon.
 - Output: A 24-hour table (configurable) showing temperature (F), dewpoint (F), wind/gust (mph), total cloud cover (%), and 1-hour precipitation (inches). Times are UTC.
 
+NBM Viewer (CSV) emulation
+- A separate tab “NBM Viewer (CSV)” uses the official NBM 1D Viewer’s public archive endpoints to fetch a per-location CSV (e.g., Bridgers.csv) for a chosen Year/Month/Day/Version/Hour.
+- It renders Max/Min Temperature percentiles with shaded 10–90% whiskers and 25–75% box bands, plus deterministic TMAX/TMIN markers, matching the NBM Viewer’s style.
+- It also computes a Probability-of-Exceedance time series for a chosen field, operator (>= or <=), and threshold (e.g., Tmax >= 40°F), using either ensemble std-dev where present or linear interpolation between available percentiles (mirroring the Viewer’s logic).
+
 Limitations
 - Current dataset selection targets the hourly CONUS grid (approximately 19–57N, 138–59W). Points near or outside this domain will snap to the nearest grid edge. Alaska is generally outside the CONUS hourly grid; Hawaii is mostly covered.
 - NOMADS availability varies during updates; if a run is in transition, try again in a few minutes.

app.py

@@ -27,6 +27,20 @@ from plot_utils import (
     make_wind_rose_fig,
     make_wind_rose_grid,
 )
+from nbm_viewer_client import (
+    list_years,
+    list_months,
+    list_days,
+    list_versions,
+    list_hours,
+    list_locations,
+    fetch_location_csv,
+)
+from nbm_viewer_emulation import (
+    make_temp_maxmin_percentile_figure,
+    prob_exceed_series,
+    make_prob_exceed_figure,
+)
 
 
 INTRO = (
@@ -280,11 +294,13 @@ with gr.Blocks(title="NBM Point Forecast (NOAA NOMADS)") as demo:
     gr.Markdown("# NBM Point Forecast (NOAA NOMADS)")
     gr.Markdown(INTRO)
 
-    with gr.Row():
-        with gr.Column(scale=3):
-            # Leaflet map embedded via HTML; clicks update lat/lon inputs below.
-            map_html = gr.HTML(
-                value="""
+    with gr.Tabs():
+        with gr.TabItem("NOMADS (1-hr/3-hr)"):
+            with gr.Row():
+                with gr.Column(scale=3):
+                    # Leaflet map embedded via HTML; clicks update lat/lon inputs below.
+                    map_html = gr.HTML(
+                        value="""
 <div id=\"leaflet_map\" style=\"height:520px;border:1px solid #ccc;\"></div>
 <link rel=\"stylesheet\" href=\"https://unpkg.com/leaflet@1.9.4/dist/leaflet.css\" crossorigin=\"\" />
 <script src=\"https://unpkg.com/leaflet@1.9.4/dist/leaflet.js\" crossorigin=\"\"></script>
@@ -317,67 +333,162 @@ with gr.Blocks(title="NBM Point Forecast (NOAA NOMADS)") as demo:
 </script>
 """,
                 label="Map (click to set point)",
-            )
+                    )
 
-            lat_in = gr.Number(label="Latitude", value=None, elem_id="lat_input")
-            lon_in = gr.Number(label="Longitude", value=None, elem_id="lon_input")
+                    lat_in = gr.Number(label="Latitude", value=None, elem_id="lat_input")
+                    lon_in = gr.Number(label="Longitude", value=None, elem_id="lon_input")
 
-            hours = gr.Slider(
-                minimum=6,
-                maximum=240,
-                value=24,
-                step=3,
-                label="Hours to fetch (1-hr <=36h, 3-hr beyond)",
-            )
-            btn = gr.Button("Fetch NBM Forecast")
+                    hours = gr.Slider(
+                        minimum=6,
+                        maximum=240,
+                        value=24,
+                        step=3,
+                        label="Hours to fetch (1-hr <=36h, 3-hr beyond)",
+                    )
+                    btn = gr.Button("Fetch NBM Forecast")
+
+                with gr.Column(scale=5):
+                    status = gr.Textbox(
+                        label="Status",
+                        value="Ready",
+                        interactive=False,
+                    )
+                    table = gr.Dataframe(
+                        headers=[
+                            "time_utc",
+                            "temp_F",
+                            "dewpoint_F",
+                            "wind_mph",
+                            "gust_mph",
+                            "cloud_cover_pct",
+                            "precip_in",
+                        ],
+                        label="NBM hourly forecast",
+                        wrap=True,
+                        row_count=(0, "dynamic"),
+                    )
+                    temp_wind_plot = gr.Plot(label="Temp/Dewpoint/Wind")
+                    cloud_precip_plot = gr.Plot(label="Clouds and Precip")
+                    snow_prob_plot = gr.Plot(label="Snow Probabilities (exceedance)")
+                    snow6_plot = gr.Plot(label="6 hr Snow + Accum")
+                    snow24_plot = gr.Plot(label="24 hr Snowfall")
+                    snow48_plot = gr.Plot(label="48 hr Snowfall")
+                    cloud_layers_plot = gr.Plot(label="Cloud Layers (%)")
+                    precip_type_plot = gr.Plot(label="Precip Type Probabilities")
+                    snow_level_plot = gr.Plot(label="Snow Level + Precip")
+                    wind_rose_plot = gr.Plot(label="Wind Rose (10 m)")
 
-        with gr.Column(scale=5):
-            status = gr.Textbox(
-                label="Status",
-                value="Ready",
-                interactive=False,
+            # Triggers for NOMADS tab
+            btn.click(
+                run_forecast,
+                inputs=[lat_in, lon_in, hours],
+                outputs=[status, table, temp_wind_plot, cloud_precip_plot, snow_prob_plot, snow6_plot, snow24_plot, snow48_plot, cloud_layers_plot, precip_type_plot, snow_level_plot, wind_rose_plot],
             )
-            table = gr.Dataframe(
-                headers=[
-                    "time_utc",
-                    "temp_F",
-                    "dewpoint_F",
-                    "wind_mph",
-                    "gust_mph",
-                    "cloud_cover_pct",
-                    "precip_in",
-                ],
-                label="NBM hourly forecast",
-                wrap=True,
-                row_count=(0, "dynamic"),
+            lat_in.change(
+                run_forecast,
+                inputs=[lat_in, lon_in, hours],
+                outputs=[status, table, temp_wind_plot, cloud_precip_plot, snow_prob_plot, snow6_plot, snow24_plot, snow48_plot, cloud_layers_plot, precip_type_plot, snow_level_plot, wind_rose_plot],
             )
-            temp_wind_plot = gr.Plot(label="Temp/Dewpoint/Wind")
-            cloud_precip_plot = gr.Plot(label="Clouds and Precip")
-            snow_prob_plot = gr.Plot(label="Snow Probabilities (exceedance)")
-            snow6_plot = gr.Plot(label="6 hr Snow + Accum")
-            snow24_plot = gr.Plot(label="24 hr Snowfall")
-            snow48_plot = gr.Plot(label="48 hr Snowfall")
-            cloud_layers_plot = gr.Plot(label="Cloud Layers (%)")
-            precip_type_plot = gr.Plot(label="Precip Type Probabilities")
-            snow_level_plot = gr.Plot(label="Snow Level + Precip")
-            wind_rose_plot = gr.Plot(label="Wind Rose (10 m)")
-
-    # Trigger when clicking Fetch, or when lat/lon are edited (e.g., via map)
-    btn.click(
-        run_forecast,
-        inputs=[lat_in, lon_in, hours],
-        outputs=[status, table, temp_wind_plot, cloud_precip_plot, snow_prob_plot, snow6_plot, snow24_plot, snow48_plot, cloud_layers_plot, precip_type_plot, snow_level_plot, wind_rose_plot],
-    )
-    lat_in.change(
-        run_forecast,
-        inputs=[lat_in, lon_in, hours],
-        outputs=[status, table, temp_wind_plot, cloud_precip_plot, snow_prob_plot, snow6_plot, snow24_plot, snow48_plot, cloud_layers_plot, precip_type_plot, snow_level_plot, wind_rose_plot],
-    )
-    lon_in.change(
-        run_forecast,
-        inputs=[lat_in, lon_in, hours],
-        outputs=[status, table, temp_wind_plot, cloud_precip_plot, snow_prob_plot, snow6_plot, snow24_plot, snow48_plot, cloud_layers_plot, precip_type_plot, snow_level_plot, wind_rose_plot],
-    )
+            lon_in.change(
+                run_forecast,
+                inputs=[lat_in, lon_in, hours],
+                outputs=[status, table, temp_wind_plot, cloud_precip_plot, snow_prob_plot, snow6_plot, snow24_plot, snow48_plot, cloud_layers_plot, precip_type_plot, snow_level_plot, wind_rose_plot],
+            )
+
+        with gr.TabItem("NBM Viewer (CSV)"):
+            gr.Markdown("Emulate the NBM 1D Viewer using its CSV archive: box/whisker and probability charts.")
+            with gr.Row():
+                with gr.Column(scale=3):
+                    year = gr.Dropdown(label="Year", choices=[], value=None)
+                    month = gr.Dropdown(label="Month", choices=[], value=None)
+                    day = gr.Dropdown(label="Day", choices=[], value=None)
+                    version = gr.Dropdown(label="Version", choices=[], value=None)
+                    hour = gr.Dropdown(label="Hour (UTC)", choices=[], value=None)
+                    location = gr.Dropdown(label="Location (NBM Viewer)", choices=[], value=None)
+                    load_btn = gr.Button("Load Viewer CSV")
+                with gr.Column(scale=5):
+                    viewer_status = gr.Textbox(label="Status", value="Ready", interactive=False)
+                    maxmin_fig = gr.Plot(label="Max/Min T Percentiles")
+                    with gr.Row():
+                        prob_field = gr.Textbox(label="Prob Field (e.g., TMP_Max_2 m above ground)", value="TMP_Max_2 m above ground")
+                        prob_op = gr.Radio(label="Operator", choices=[">=","<="], value=">=")
+                        prob_value = gr.Number(label="Threshold (F)", value=40)
+                        make_prob = gr.Button("Compute Probability")
+                    prob_fig = gr.Plot(label="Probability of Exceedance")
+
+            # Populate cascading date selectors
+            def _init_years():
+                try:
+                    ys = list_years()
+                except Exception as e:
+                    ys = []
+                return gr.update(choices=ys, value=(ys[-1] if ys else None)), "Years loaded." if ys else "No years."
+
+            def _on_year(y):
+                ms = list_months(y) if y else []
+                return gr.update(choices=ms, value=(ms[-1] if ms else None))
+
+            def _on_month(y, m):
+                ds = list_days(y, m) if (y and m) else []
+                return gr.update(choices=ds, value=(ds[-1] if ds else None))
+
+            def _on_day(y, m, d):
+                vs = list_versions(y, m, d) if (y and m and d) else []
+                return gr.update(choices=vs, value=(vs[0] if vs else None))
+
+            def _on_version(y, m, d, v):
+                hs = list_hours(y, m, d, v) if (y and m and d and v) else []
+                # Use latest available hour by default
+                return gr.update(choices=hs, value=(hs[-1] if hs else None))
+
+            def _on_hour(y, m, d, v, h):
+                locs = list_locations(y, m, d, v, h) if (y and m and d and v and h) else []
+                # Keep list manageable
+                # Preselect a common mountainous example if present
+                sel = None
+                for cand in ("Bridgers", "Bridger", "Alta", "Aspen Highland Peak"):
+                    if cand in locs:
+                        sel = cand
+                        break
+                if not sel and locs:
+                    sel = locs[0]
+                return gr.update(choices=locs, value=sel)
+
+            def _load_csv(y, m, d, v, h, loc):
+                try:
+                    df = fetch_location_csv(y, m, d, v, h, loc)
+                except Exception as e:
+                    return (f"Failed to load CSV: {e}", None)
+                try:
+                    fig = make_temp_maxmin_percentile_figure(df)
+                    return (f"Loaded {loc}.csv at {y}/{m}/{d} {v} {h}Z", fig, df)
+                except Exception as e:
+                    return (f"Loaded CSV but plot failed: {e}", None, df)
+
+            def _make_prob(df: pd.DataFrame, field: str, op: str, val: float):
+                if df is None or len(df) == 0:
+                    return "Load CSV first.", None
+                poe = prob_exceed_series(df, field=field, operator=("<=" if op == "<=" else ">="), threshold_value=float(val), units='F')
+                fig = make_prob_exceed_figure(poe.index, poe, title=f"Prob {field} {op} {val}")
+                return "OK", fig
+
+            yr_init, msg = _init_years()
+            year.update(**yr_init)
+            viewer_status.value = msg
+
+            year.change(_on_year, inputs=[year], outputs=[month])
+            month.change(_on_month, inputs=[year, month], outputs=[day])
+            day.change(_on_day, inputs=[year, month, day], outputs=[version])
+            version.change(_on_version, inputs=[year, month, day, version], outputs=[hour])
+            hour.change(_on_hour, inputs=[year, month, day, version, hour], outputs=[location])
+
+            csv_state = gr.State(value=None)
+            def _load_and_store(y, m, d, v, h, loc):
+                status, fig, df = _load_csv(y, m, d, v, h, loc)
+                return status, fig, df
+
+            load_btn.click(_load_and_store, inputs=[year, month, day, version, hour, location], outputs=[viewer_status, maxmin_fig, csv_state])
+            make_prob.click(_make_prob, inputs=[csv_state, prob_field, prob_op, prob_value], outputs=[viewer_status, prob_fig])
 
 
 if __name__ == "__main__":

nbm_viewer_client.py

@@ -0,0 +1,75 @@
+import re
+from dataclasses import dataclass
+from typing import Dict, List, Tuple, Optional
+
+import pandas as pd
+import requests
+
+
+BASE_VIEWER = "https://apps.gsl.noaa.gov/nbmviewer"
+
+
+def _get_json(url: str):
+    r = requests.get(url, timeout=20)
+    r.raise_for_status()
+    return r.json()
+
+
+def list_years() -> List[str]:
+    return _get_json(f"{BASE_VIEWER}/getdates?prefix=/")
+
+
+def list_months(year: str) -> List[str]:
+    return _get_json(f"{BASE_VIEWER}/getdates?prefix=/{year}")
+
+
+def list_days(year: str, month: str) -> List[str]:
+    return _get_json(f"{BASE_VIEWER}/getdates?prefix=/{year}/{month}")
+
+
+def list_versions(year: str, month: str, day: str) -> List[str]:
+    return _get_json(f"{BASE_VIEWER}/getdates?prefix=/{year}/{month}/{day}")
+
+
+def list_hours(year: str, month: str, day: str, version: str) -> List[str]:
+    return _get_json(f"{BASE_VIEWER}/getdates?prefix=/{year}/{month}/{day}/{version}")
+
+
+def list_locations(year: str, month: str, day: str, version: str, hour: str) -> List[str]:
+    # Returns a list of csv filenames; strip .csv before returning
+    arr = _get_json(f"{BASE_VIEWER}/getdates?prefix=/{year}/{month}/{day}/{version}/{hour}")
+    arr = [x for x in arr if x.endswith('.csv') and not x.strip().startswith('.')]
+    return [x[:-4] for x in arr]
+
+
+def fetch_location_csv(year: str, month: str, day: str, version: str, hour: str, location: str) -> pd.DataFrame:
+    url = f"{BASE_VIEWER}/data/archive/{year}/{month}/{day}/{version}/{hour}/{location}.csv"
+    df = pd.read_csv(url)
+    # Ensure time index
+    if 'ValidTime' in df.columns:
+        # strings like YYYYMMDDHH
+        t = pd.to_datetime(df['ValidTime'].astype(str), format='%Y%m%d%H', utc=True, errors='coerce')
+        df.insert(0, 'time_utc', t)
+    return df
+
+
+def available_percentiles(df: pd.DataFrame, base_field: str) -> List[int]:
+    # Detect columns like "<base>_10% level"
+    patt = re.compile(re.escape(base_field) + r"_(\d+)% level$")
+    ps: List[int] = []
+    for c in df.columns:
+        m = patt.search(c)
+        if m:
+            try:
+                ps.append(int(m.group(1)))
+            except Exception:
+                pass
+    return sorted(list(set(ps)))
+
+
+def get_series(df: pd.DataFrame, col: str) -> Optional[pd.Series]:
+    if col in df.columns:
+        return pd.Series(df[col].values, index=pd.DatetimeIndex(df['time_utc']))
+    return None
+
+

nbm_viewer_emulation.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import math
+import re
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+from scipy.stats import norm
+
+from nbm_viewer_client import available_percentiles, get_series
+
+
+def k_to_f(x: pd.Series | np.ndarray) -> pd.Series:
+    v = pd.Series(x, copy=False).astype(float)
+    return v * 9.0 / 5.0 - 459.67
+
+
+def mps_to_mph(x: pd.Series | np.ndarray) -> pd.Series:
+    return pd.Series(x, copy=False).astype(float) * 2.23693629
+
+
+def mm_to_in(x: pd.Series | np.ndarray) -> pd.Series:
+    return pd.Series(x, copy=False).astype(float) / 25.4
+
+
+def make_temp_maxmin_percentile_figure(
+    df: pd.DataFrame,
+    whiskers: Tuple[int, int] = (10, 90),
+    box: Tuple[int, int] = (25, 75),
+) -> go.Figure:
+    """Emulate the NBM Viewer Max/Min temperature percentile panel.
+
+    - Uses TMP_Max_2 m above ground and TMP_Min_2 m above ground percentiles
+    - Overlays deterministic TMAX12hr and TMIN12hr circles
+    - Default whiskers=10/90, box=25/75
+    """
+    t = pd.DatetimeIndex(df['time_utc'])
+    fig = go.Figure()
+
+    def add_field(field: str, color: str, det_field: str, show_legend_prefix: str):
+        p_avail = available_percentiles(df, field)
+        if not p_avail:
+            return
+        p_lo_w, p_hi_w = whiskers
+        p_lo_b, p_hi_b = box
+        lo_w = get_series(df, f"{field}_{p_lo_w}% level")
+        hi_w = get_series(df, f"{field}_{p_hi_w}% level")
+        lo_b = get_series(df, f"{field}_{p_lo_b}% level")
+        hi_b = get_series(df, f"{field}_{p_hi_b}% level")
+        p50  = get_series(df, f"{field}_50% level")
+        # Convert K->F
+        if lo_w is not None and hi_w is not None:
+            fig.add_trace(go.Scatter(x=t, y=k_to_f(hi_w), line=dict(color=color, width=0), showlegend=False))
+            fig.add_trace(go.Scatter(x=t, y=k_to_f(lo_w), line=dict(color=color, width=0), fill='tonexty', name=f"{show_legend_prefix} {p_lo_w}-{p_hi_w}%", opacity=0.15))
+        if lo_b is not None and hi_b is not None:
+            fig.add_trace(go.Scatter(x=t, y=k_to_f(hi_b), line=dict(color=color, width=1, dash='dot'), showlegend=False))
+            fig.add_trace(go.Scatter(x=t, y=k_to_f(lo_b), line=dict(color=color, width=1, dash='dot'), fill='tonexty', name=f"{show_legend_prefix} {p_lo_b}-{p_hi_b}%", opacity=0.25))
+        if p50 is not None:
+            fig.add_trace(go.Scatter(x=t, y=k_to_f(p50), name=f"{show_legend_prefix} 50%", mode='lines', line=dict(color=color, width=3, shape='hv')))
+        det = get_series(df, det_field)
+        if det is not None:
+            fig.add_trace(go.Scatter(x=t, y=k_to_f(det), name=f"{show_legend_prefix} Deterministic", mode='markers', marker=dict(size=4, color=color)))
+
+    add_field("TMP_Max_2 m above ground", color="rgba(255,59,58,1.0)", det_field="TMAX12hr_2 m above ground", show_legend_prefix="Max T")
+    add_field("TMP_Min_2 m above ground", color="rgba(115,197,243,1.0)", det_field="TMIN12hr_2 m above ground", show_legend_prefix="Min T")
+
+    fig.update_layout(
+        margin=dict(l=40, r=40, t=30, b=40),
+        xaxis=dict(title="Time (UTC)"),
+        yaxis=dict(title="Temperature (F)", rangemode="tozero"),
+        legend=dict(orientation='h', yanchor='bottom', y=1.02, xanchor='right', x=1),
+    )
+    return fig
+
+
+def _std_prob_exceed(mean: float, std: float, threshold: float, operator: str) -> float:
+    if not math.isfinite(mean) or not math.isfinite(std) or std <= 0:
+        return float('nan')
+    z = (threshold - mean) / std
+    c = norm.cdf(z)
+    return 100.0 * (c if operator == '<=' else (1.0 - c))
+
+
+def _interp_percentile_for_threshold(values: List[Tuple[int, float]], threshold: float, operator: str) -> float:
+    """Mirror the viewer's linear interpolation between percentile points to find P(X <= thr).
+    values: list of (percentile, value) pairs sorted by percentile.
+    Returns percentile (0..100)."""
+    if not values:
+        return float('nan')
+    vals = sorted(values, key=lambda x: x[0])
+    ps = [p for p, _ in vals]
+    xs = [x for _, x in vals]
+    # Handle monotonicity quirks by enforcing nondecreasing sequence (as in JS fix)
+    last = xs[0]
+    inc = None
+    for i in range(1, len(xs)):
+        if inc is None:
+            if xs[i] > last:
+                inc = True
+            elif xs[i] < last:
+                inc = False
+        if inc is True and xs[i] < last:
+            xs[i] = last
+        if inc is False and xs[i] > last:
+            xs[i] = last
+        last = xs[i]
+
+    # If threshold below min, percentile near first two
+    if threshold <= xs[0]:
+        p = ps[0]
+    elif threshold >= xs[-1]:
+        p = ps[-1]
+    else:
+        # Find bracketing segment and linearly interpolate in x between percentiles
+        p = ps[-1]
+        for i in range(len(xs) - 1):
+            x0, x1 = xs[i], xs[i + 1]
+            if x0 <= threshold <= x1 or x1 <= threshold <= x0:
+                # Line in percentile-x space: (p, x)
+                p0, p1 = ps[i], ps[i + 1]
+                if x1 == x0:
+                    p = p1
+                else:
+                    frac = (threshold - x0) / (x1 - x0)
+                    p = p0 + frac * (p1 - p0)
+                break
+    # Return probability of exceed/under
+    return p if operator == '<=' else (100.0 - p)
+
+
+def prob_exceed_series(
+    df: pd.DataFrame,
+    field: str,
+    operator: str,
+    threshold_value: float,
+    units: str = 'auto',  # 'K','F','mps','mph','mm','in','%' or 'auto'
+) -> pd.Series:
+    """Compute probability of exceedance like the viewer.
+
+    If a std-dev column exists, use Gaussian with mean/std.
+    Otherwise, interpolate among available percentiles.
+    """
+    idx = pd.DatetimeIndex(df['time_utc'])
+    # Unit normalization
+    thr = threshold_value
+    # Temperature fields use Kelvin in CSV
+    if 'TMP_' in field or field.endswith('2 m above ground') or field.endswith('_ level'):
+        # Heuristic: convert F->K if range suggests F
+        if units in ('auto', 'F'):
+            if threshold_value > 180:  # it's almost certainly F
+                thr = (threshold_value + 459.67) * 5.0 / 9.0
+            else:
+                # If user passed C or K, do nothing for now
+                pass
+        elif units == 'F':
+            thr = (threshold_value + 459.67) * 5.0 / 9.0
+
+    out = []
+    # Use std-dev if present (ens std dev)
+    mean_col = None
+    std_col = None
+
+    # Common std-dev naming
+    if f"{field}_ens std dev" in df.columns:
+        std_col = f"{field}_ens std dev"
+    if f"{field}_ens mean" in df.columns:
+        mean_col = f"{field}_ens mean"
+    elif f"{field}" in df.columns and std_col:
+        mean_col = field
+
+    if mean_col and std_col:
+        m = df[mean_col].astype(float).values
+        s = df[std_col].astype(float).values
+        for i in range(len(idx)):
+            out.append(_std_prob_exceed(m[i], s[i], thr, operator))
+        return pd.Series(np.asarray(out, dtype=float), index=idx)
+
+    # Else interpolate in percentiles
+    ps = available_percentiles(df, field)
+    if len(ps) < 2:
+        return pd.Series(np.full(len(idx), np.nan), index=idx)
+    # Collect the series for each percentile
+    series_map: Dict[int, pd.Series] = {}
+    for p in ps:
+        s = get_series(df, f"{field}_{p}% level")
+        if s is not None:
+            series_map[p] = s.astype(float)
+    ps_sorted = sorted(series_map.keys())
+    for i, t in enumerate(idx):
+        vals: List[Tuple[int, float]] = []
+        for p in ps_sorted:
+            try:
+                val = float(series_map[p].loc[t])
+            except Exception:
+                val = float('nan')
+            if math.isfinite(val):
+                vals.append((p, val))
+        out.append(_interp_percentile_for_threshold(vals, thr, operator))
+    return pd.Series(np.asarray(out, dtype=float), index=idx)
+
+
+def make_prob_exceed_figure(
+    idx: pd.DatetimeIndex, poe: pd.Series, title: Optional[str] = None
+) -> go.Figure:
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=idx, y=poe.values, mode='lines', line=dict(width=4)))
+    fig.update_layout(
+        margin=dict(l=40, r=40, t=30, b=40),
+        xaxis=dict(title="Time (UTC)"),
+        yaxis=dict(title="Prob. Exceedance (%)", range=[0, 100]),
+        title=title or None,
+    )
+    return fig
+
+