feat: add cloud layers plot (tcdcl195/196/197,tcdchcll), precip type probabilities (Rain/Snow/FZRA/Sleet), and snow level + precip panel; show these when vars are present

app.py

@@ -10,6 +10,9 @@ from nbm_client import (
     fetch_point_probabilities,
     get_latest_hourly_dataset_url,
     get_latest_3hr_dataset_url,
+    fetch_cloud_layers,
+    fetch_precip_type_probs,
+    fetch_snow_level_kft,
 )
 from plot_utils import (
     make_temp_dew_wind_fig,
@@ -17,6 +20,9 @@ from plot_utils import (
     make_snow_prob_fig,
     make_snow_6h_accum_fig,
     make_window_snow_fig,
+    make_cloud_layers_fig,
+    make_precip_type_fig,
+    make_snow_level_fig,
 )
 
 
@@ -36,11 +42,26 @@ def run_forecast(lat, lon, hours=24):
     temp_wind_fig = None
     cloud_precip_fig = None
     snow_prob_fig = None
+    cloud_layers_fig = None
+    precip_type_fig = None
+    snow_level_fig = None
 
     def y(msg):
         print(msg, flush=True)
         elapsed = time.perf_counter() - t0
-        return gr.update(value=f"{msg} (elapsed {elapsed:.1f}s)"), table_df, temp_wind_fig, cloud_precip_fig, snow_prob_fig, None, None, None
+        return (
+            gr.update(value=f"{msg} (elapsed {elapsed:.1f}s)"),
+            table_df,
+            temp_wind_fig,
+            cloud_precip_fig,
+            snow_prob_fig,
+            None,
+            None,
+            None,
+            cloud_layers_fig,
+            precip_type_fig,
+            snow_level_fig,
+        )
 
     if lat is None or lon is None:
         yield y("Click map or enter lat/lon.")
@@ -101,6 +122,46 @@ def run_forecast(lat, lon, hours=24):
         print(f"Probability fetch/plot error: {e}")
         snow_prob_fig = None
 
+    # Cloud layers and precip type probabilities
+    try:
+        t_layers, layers = fetch_cloud_layers(dataset_url, lat, lon, hours=hours)
+        if len(layers) > 0:
+            import pandas as _pd
+            x = _pd.to_datetime(df["time_utc"], utc=True, errors="coerce")
+            total = _pd.Series(df["cloud_cover_pct"].astype(float).values, index=x) if "cloud_cover_pct" in df.columns else None
+            # preserve input order
+            layers_ordered = {k: layers[k] for k in layers}
+            cloud_layers_fig = make_cloud_layers_fig(t_layers, layers_ordered, total)
+    except Exception as e:
+        print(f"Cloud layers plot error: {e}")
+
+    try:
+        t_ptype, ptype = fetch_precip_type_probs(dataset_url, lat, lon, hours=hours)
+        if len(ptype) > 0:
+            precip_type_fig = make_precip_type_fig(t_ptype, ptype)
+    except Exception as e:
+        print(f"Precip type plot error: {e}")
+
+    # Snow level with precip overlay
+    try:
+        t_sl, snow_kft = fetch_snow_level_kft(dataset_url, lat, lon, hours=hours)
+        if snow_kft is not None and len(snow_kft) > 0:
+            import pandas as _pd
+            x = _pd.to_datetime(df["time_utc"], utc=True, errors="coerce")
+            # Compute 6h precip window from available precip
+            if "precip_in" in df.columns:
+                # estimate step
+                step_hours = 1.0
+                if len(x) > 1:
+                    step_hours = max(1.0, (x[1] - x[0]).total_seconds() / 3600.0)
+                w6 = max(1, int(round(6.0 / step_hours)))
+                p6 = _pd.Series(df["precip_in"].astype(float).values, index=x).rolling(window=w6, min_periods=1).sum()
+            else:
+                p6 = None
+            snow_level_fig = make_snow_level_fig(t_sl, snow_kft, p6)
+    except Exception as e:
+        print(f"Snow level plot error: {e}")
+
     # Deterministic snowfall derivations if available
     snow6_fig = None
     snow24_fig = None
@@ -141,7 +202,19 @@ def run_forecast(lat, lon, hours=24):
         f"{meta['lat']:.3f}, {meta['lon']:.3f} (grid: lat[{meta['ilat']}], lon[{meta['ilon']}])\n"
         f"Dataset: {dataset_url} | total time {time.perf_counter()-t0:.1f}s"
     )
