Configurable showcases

config/interpolators-ich1.yaml

@@ -55,6 +55,22 @@ stratification:
     - alpensuedseite
   root: /scratch/mch/bhendj/regions/Prognoseregionen_LV95_20220517
 
+showcase:
+  params:
+    - T_2M
+    - SP_10M
+    - TOT_PREC
+  meteograms: false
+  animations: true
+  domains:
+    - europe
+    - switzerland
+    - name: alpine_arc
+      extent: [3.0, 17.0, 43.5, 48.5]
+      projection: orthographic
+
+  stations: [JUN] #, COV, GOR, WFJ, SAE, SAM, DAV, ZER, ANT, VSBAS, BRT, LTB, GOS, CEV, BIA]
+
 locations:
   output_root: output/
 

src/data_input/__init__.py

@@ -118,11 +118,14 @@ def load_fct_data_from_grib(
             ds[var] = da.rename({"z": da.attrs["vcoord_type"]})
     ds = xr.merge([ds[p].rename(p) for p in ds], compat="no_conflicts")
     lead_times = np.array(steps, dtype="timedelta64[h]")
-    # Restrict to the requested lead times so that the TOT_PREC disaggregation
+    # Reindex to the requested lead times so that the TOT_PREC disaggregation
     # below operates on the correct step interval even if the GRIB contains
     # extra (e.g. hourly) steps beyond those requested — e.g. when consuming
     # output from an interpolator emulator or a baseline with sub-step output.
-    ds = ds.sel(lead_time=lead_times)
+    # reindex (rather than sel) fills missing steps with NaN instead of raising
+    # KeyError — needed because accumulated fields like TOT_PREC are absent at
+    # step 0 in the GRIB, and the NaN-fill logic below handles that case.
+    ds = ds.reindex(lead_time=lead_times)
     if "TOT_PREC" in ds.data_vars:
         ## Disaggregate TOT_PREC from cumulative-from-start (expected when the
         ## accumulate_from_start_of_forecast post-processor is enabled in

src/evalml/config.py

@@ -208,6 +208,52 @@ class BaselineItem(BaseModel):
     baseline: BaselineConfig
 
 
+class RegionConfig(BaseModel):
+    """A custom map region defined by name, extent, and projection."""
+
+    name: str = Field(..., description="Name for the custom region (used as wildcard).")
+    extent: List[float] | None = Field(
+        None,
+        description="Geographic extent as [lon_min, lon_max, lat_min, lat_max] in PlateCarree coordinates. None means full globe.",
+    )
+    projection: str = Field(
+        "orthographic",
+        description="Projection name (must be a key in plotting._PROJECTIONS, e.g. 'orthographic').",
+    )
+
+    model_config = {"extra": "forbid"}
+
+
+class ShowcaseConfig(BaseModel):
+    """Configuration for the showcase workflow."""
+
+    meteograms: bool = Field(
+        default=True,
+        description="Whether to generate meteograms (time series plots at stations).",
+    )
+    animations: bool = Field(
+        default=True,
+        description="Whether to generate forecast animations (GIFs per param and region).",
+    )
+    params: List[str] = Field(
+        default=["T_2M", "SP_10M"],
+        description="List of parameters to generate animations and meteograms for.",
+    )
+    stations: List[str] = Field(
+        default=["GVE", "KLO", "LUG"],
+        description="List of PeakWeather station IDs to generate meteograms for.",
+    )
+    domains: List[str | RegionConfig] = Field(
+        default=["globe", "europe", "switzerland"],
+        description=(
+            "Domains to generate animations for. Each entry is either a named domain "
+            "(e.g. 'globe', 'europe', 'switzerland') defined in plotting.DOMAINS, "
+            "or a custom domain dict with 'name', optional 'extent' "
+            "[lon_min, lon_max, lat_min, lat_max], and optional 'projection'."
+        ),
+    )
+
+
 class Locations(BaseModel):
     """Locations of data and services used in the workflow."""
 
@@ -318,6 +364,10 @@ class ConfigModel(BaseModel):
     stratification: Stratification
     locations: Locations
     profile: Profile
+    showcase: ShowcaseConfig = Field(
+        default_factory=ShowcaseConfig,
+        description="Settings for the showcase workflow.",
+    )
 
     model_config = {
         "extra": "forbid",  # fail on misspelled keys

src/plotting/__init__.py

@@ -20,6 +20,15 @@
 
 # Mapping of region names to their geographic extent and projection
 # extent [lon_min, lon_max, lat_min, lat_max] in PlateCarree coordinates
+def get_projection(name: str) -> "ccrs.Projection":
+    """Look up a projection by name."""
+    if name not in _PROJECTIONS:
+        raise ValueError(
+            f"Unknown projection {name!r}. Available: {list(_PROJECTIONS)}"
+        )
+    return _PROJECTIONS[name]
+
+
 DOMAINS = {
     "globe": {
         "extent": None,  # full globe view

src/plotting/compat.py

@@ -18,8 +18,15 @@ def load_state_from_grib(
     fds = data_source.FileDataSource(datafiles=[str(file)])
     ds = grib_decoder.load(fds, {"param": paramlist})
     state = {}
-    lats = ds[paramlist[0]].lat.data.flatten()
-    lons = ds[paramlist[0]].lon.data.flatten()
+    ref_param = next((p for p in (paramlist or []) if p in ds), None)
+    if ref_param is None:
+        raise ValueError(
+            f"None of the requested params {paramlist} found in {file}. "
+            "The GRIB file may not contain these fields at this lead time "
+            "(e.g. accumulated fields like TOT_PREC are undefined at step 0)."
+        )
+    lats = ds[ref_param].lat.data.flatten()
+    lons = ds[ref_param].lon.data.flatten()
     state["forecast_reference_time"] = reftime
     state["valid_time"] = reftime + pd.to_timedelta(lead_time_hours, unit="h")
     state["longitudes"] = lons

workflow/Snakefile

@@ -138,21 +138,29 @@ rule experiment_all:
 rule showcase_all:
     """Target rule for showcase workflow."""
     input:
-        expand(
-            rules.make_forecast_animation.output,
-            init_time=[t.strftime("%Y%m%d%H%M") for t in REFTIMES],
-            run_id=CANDIDATES,
-            param=["T_2M", "SP_10M", "TOT_PREC"],
-            region=["globe", "europe", "switzerland"],
-            showcase=EXPERIMENT_NAME,
+        (
+            expand(
+                rules.make_forecast_animation.output,
+                init_time=[t.strftime("%Y%m%d%H%M") for t in REFTIMES],
+                run_id=CANDIDATES,
+                param=SHOWCASE_PARAMS,
+                region=list(SHOWCASE_REGIONS.keys()),
+                showcase=EXPERIMENT_NAME,
+            )
+            if config["showcase"]["animations"]
+            else []
         ),
-        expand(
-            rules.plot_meteogram.output,
-            init_time=[t.strftime("%Y%m%d%H%M") for t in REFTIMES],
-            run_id=CANDIDATES,
-            param=["T_2M", "SP_10M"],
-            sta=["GVE", "KLO", "LUG"],
-            showcase=EXPERIMENT_NAME,
+        (
+            expand(
+                rules.plot_meteogram.output,
+                init_time=[t.strftime("%Y%m%d%H%M") for t in REFTIMES],
+                run_id=CANDIDATES,
+                param=SHOWCASE_PARAMS,
+                sta=config["showcase"]["stations"],
+                showcase=EXPERIMENT_NAME,
+            )
+            if config["showcase"]["meteograms"]
+            else []
         ),
 
 

workflow/rules/common.smk

@@ -80,6 +80,28 @@ def parse_regions():
     return regions_txt
 
 
+def parse_showcase_regions():
+    """Parse showcase domains from config.
+
+    Returns a dict mapping domain name -> {extent, projection}.
+    Named domains (strings) have extent=None and projection=None,
+    meaning the plot script will fall back to the DOMAINS lookup.
+    Custom domains carry their explicit extent and projection.
+    """
+    result = {}
+    for r in config.get("showcase", {}).get(
+        "domains", ["globe", "europe", "switzerland"]
+    ):
+        if isinstance(r, str):
+            result[r] = {"extent": None, "projection": None}
+        else:
+            result[r["name"]] = {
+                "extent": r.get("extent"),
+                "projection": r.get("projection", "orthographic"),
+            }
+    return result
+
+
 # ============================================================================
 # Run entries configuration management
 # ============================================================================
@@ -294,6 +316,8 @@ def master_hash() -> str:
 
 
 REGIONS = parse_regions()
+SHOWCASE_REGIONS = parse_showcase_regions()
+SHOWCASE_PARAMS = config.get("showcase", {}).get("params", ["T_2M", "SP_10M"])
 REFTIMES = parse_reference_times()
 RUN_CONFIGS = collect_all_runs()
 ENV_CONFIGS = collect_all_envs()

workflow/rules/plot.smk

@@ -38,7 +38,7 @@ rule plot_meteogram:
     resources:
         slurm_partition="postproc",
         cpus_per_task=1,
-        runtime="10m",
+        runtime="60m",
     params:
         ana_label=lambda wc: config["truth"]["label"],
         fcst_grib=lambda wc: (
@@ -92,6 +92,7 @@ rule plot_forecast_frame:
         / "data/runs/{run_id}/{init_time}/frames/frame_{leadtime}_{param}_{region}.png",
     wildcard_constraints:
         leadtime=r"\d+",  # only digits
+        region="|".join(map(re.escape, SHOWCASE_REGIONS.keys())),
     resources:
         slurm_partition="postproc",
         cpus_per_task=1,
@@ -100,13 +101,22 @@ rule plot_forecast_frame:
         grib_out_dir=lambda wc: (
             Path(OUT_ROOT) / f"data/runs/{wc.run_id}/{wc.init_time}/grib"
         ).resolve(),
+        region_extra=lambda wc: (
+            "--extent {} --projection {}".format(
+                " ".join(map(str, SHOWCASE_REGIONS[wc.region]["extent"])),
+                SHOWCASE_REGIONS[wc.region]["projection"],
+            )
+            if SHOWCASE_REGIONS.get(wc.region, {}).get("extent") is not None
+            else ""
+        ),
         accu=lambda wc: int(RUN_CONFIGS[wc.run_id]["steps"].split("/")[2]),
     shell:
         """
         export ECCODES_DEFINITION_PATH=$(realpath .venv/share/eccodes-cosmo-resources/definitions)
         python {input.script} \
             --input {params.grib_out_dir}  --date {wildcards.init_time} --outfn {output[0]} \
             --param {wildcards.param} --leadtime {wildcards.leadtime} --region {wildcards.region} \
+            {params.region_extra} \
             --accu {params.accu} \
         # interactive editing (needs to set localrule: True and use only one core)
         # marimo edit {input.script} -- \
@@ -127,11 +137,17 @@ def get_leadtimes(wc):
 
 rule make_forecast_animation:
     localrule: True
+    wildcard_constraints:
+        param="|".join(map(re.escape, SHOWCASE_PARAMS)),
+        region="|".join(map(re.escape, SHOWCASE_REGIONS.keys())),
     input:
-        expand(
+        lambda wc: expand(
             rules.plot_forecast_frame.output,
-            leadtime=lambda wc: get_leadtimes(wc),
-            allow_missing=True,
+            run_id=wc.run_id,
+            init_time=wc.init_time,
+            param=wc.param,
+            region=wc.region,
+            leadtime=get_leadtimes(wc),
         ),
     output:
         OUT_ROOT

workflow/scripts/plot_forecast_frame.mo.py

@@ -15,6 +15,7 @@ def _():
     import numpy as np
 
     from plotting import DOMAINS
+    from plotting import get_projection
     from plotting import StatePlotter
     from plotting.colormap_defaults import CMAP_DEFAULTS
     from plotting.compat import load_state_from_grib
@@ -29,6 +30,7 @@ def _():
         logging,
         np,
         DOMAINS,
+        get_projection,
         ccrs,
     )
 
@@ -53,6 +55,20 @@ def _(ArgumentParser, Path):
     parser.add_argument("--leadtime", type=str, help="leadtime")
     parser.add_argument("--param", type=str, help="parameter")
     parser.add_argument("--region", type=str, help="name of region")
+    parser.add_argument(
+        "--extent",
+        type=float,
+        nargs=4,
+        default=None,
+        metavar=("LON_MIN", "LON_MAX", "LAT_MIN", "LAT_MAX"),
+        help="custom geographic extent in PlateCarree coordinates; overrides DOMAINS lookup",
+    )
+    parser.add_argument(
+        "--projection",
+        type=str,
+        default=None,
+        help="projection name (e.g. 'orthographic'); used only together with --extent",
+    )
     parser.add_argument(
         "--accu", type=int, default=1, help="accumulation period in hours"
     )
@@ -208,6 +224,7 @@ def _(
     accu,
     args,
     get_style,
+    get_projection,
     outfn,
     param,
     preprocess_field,
@@ -222,11 +239,17 @@ def _(
         state["latitudes"],
         outfn.parent,
     )
+    if args.extent is not None:
+        _projection = get_projection(args.projection or "orthographic")
+        _extent = args.extent
+    else:
+        _projection = DOMAINS[region]["projection"]
+        _extent = DOMAINS[region]["extent"]
     fig = plotter.init_geoaxes(
         nrows=1,
         ncols=1,
-        projection=DOMAINS[region]["projection"],
-        bbox=DOMAINS[region]["extent"],
+        projection=_projection,
+        bbox=_extent,
         name=region,
         size=(6, 6),
     )