feat: heuristic fallbacks for Snow PoE (lognormal from snowfall mean) and Precip Type probs (wet-bulb from T/Td); expand cloud-layer candidates; add per-step wind rose small-multiples grid

app.py

@@ -134,8 +134,22 @@ def run_forecast(lat, lon, hours=24):
         else:
             src_url = get_latest_hourly_dataset_url()
         t_idx, prob_map = fetch_point_probabilities(src_url, lat, lon, hours=min(hours, 36))
+        if len(prob_map) == 0:
+            # Heuristic fallback from snowfall series (deterministic or estimate)
+            import pandas as _pd
+            x = _pd.to_datetime(df["time_utc"], utc=True, errors="coerce")
+            snow_series = None
+            if "snow_in" in df.columns:
+                snow_series = _pd.Series(df["snow_in"].astype(float).values, index=x)
+            elif "snow_est_in" in df.columns:
+                snow_series = _pd.Series(df["snow_est_in"].astype(float).values, index=x)
+            if snow_series is not None:
+                from nbm_client import estimate_snow_exceedance_from_series
+                thresholds = [0.1, 0.3, 0.5, 1.5, 2.0, 2.5, 4.0]
+                temp_k_vals = (df["temp_F"].astype(float).values - 32.0) * 5.0/9.0 + 273.15
+                prob_map = estimate_snow_exceedance_from_series(x, snow_series.values, temp_k_vals, thresholds)
         if len(prob_map) > 0:
-            snow_prob_fig = make_snow_prob_fig(t_idx, prob_map)
+            snow_prob_fig = make_snow_prob_fig(t_idx if len(t_idx)>0 else x, prob_map)
     except Exception as e:
         print(f"Probability fetch/plot error: {e}")
         snow_prob_fig = None
@@ -156,9 +170,12 @@ def run_forecast(lat, lon, hours=24):
         print(f"Cloud layers plot error: {e}")
 
     try:
-        # Precip type probs generally available on 1-hr and 3-hr; use active dataset for full coverage
+        # Precip type probs available on 1-hr and often on 3-hr; try fetch, else fallback heuristic
         ptype_url = dataset_url if hours <= 36 else get_latest_3hr_dataset_url()
         t_ptype, ptype = fetch_precip_type_probs(ptype_url, lat, lon, hours=hours)
+        if len(ptype) == 0:
+            from nbm_client import estimate_precip_type_probs_from_surface
+            t_ptype, ptype = estimate_precip_type_probs_from_surface(ptype_url, lat, lon, hours=min(hours, 36))
         if len(ptype) > 0:
             precip_type_fig = make_precip_type_fig(t_ptype, ptype)
     except Exception as e:
@@ -193,7 +210,8 @@ def run_forecast(lat, lon, hours=24):
             x = _pd.to_datetime(df["time_utc"], utc=True, errors="coerce")
             wdir = _pd.Series(df["wdir_deg"].astype(float).values, index=x)
             wspd = _pd.Series(df["wind_mph"].astype(float).values, index=x)
-            wind_rose_fig = make_wind_rose_fig(wdir, wspd)
+            # Render per-step roses as small multiples
+            wind_rose_fig = make_wind_rose_grid(x, wdir, wspd, step_hours=3.0 if hours>36 else 1.0)
     except Exception as e:
         print(f"Wind rose plot error: {e}")
 

nbm_client.py