-    yield gr.update(value=header), table_df, temp_wind_fig, cloud_precip_fig, snow_prob_fig, snow6_fig, snow24_fig, snow48_fig
+    yield (
+        gr.update(value=header),
+        table_df,
+        temp_wind_fig,
+        cloud_precip_fig,
+        snow_prob_fig,
+        snow6_fig,
+        snow24_fig,
+        snow48_fig,
+        cloud_layers_fig,
+        precip_type_fig,
+        snow_level_fig,
+    )
     return
 
 
@@ -226,22 +299,25 @@ with gr.Blocks(title="NBM Point Forecast (NOAA NOMADS)") as demo:
             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")
 
     # 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],
+        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],
     )
     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],
+        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],
     )
     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],
+        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],
     )
 
 

nbm_client.py

@@ -328,3 +328,121 @@ def fetch_point_probabilities(
             logger.warning(f"Skipping {v} due to read/convert error: {ex}")
 
     return t_index, out
+
+
+def _open_ds(dataset_url: str) -> xr.Dataset:
+    return xr.open_dataset(_to_dap2_url(dataset_url), engine="pydap", decode_cf=True)
+
+
+def fetch_cloud_layers(
+    dataset_url: str, lat: float, lon: float, hours: int = 24
+) -> Tuple[pd.DatetimeIndex, Dict[str, pd.Series]]:
+    """Return available cloud layer cover percentages as time series.
+
+    Looks for variables among: tcdcl195, tcdcl196, tcdcl197, tcdchcll.
+    Labels are derived from long_name attributes when present.
+    """
+    logger = logging.getLogger(__name__)
+    ds = _open_ds(dataset_url)
+    lat_vals = ds["lat"].values
+    lon_vals = ds["lon"].values
+    ilat = _nearest_index(lat_vals, lat)
+    ilon = _nearest_index(lon_vals, lon)
+    candidates = ["tcdcl195", "tcdcl196", "tcdcl197", "tcdchcll"]
+    present = [v for v in candidates if v in ds.variables]
+    if not present:
+        return pd.DatetimeIndex([]), {}
+    t_full = _to_datetime_index(ds["time"])
+    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]
+    out: Dict[str, pd.Series] = {}
+    for v in present:
+        try:
+            arr = _mask_fill(ds[v].isel(lat=ilat, lon=ilon, time=slice(0, n)).values)
+            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":
+                name = "High Cloud (%)"
+            elif v.endswith("195"):
+                name = "Layer 195 (%)"
+            elif v.endswith("196"):
+                name = "Layer 196 (%)"
+            elif v.endswith("197"):
+                name = "Layer 197 (%)"
+            else:
+                name = v
+            out[name] = pd.Series(np.round(vals.astype(float), 1), index=t)
+        except Exception as ex:
+            logger.warning(f"Skipping cloud layer {v}: {ex}")
+    return t, out
+
+
+def fetch_precip_type_probs(
+    dataset_url: str, lat: float, lon: float, hours: int = 24
+) -> Tuple[pd.DatetimeIndex, Dict[str, pd.Series]]:
+    """Return precipitation type probabilities (%): Rain, Snow, Freezing Rain, Sleet.
+
+    Uses variables ptype1to2sfc (Rain), ptype3to4sfc (Snow), ptype5to7sfc (Freezing Rain), ptype8to9sfc (Sleet).
+    """
+    ds = _open_ds(dataset_url)
+    lat_vals = ds["lat"].values
+    lon_vals = ds["lon"].values
+    ilat = _nearest_index(lat_vals, lat)
+    ilon = _nearest_index(lon_vals, lon)
+    mapping = {
+        "ptype1to2sfc": "Rain",
+        "ptype3to4sfc": "Snow",
+        "ptype5to7sfc": "Freezing Rain",
+        "ptype8to9sfc": "Sleet",
+    }
+    present = [k for k in mapping if k in ds.variables]
+    if not present:
+        return pd.DatetimeIndex([]), {}
+    t_full = _to_datetime_index(ds["time"])  # time is global
+    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]
+    out: Dict[str, pd.Series] = {}
+    for k in present:
+        vals = _mask_fill(ds[k].isel(lat=ilat, lon=ilon, time=slice(0, n)).values)
+        # Normalize 0..1 to percent when needed
+        mx = float(np.nanmax(vals)) if np.isfinite(vals).any() else 0.0
+        if mx <= 1.0:
+            vals = vals * 100.0
+        out[mapping[k]] = pd.Series(np.round(vals.astype(float), 1), index=t)
+    return t, out
+
+
+def fetch_snow_level_kft(
+    dataset_url: str, lat: float, lon: float, hours: int = 24
+) -> Tuple[pd.DatetimeIndex, Optional[pd.Series]]:
+    """Return snow level above mean sea level in kft if available (1-hr datasets typically).
+    Searches variable attributes for 'snow level'.
+    """
+    ds = _open_ds(dataset_url)
+    lat_vals = ds["lat"].values
+    lon_vals = ds["lon"].values
+    ilat = _nearest_index(lat_vals, lat)
+    ilon = _nearest_index(lon_vals, lon)
+    # find first var whose long_name mentions 'snow level'
+    candidate: Optional[str] = None
+    for v in ds.variables:
+        ln = str(ds[v].attrs.get("long_name", "")).lower()
+        if "snow level" in ln:
+            candidate = v
+            break
+    if candidate is None:
+        return pd.DatetimeIndex([]), None
+    t_full = _to_datetime_index(ds["time"])  # assume aligned
+    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]
+    vals_m = _mask_fill(ds[candidate].isel(lat=ilat, lon=ilon, time=slice(0, n)).values)
+    # convert meters to kft
+    kft = (vals_m / 0.3048) / 1000.0
+    return t, pd.Series(np.round(kft.astype(float), 2), index=t)