@@ -421,7 +421,11 @@ def fetch_cloud_layers(
     lon_vals = ds["lon"].values
     ilat = _nearest_index(lat_vals, lat)
     ilon = _nearest_index(lon_vals, lon)
-    candidates = ["tcdcl195", "tcdcl196", "tcdcl197", "tcdchcll"]
+    # Include additional conventional names if present
+    candidates = [
+        "tcdcl195", "tcdcl196", "tcdcl197", "tcdchcll",
+        "tcdccll", "tcdcclm", "tcdcclh",  # low/mid/high conventional
+    ]
     present = [v for v in candidates if v in ds.variables]
     if not present:
         return pd.DatetimeIndex([]), {}
@@ -437,11 +441,11 @@ def fetch_cloud_layers(
             vals = np.clip(arr, 0, 100)
             # Label
             ln = str(ds[v].attrs.get("long_name", v))
-            if "high cloud" in ln.lower() or v == "tcdchcll":
+            if "high cloud" in ln.lower() or v in ("tcdchcll", "tcdcclh"):
                 name = "High Cloud (%)"
-            elif v.endswith("195"):
+            elif v.endswith("195") or v == "tcdccll":
                 name = "Layer 195 (%)"
-            elif v.endswith("196"):
+            elif v.endswith("196") or v == "tcdcclm":
                 name = "Layer 196 (%)"
             elif v.endswith("197"):
                 name = "Layer 197 (%)"
@@ -453,6 +457,91 @@ def fetch_cloud_layers(
     return t, out
 
 
+def _estimate_wetbulb_c(temp_k: np.ndarray, dpt_k: np.ndarray) -> np.ndarray:
+    """Approximate wet-bulb temperature in C from T and Td using Stull (2011) approximation."""
+    T = temp_k - 273.15
+    Td = dpt_k - 273.15
+    # relative humidity estimate
+    RH = 100.0 * np.clip(np.exp((17.625*Td)/(243.04+Td)) / np.exp((17.625*T)/(243.04+T)), 0.0, 1.2)
+    RH = np.clip(RH, 1.0, 100.0)
+    Tw = T*np.arctan(0.151977*(RH+8.313659)**0.5) + np.arctan(T+Td) - np.arctan(Td-1.676331) + 0.00391838*RH**1.5*np.arctan(0.023101*RH) - 4.686035
+    return Tw
+
+
+def estimate_precip_type_probs_from_surface(
+    ds_url: str, lat: float, lon: float, hours: int
+) -> Tuple[pd.DatetimeIndex, Dict[str, pd.Series]]:
+    """Heuristic precip type probabilities from surface variables (T, Td, precip).
+
+    This is a fallback when categorical ptype vars are absent. It uses wet-bulb temperature
+    thresholds to assign soft probabilities among Rain, Snow, Freezing Rain, Sleet.
+    """
+    ds = _open_ds(ds_url)
+    lat_vals = ds["lat"].values
+    lon_vals = ds["lon"].values
+    ilat = _nearest_index(lat_vals, lat)
+    ilon = _nearest_index(lon_vals, lon)
+    t_full = _to_datetime_index(ds["time"])  # type: ignore
+    step = _infer_step_hours(t_full)
+    n_req = int(np.ceil(max(1, float(hours)) / step))
+    n = min(len(t_full), n_req)
+    t = t_full[:n]
+    T = _mask_fill(ds["tmp2m"].isel(lat=ilat, lon=ilon, time=slice(0, n)).values)
+    Td = _mask_fill(ds["dpt2m"].isel(lat=ilat, lon=ilon, time=slice(0, n)).values)
+    Tw = _estimate_wetbulb_c(T, Td)
+    # Probabilities from Tw in degC using smooth logistic transitions
+    import numpy as _np
+    def sigmoid(x):
+        return 1.0 / (1.0 + _np.exp(-x))
+    # Snow prob high when Tw <= -1C, rain when Tw >= 1.5C, transitions in between
+    p_snow = sigmoid((-Tw - 0.5) / 0.8)  # shift/scale for smoothness
+    p_rain = sigmoid((Tw - 0.5) / 0.8)
+    # allocate remaining between sleet and freezing rain near 0C
+    mix = 1.0 - np.clip(p_snow + p_rain, 0, 1)
+    # split mix by T below/above 0C
+    p_fzra = mix * sigmoid((-Tw) / 0.7)  # colder side
+    p_sleet = np.clip(mix - p_fzra, 0, 1)
+    out = {
+        "Snow": pd.Series(np.round(100.0 * np.clip(p_snow, 0, 1), 1), index=t),
+        "Rain": pd.Series(np.round(100.0 * np.clip(p_rain, 0, 1), 1), index=t),
+        "Freezing Rain": pd.Series(np.round(100.0 * np.clip(p_fzra, 0, 1), 1), index=t),
+        "Sleet": pd.Series(np.round(100.0 * np.clip(p_sleet, 0, 1), 1), index=t),
+    }
+    return t, out
+
+
+def estimate_snow_exceedance_from_series(
+    time_index: pd.DatetimeIndex,
+    snowfall_in: np.ndarray,
+    temp_k: np.ndarray,
+    thresholds_in: List[float],
+) -> Dict[str, pd.Series]:
+    """Heuristic probability of exceedance for snowfall from mean +/- uncertainty.
+
+    Assumes lognormal uncertainty with coefficient of variation based on temperature.
+    """
+    import numpy as _np
+    S = np.asarray(snowfall_in, dtype=float)
+    T = np.asarray(temp_k, dtype=float)
+    # CV higher near freezing, lower when colder
+    Tc = T - 273.15
+    cv = np.clip(0.9 - 0.02 * (-(Tc - 0)), 0.4, 1.0)  # ~0.9 near 0C -> ~0.5 when much colder
+    # Avoid negative/NaN
+    m = np.clip(S, 0, None)
+    # Lognormal parameters from mean and cv
+    sigma = np.sqrt(np.log(1.0 + cv**2))
+    # Avoid zeros: add small epsilon
+    eps = 1e-6
+    mu = np.log(np.maximum(m, eps)) - 0.5 * sigma**2
+    from scipy.stats import lognorm
+    out: Dict[str, pd.Series] = {}
+    for thr in thresholds_in:
+        cdf = lognorm.cdf(thr, s=sigma, scale=np.exp(mu))
+        poe = 100.0 * (1.0 - cdf)
+        out[f">= {thr:g} in"] = pd.Series(np.round(poe, 1), index=time_index)
+    return out
+
+
 def fetch_precip_type_probs(
     dataset_url: str, lat: float, lon: float, hours: int = 24
 ) -> Tuple[pd.DatetimeIndex, Dict[str, pd.Series]]:

plot_utils.py

@@ -338,3 +338,54 @@ def make_wind_rose_fig(dir_deg: pd.Series, spd_mph: pd.Series) -> go.Figure:
         ),
     )
     return fig
+
+
+def make_wind_rose_grid(
+    times: pd.DatetimeIndex,
+    dir_deg: pd.Series,
+    spd_mph: pd.Series,
+    step_hours: float,
+    max_panels: int = 24,
+) -> go.Figure:
+    """Render small-multiples wind roses per native time step.
+
+    Caps at `max_panels` panels for readability.
+    """
+    import numpy as np
+    from plotly.subplots import make_subplots
+
+    n = len(times)
+    if n == 0:
+        return go.Figure()
+    panels = min(n, max_panels)
+    cols = min(6, panels)
+    rows = int(np.ceil(panels / cols))
+    fig = make_subplots(rows=rows, cols=cols, specs=[[{"type": "polar"}]*cols for _ in range(rows)], subplot_titles=[t.strftime("%b %d %HZ") for t in times[:panels]])
+    # Binning config reused
+    dir_bins = np.arange(-11.25, 360 + 22.5, 22.5)
+    dir_labels = (dir_bins[:-1] + dir_bins[1:]) / 2.0
+    speed_edges = [0, 5, 10, 20, 1e6]
+    speed_labels = ["0-5", "5-10", "10-20", ">20"]
+    colors = ["#d0f0fd", "#86c5da", "#2ca02c", "#d62728"]
+    import numpy as _np
+    for idx in range(panels):
+        d = float(dir_deg.iloc[idx]) if _np.isfinite(dir_deg.iloc[idx]) else _np.nan
+        s = float(spd_mph.iloc[idx]) if _np.isfinite(spd_mph.iloc[idx]) else _np.nan
+        # Build a rose with single observation -> show as counts
+        hist = _np.histogram([d % 360.0] if _np.isfinite(d) else [], bins=dir_bins)[0]
+        # Place into one of the speed bins
+        bin_idx = 0
+        for i in range(len(speed_edges)-1):
+            if speed_edges[i] <= s < speed_edges[i+1]:
+                bin_idx = i
+                break
+        r_counts = [hist if i == bin_idx else _np.zeros_like(hist) for i in range(4)]
+        r = (idx // cols) + 1
+        c = (idx % cols) + 1
+        for i in range(4):
+            fig.add_trace(
+                go.Barpolar(r=r_counts[i], theta=dir_labels, name=speed_labels[i], marker_color=colors[i], opacity=0.9, showlegend=(idx==0)),
+                row=r, col=c,
+            )
+    fig.update_layout(margin=dict(l=30, r=30, t=40, b=30))
+    return fig