plot_utils.py

@@ -199,3 +199,92 @@ def make_window_snow_fig(x: pd.DatetimeIndex, snow_win: pd.Series, window_label:
         legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
     )
     return fig
+
+
+def make_cloud_layers_fig(
+    x: pd.DatetimeIndex,
+    layers: Dict[str, pd.Series],
+    total: pd.Series | None = None,
+) -> go.Figure:
+    fig = go.Figure()
+    palette = ["#c7c7c7", "#8c8c8c", "#525252", "#a0a0ff"]
+    # Plot each layer as filled area
+    for i, (name, series) in enumerate(layers.items()):
+        fig.add_trace(
+            go.Scatter(
+                x=x,
+                y=series.values,
+                name=name,
+                mode="lines",
+                line=dict(color=palette[i % len(palette)]),
+                fill="tozeroy",
+                opacity=0.4,
+            )
+        )
+    if total is not None:
+        fig.add_trace(
+            go.Scatter(
+                x=x,
+                y=total.values,
+                name="Total Cloud (%)",
+                mode="lines",
+                line=dict(color="#444444", width=2),
+            )
+        )
+    fig.update_layout(
+        margin=dict(l=40, r=20, t=30, b=40),
+        xaxis=dict(title="Time (UTC)"),
+        yaxis=dict(title="Cloud Cover (%)", range=[0, 100]),
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
+    )
+    return fig
+
+
+def make_precip_type_fig(x: pd.DatetimeIndex, probs: Dict[str, pd.Series]) -> go.Figure:
+    fig = go.Figure()
+    colors = {
+        "Rain": "#2ca02c",
+        "Freezing Rain": "#e377c2",
+        "Snow": "#1f77b4",
+        "Sleet": "#9467bd",
+    }
+    for name, s in probs.items():
+        fig.add_trace(
+            go.Scatter(x=x, y=s.values, name=name, mode="lines", line=dict(color=colors.get(name, None), width=2))
+        )
+    fig.update_layout(
+        margin=dict(l=40, r=20, t=30, b=40),
+        xaxis=dict(title="Time (UTC)"),
+        yaxis=dict(title="Precip Type Prob (%)", range=[0, 100]),
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
+    )
+    return fig
+
+
+def make_snow_level_fig(
+    x: pd.DatetimeIndex,
+    snow_level_kft: pd.Series,
+    precip_window_in: pd.Series | None = None,
+) -> go.Figure:
+    fig = go.Figure()
+    fig.add_trace(
+        go.Scatter(x=x, y=snow_level_kft.values, name="Snow level (kft)", mode="lines", line=dict(color="#1f77b4", width=3))
+    )
+    if precip_window_in is not None:
+        fig.add_trace(
+            go.Bar(
+                x=x,
+                y=precip_window_in.values,
+                name="Precip (in)",
+                marker_color="rgba(0,128,0,0.35)",
+                yaxis="y2",
+            )
+        )
+    fig.update_layout(
+        margin=dict(l=40, r=40, t=30, b=40),
+        xaxis=dict(title="Time (UTC)"),
+        yaxis=dict(title="Snow level (kft)", rangemode="tozero"),
+        yaxis2=dict(title="Precip (in)", overlaying="y", side="right", rangemode="tozero"),
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
+    )
+    return fig