Suitability tables

CLAUDE.md

@@ -47,8 +47,10 @@ calibration_benchmark/
 │   ├── streamlit_app.py          Entrypoint + Home/"Optimization Leaderboard"
 │   ├── data_store.py             load_metric_store() / load_uq_store() / load_uq_budget_store()
 │   │                             → @st.cache_data DataFrames; DATASET_FILES, UQ_BUDGET_FILES
+│   │                             → BENCHMARK_DIMS — physical (param, state, output) dims per benchmark
 │   ├── common/
 │   │   ├── leaderboard.py       render_leaderboard() — shared scored-table + chart pipeline
+│   │   │                        _render_suitability_table() — method × benchmark suitability grid
 │   │   │                        optional budget_store param adds budget/iters chart section
 │   │   └── method_registry.py   KNOWN_METHODS registry + name canonicalization
 │   └── pages/
@@ -122,6 +124,21 @@ all-quantiles-satisfied condition.
 
 All three stores are `@st.cache_data` — clear Streamlit cache to pick up new data files.
 
+### Benchmark dimensions (`BENCHMARK_DIMS`)
+
+Physical dimensions of each benchmark exported from `src/data_store.py` as
+`BENCHMARK_DIMS: dict[str, tuple[int, int, int]]` — `(param_dim, state_dim, output_dim)`:
+
+| Benchmark | param | state | output |
+|---|---|---|---|
+| `L63` | 2 | 3 | 9 |
+| `L96` | 1 | 40 | 80 |
+| `L96_NN_FORCING` | 61 | 100 | 200 |
+| `L96_SPATIAL_FORCING` | 40 | 40 | 80 |
+
+Passed as `benchmark_dims=BENCHMARK_DIMS` to `render_leaderboard()` for column-header
+annotations in the suitability table. Update if a new benchmark is added.
+
 ## Method registry  (`src/common/method_registry.py`)
 
 | Canonical | Abbreviation | Family | Aliases |
@@ -144,8 +161,10 @@ All three stores are `@st.cache_data` — clear Streamlit cache to pick up new d
 3. Place result NetCDF(s) in `data/` and add paths to `DATASET_FILES` in `src/data_store.py`.
 
 ### Add an optimization benchmark dataset
-Add a `"BENCHMARK_NAME": [list_of_nc_paths]` entry to `DATASET_FILES` in `src/data_store.py`.
-Paths are relative to the `data/` directory.
+1. Add a `"BENCHMARK_NAME": [list_of_nc_paths]` entry to `DATASET_FILES` in `src/data_store.py`.
+   Paths are relative to the `data/` directory.
+2. Add a `"BENCHMARK_NAME": (param_dim, state_dim, output_dim)` entry to `BENCHMARK_DIMS`
+   in `src/data_store.py` for the suitability table column header.
 
 ### Add UQ data
 Add an `(algorithm_type, nc_path)` tuple to the appropriate benchmark key in `UQ_BUDGET_FILES`
@@ -183,3 +202,11 @@ the `budget_store` parameter of `render_leaderboard()` in `src/common/leaderboar
   never reached (no `metric == -1` sentinel); `failure_rate` is computed differently.
 - **`render_leaderboard` budget_store param** — must be passed explicitly from
   `UQLeaderboard.py`; `leaderboard.py` is not aware of UQ-specific data paths.
+- **`render_leaderboard` requires `default_target`** — callers must pass the fixed target level
+  shown on first load (`1.1` for optimization, `1.5` for UQ). There is no "All targets" option.
+- **Suitability table is fixed at `default_target`** — `_render_suitability_table()` always
+  evaluates suitability at the `default_target` passed to `render_leaderboard()`, independent
+  of what the user selects in the target radio control below it.
+- **Suitability criteria** — a method is green for a benchmark if there exists an ensemble size
+  with `failure_rate < 20%` and `mean_budget ≤ 3× global_best` at `default_target`. Gray means
+  no data for that benchmark; the method may be suitable on other benchmarks.

src/common/leaderboard.py

@@ -14,6 +14,7 @@ Usage::
         target_label="RMSE Target Level",
         title="Optimization Leaderboard",
         state_prefix="opt",
+        default_target=1.1,
         raw_page="pages/RawData.py",
     )
 """
@@ -31,6 +32,98 @@ _METHOD_PALETTE = [
     "#eeca3b", "#b279a2", "#ff9da6", "#9d755d", "#bab0ac",
 ]
 
+_SUITABLE   = "#009E73"  # Okabe-Ito teal-green (colorblind-safe)
+_UNSUITABLE = "#C0392B"  # dark red
+_UNTESTED   = "#BDBDBD"  # gray
+
+
+def _render_suitability_table(
+    store: pd.DataFrame,
+    target_col: str,
+    suitability_target: float,
+    benchmark_dims: dict[str, tuple[int, int, int]] | None = None,
+    failure_threshold: float = 20.0,
+    ratio_threshold: float = 3.0,
+) -> None:
+    """Render the method × benchmark suitability grid above the leaderboard controls."""
+    benchmarks = sorted(
+        store["benchmark"].unique().tolist(),
+        key=lambda bm: benchmark_dims[bm][0] if (benchmark_dims and bm in benchmark_dims) else bm,
+    )
+    methods    = sorted(store["abbreviation"].dropna().unique().tolist())
+
+    target_str     = str(float(suitability_target))
+    target_str_col = f"{target_col}_str"
+    target_df      = store.copy()
+    target_df[target_str_col] = target_df[target_col].astype(str)
+    target_df = target_df[target_df[target_str_col] == target_str]
+
+    # Global best per benchmark: min metric across all methods with failure_rate < threshold
+    global_best: dict[str, float | None] = {}
+    for bm in benchmarks:
+        bm_df      = target_df[target_df["benchmark"] == bm]
+        qualifying = bm_df[bm_df["failure_rate"] < failure_threshold].dropna(subset=["metric"])
+        global_best[bm] = float(qualifying["metric"].min()) if not qualifying.empty else None
+
+    cell_text:  dict[str, dict[str, str]] = {}
+    cell_color: dict[str, dict[str, str]] = {}
+
+    for method in methods:
+        cell_text[method]  = {}
+        cell_color[method] = {}
+        for bm in benchmarks:
+            sub = target_df[
+                (target_df["abbreviation"] == method) & (target_df["benchmark"] == bm)
+            ]
+            if sub.empty:
+                cell_text[method][bm]  = "—"
+                cell_color[method][bm] = _UNTESTED
+                continue
+            qualifying = sub[sub["failure_rate"] < failure_threshold].dropna(subset=["metric"])
+            if qualifying.empty:
+                cell_text[method][bm]  = "failed"
+                cell_color[method][bm] = _UNSUITABLE
+                continue
+            method_best = float(qualifying["metric"].min())
+            gb          = global_best.get(bm)
+            ratio       = (method_best / gb) if (gb is not None and gb > 0) else 1.0
+            cell_text[method][bm]  = f"{ratio:.1f}×"
+            cell_color[method][bm] = _SUITABLE if ratio <= ratio_threshold else _UNSUITABLE
+
+    col_labels: dict[str, str] = {}
+    for bm in benchmarks:
+        if benchmark_dims and bm in benchmark_dims:
+            p, s, o = benchmark_dims[bm]
+            col_labels[bm] = f"{bm} (p={p}, s={s}, o={o})"
+        else:
+            col_labels[bm] = bm
+
+    display_df = pd.DataFrame(cell_text).T.rename(columns=col_labels)
+    color_df   = pd.DataFrame(cell_color).T.rename(columns=col_labels)
+    display_df.index.name = "Method"
+
+    def _style(df: pd.DataFrame) -> pd.DataFrame:
+        result = pd.DataFrame("", index=df.index, columns=df.columns)
+        for row in df.index:
+            for col in df.columns:
+                bg = color_df.loc[row, col]
+                fg = "#212529" if bg == _UNTESTED else "white"
+                result.loc[row, col] = (
+                    f"background-color: {bg}; color: {fg}; "
+                    "text-align: center; font-weight: bold"
+                )
+        return result
+
+    st.subheader("Method Suitability Overview")
+    st.caption(
+        f"Evaluated at target = {suitability_target}. "
+        f"**Green**: at some ensemble size, failure rate < {failure_threshold:.0f}% "
+        f"and mean budget ≤ {ratio_threshold:.0f}× the best method (ratio shown). "
+        "**Red**: does not meet criteria. "
+        "**Gray**: no data for this experiment."
+    )
+    st.dataframe(display_df.style.apply(_style, axis=None), use_container_width=True)
+
 
 def render_leaderboard(
     metric_store: pd.DataFrame,
@@ -39,11 +132,13 @@ def render_leaderboard(
     target_label: str,
     title: str,
     state_prefix: str,
+    default_target: float,
     raw_page: str | None = None,
     show_failure_panel: bool = False,
     show_scoring_modes: bool = True,
     canonical_target_levels: list[float] | None = None,
     budget_store: pd.DataFrame | None = None,
+    benchmark_dims: dict[str, tuple[int, int, int]] | None = None,
 ) -> None:
     """Render a scored leaderboard backed by *metric_store*.
 
@@ -66,12 +161,17 @@ def render_leaderboard(
         Short string used to namespace ``st.session_state`` keys so multiple
         leaderboard pages keep independent control state.  Use ``"opt"`` for
         the Optimization leaderboard and ``"uq"`` for the UQ leaderboard.
+    default_target:
+        Target level shown on first load (e.g. ``1.1`` for optimization,
+        ``1.5`` for UQ).
     raw_page:
         Optional Streamlit page path for an "Open Raw Data" link shown at the
         bottom.  Pass ``None`` to suppress the link.
     show_failure_panel:
         If ``True``, render a grouped-bar failure-rate chart below the main
         performance chart.
+    show_scoring_modes:
+        If ``True``, show scoring-mode radio controls in the expander.
     canonical_target_levels:
         If provided, the target-level selector always offers exactly these
         values (as strings) regardless of what is present in the data.  Use
@@ -79,10 +179,11 @@ def render_leaderboard(
         levels even when some have 100 % failure.
     budget_store:
         Optional DataFrame produced by ``load_uq_budget_store()``.  When
-        provided, an additional "Budget and Iterations for Coverage" section is
-        rendered below the main performance chart, showing mean budget
-        (N_ens·k_iter, solid lines) and mean iterations (k_iter, dashed lines)
-        vs ensemble size, followed by a coverage-failure-rate bar chart.
+        provided, an additional "Mean Iterations for Coverage" section is
+        rendered below the main performance chart.
+    benchmark_dims:
+        Optional mapping of benchmark name → (param_dim, state_dim, output_dim)
+        used to annotate column headers in the suitability table.
     """
     st.header(title)
 
@@ -90,24 +191,25 @@ def render_leaderboard(
         st.warning("No metric data found. Expected NetCDF files in `data/` with a `metric` variable.")
         return
 
+    _render_suitability_table(
+        metric_store, target_col, default_target, benchmark_dims=benchmark_dims
+    )
+
+    st.divider()
+
     # Derived column name for the string version of the target coordinate
     target_str_col = f"{target_col}_str"
 
-    benchmark_values = sorted(metric_store["benchmark"].unique().tolist())
-    benchmark_options = ["All"] + benchmark_values
-    selected_benchmark = st.selectbox("Benchmark", options=benchmark_options, index=0)
+    benchmark_values   = sorted(metric_store["benchmark"].unique().tolist())
+    selected_benchmark = st.selectbox("Benchmark", options=benchmark_values, index=0)
 
-    filtered = (
-        metric_store.copy()
-        if selected_benchmark == "All"
-        else metric_store[metric_store["benchmark"] == selected_benchmark].copy()
-    )
+    filtered = metric_store[metric_store["benchmark"] == selected_benchmark].copy()
     filtered[target_str_col] = filtered[target_col].astype(str)
 
     if canonical_target_levels is not None:
-        target_options = ["All targets"] + [str(float(t)) for t in canonical_target_levels]
+        target_options = [str(float(t)) for t in canonical_target_levels]
     else:
-        target_options = ["All targets"] + sorted(
+        target_options = sorted(
             metric_store[target_col].astype(str).unique().tolist()
         )
 
@@ -120,14 +222,19 @@ def render_leaderboard(
 
     # Session-state keys namespaced by state_prefix so two leaderboard pages
     # don't share control state.
-    k_target = f"{state_prefix}_selected_target"
+    k_target  = f"{state_prefix}_selected_target"
     k_scoring = f"{state_prefix}_scoring_mode"
-    k_weight = f"{state_prefix}_fwdruns_weight_percent"
+    k_weight  = f"{state_prefix}_fwdruns_weight_percent"
     k_methods = f"{state_prefix}_selected_methods"
 
-    current_target = st.session_state.get(k_target, "All targets")
-    if current_target not in target_options:
-        current_target = target_options[0]
+    default_target_str = str(float(default_target))
+
+    # Pre-populate session state so the radio widget and the filter agree on first load.
+    if k_target not in st.session_state or st.session_state[k_target] not in target_options:
+        st.session_state[k_target] = (
+            default_target_str if default_target_str in target_options else target_options[0]
+        )
+    selected_target = st.session_state[k_target]
 
     current_scoring_mode = st.session_state.get(k_scoring, "Mean Forward Model Runs")
     if current_scoring_mode not in scoring_options:
@@ -136,22 +243,21 @@ def render_leaderboard(
     current_fwdruns_weight_percent = int(st.session_state.get(k_weight, 80))
     current_fwdruns_weight_percent = max(0, min(100, current_fwdruns_weight_percent))
 
-    selected_target = current_target
-    scoring_mode = current_scoring_mode
-    fwdruns_weight = current_fwdruns_weight_percent / 100.0
+    scoring_mode    = current_scoring_mode
+    fwdruns_weight  = current_fwdruns_weight_percent / 100.0
     ensemble_weight = 1.0 - fwdruns_weight
 
     # Available methods for the current benchmark selection; used to populate the
     # multiselect and to prune any stale saved selections when the benchmark changes.
     available_methods = sorted(filtered["abbreviation"].dropna().unique().tolist())
-    saved_methods = st.session_state.get(k_methods, available_methods)
-    valid_saved = [m for m in saved_methods if m in available_methods]
+    saved_methods     = st.session_state.get(k_methods, available_methods)
+    valid_saved       = [m for m in saved_methods if m in available_methods]
     st.session_state[k_methods] = valid_saved if valid_saved else available_methods
 
     # Stable color scale: domain covers ALL methods so colors don't shift when a
     # subset is displayed.
     color_domain = available_methods
-    color_range = [_METHOD_PALETTE[i % len(_METHOD_PALETTE)] for i in range(len(available_methods))]
+    color_range  = [_METHOD_PALETTE[i % len(_METHOD_PALETTE)] for i in range(len(available_methods))]
     method_color = alt.Color(
         "abbreviation:N",
         title="Method",
@@ -159,11 +265,7 @@ def render_leaderboard(
     )
 
     def build_scored_table(input_df: pd.DataFrame, add_rank: bool = True) -> pd.DataFrame:
-        ranking_source = (
-            input_df
-            if selected_target == "All targets"
-            else input_df[input_df[target_str_col] == selected_target]
-        )
+        ranking_source = input_df[input_df[target_str_col] == selected_target]
         if ranking_source.empty:
             return ranking_source
 
@@ -182,7 +284,6 @@ def render_leaderboard(
         ).agg(
             **{"Mean Forward Model Runs": ("metric", "mean")},
             **{"Minimum Forward Model Runs": ("metric", "min")},
-            **{"Targets Used": (target_str_col, "nunique")},
             **{"Ensemble Sizes Used": ("ensemble_size", "nunique")},
         )
 
@@ -216,10 +317,10 @@ def render_leaderboard(
             how="left",
         )
 
-        scored_df["Optimal Ensemble Size"] = scored_df["Optimal Ensemble Size"].round(2)
-        scored_df["Mean Forward Model Runs"] = scored_df["Mean Forward Model Runs"].round(4)
+        scored_df["Optimal Ensemble Size"]      = scored_df["Optimal Ensemble Size"].round(2)
+        scored_df["Mean Forward Model Runs"]    = scored_df["Mean Forward Model Runs"].round(4)
         scored_df["Minimum Forward Model Runs"] = scored_df["Minimum Forward Model Runs"].round(4)
-        scored_df["Mean Failure Rate (%)"] = scored_df["Mean Failure Rate (%)"].round(1)
+        scored_df["Mean Failure Rate (%)"]      = scored_df["Mean Failure Rate (%)"].round(1)
 
         mean_runs_min = scored_df["Mean Forward Model Runs"].min()
         mean_runs_max = scored_df["Mean Forward Model Runs"].max()
@@ -278,85 +379,20 @@ def render_leaderboard(
 
         return scored_df
 
-    if selected_benchmark == "All":
-        benchmark_scores = []
-        for benchmark_name in benchmark_values:
-            benchmark_df = metric_store[metric_store["benchmark"] == benchmark_name].copy()
-            benchmark_df[target_str_col] = benchmark_df[target_col].astype(str)
-            scored = build_scored_table(benchmark_df, add_rank=False)
-            if scored.empty:
-                continue
-            scored["benchmark"] = benchmark_name
-            benchmark_scores.append(scored)
-
-        if benchmark_scores:
-            combined_scores = (
-                benchmark_scores[0].copy()
-                if len(benchmark_scores) == 1
-                else pd.concat(benchmark_scores, ignore_index=True)
-            )
-            leaderboard_df = combined_scores.groupby(
-                ["algorithm_type", "abbreviation", "Method", "family"], as_index=False
-            ).agg(
-                Score=("Score", "mean"),
-                **{"Mean Forward Model Runs": ("Mean Forward Model Runs", "mean")},
-                **{"Minimum Forward Model Runs": ("Minimum Forward Model Runs", "mean")},
-                **{"Optimal Ensemble Size": ("Optimal Ensemble Size", "mean")},
-                **{"Targets Used": ("Targets Used", "mean")},
-                **{"Ensemble Sizes Used": ("Ensemble Sizes Used", "mean")},
-                **{"Benchmarks Used": ("benchmark", "nunique")},
-                **{"Mean Failure Rate (%)": ("Mean Failure Rate (%)", "mean")},
-            )
-
-            leaderboard_df["Mean Forward Model Runs"] = leaderboard_df["Mean Forward Model Runs"].round(4)
-            leaderboard_df["Minimum Forward Model Runs"] = leaderboard_df["Minimum Forward Model Runs"].round(4)
-            leaderboard_df["Optimal Ensemble Size"] = leaderboard_df["Optimal Ensemble Size"].round(2)
-            leaderboard_df["Targets Used"] = leaderboard_df["Targets Used"].round().astype(int)
-            leaderboard_df["Ensemble Sizes Used"] = leaderboard_df["Ensemble Sizes Used"].round().astype(int)
-            leaderboard_df["Mean Failure Rate (%)"] = leaderboard_df["Mean Failure Rate (%)"].round(1)
-            leaderboard_df = leaderboard_df.sort_values(
-                ["Score", "Mean Forward Model Runs", "abbreviation"], ascending=[False, True, True]
-            ).reset_index(drop=True)
-            leaderboard_df["Rank"] = leaderboard_df.index + 1
-            leaderboard_df["Placement"] = leaderboard_df["Rank"].apply(
-                lambda rank: f"{ {1: '🥇', 2: '🥈', 3: '🥉'}.get(rank, '')} #{rank}".strip()
-            )
-        else:
-            leaderboard_df = pd.DataFrame(
-                columns=[
-                    "Placement",
-                    "abbreviation",
-                    "Method",
-                    "family",
-                    "Mean Forward Model Runs",
-                    "Minimum Forward Model Runs",
-                    "Score",
-                    "Optimal Ensemble Size",
-                    "Targets Used",
-                    "Ensemble Sizes Used",
-                    "Benchmarks Used",
-                    "Mean Failure Rate (%)",
-                ]
-            )
-    else:
-        leaderboard_df = build_scored_table(filtered, add_rank=True)
-        leaderboard_df["Benchmarks Used"] = 1
+    leaderboard_df = build_scored_table(filtered, add_rank=True)
 
     if scoring_mode == "Mean Forward Model Runs":
-        score_basis = "normalized mean of best forward model runs over selected target levels (lower is better)"
+        score_basis = "mean forward-model runs at the selected target level (lower is better)"
     elif scoring_mode == "Minimum Forward Model Runs":
-        score_basis = "normalized minimum of forward model runs over selected targets and ensemble sizes (lower is better)"
+        score_basis = "minimum forward-model runs at the selected target level (lower is better)"
     elif scoring_mode == "Smallest Optimal Ensemble Size":
-        score_basis = "normalized mean optimal ensemble size over selected target levels (lower is better)"
+        score_basis = "mean optimal ensemble size at the selected target level (lower is better)"
     else:
         score_basis = (
-            "weighted blend of normalized forward-model-runs score and normalized ensemble-size score "
-            f"(forward-runs weight {fwdruns_weight:.0%}, ensemble-size weight {ensemble_weight:.0%})"
+            f"weighted blend of normalized forward-model-runs score ({fwdruns_weight:.0%}) "
+            f"and normalized ensemble-size score ({ensemble_weight:.0%})"
         )
 
-    if selected_benchmark == "All":
-        score_basis = f"{score_basis}; in All mode, each method's final score is the mean of its per-benchmark scores"
-
     # Controls expander — always shown so users can change target even when the
     # current selection yields all failures.
     with st.expander("Scoring & Target Controls", expanded=False):
@@ -398,6 +434,19 @@ def render_leaderboard(
     if not selected_methods:
         selected_methods = available_methods
 
+    table_column_order = [
+        "Placement",
+        "abbreviation",
+        "Method",
+        "family",
+        "Score",
+        "Mean Forward Model Runs",
+        "Minimum Forward Model Runs",
+        "Mean Failure Rate (%)",
+        "Optimal Ensemble Size",
+        "Ensemble Sizes Used",
+    ]
+
     if leaderboard_df.empty:
         st.warning(
             "All runs failed to reach the target at this selection. "
@@ -406,34 +455,6 @@ def render_leaderboard(
             else "No rows available for the current benchmark/target selection."
         )
     else:
-        if selected_benchmark == "All":
-            table_column_order = [
-                "Placement",
-                "abbreviation",
-                "Method",
-                "family",
-                "Score",
-                "Mean Failure Rate (%)",
-                "Targets Used",
-                "Ensemble Sizes Used",
-                "Benchmarks Used",
-            ]
-        else:
-            table_column_order = [
-                "Placement",
-                "abbreviation",
-                "Method",
-                "family",
-                "Score",
-                "Mean Forward Model Runs",
-                "Minimum Forward Model Runs",
-                "Mean Failure Rate (%)",
-                "Optimal Ensemble Size",
-                "Targets Used",
-                "Ensemble Sizes Used",
-                "Benchmarks Used",
-            ]
-
         st.subheader(f"Ranked Leaderboard — {selected_benchmark}")
         st.dataframe(
             leaderboard_df,
@@ -449,91 +470,82 @@ def render_leaderboard(
                 "Score": st.column_config.ProgressColumn("Score (0-100)", min_value=0.0, max_value=100.0, format="%.1f"),
                 "Optimal Ensemble Size": st.column_config.NumberColumn("Mean Optimal Ensemble Size", format="%.2f"),
                 "Mean Failure Rate (%)": st.column_config.NumberColumn("Mean Failure Rate (%)", format="%.1f"),
-                "Targets Used": st.column_config.NumberColumn("Targets Used", format="%d"),
                 "Ensemble Sizes Used": st.column_config.NumberColumn("Ensemble Sizes Used", format="%d"),
-                "Benchmarks Used": st.column_config.NumberColumn("Benchmarks Used", format="%d"),
             },
             column_order=table_column_order,
         )
 
         st.info(
             f"Score is a normalized 0–100 ranking based on **{score_basis}**. "
-            "For Mean/Minimum forward-runs scoring, values are computed from all selected metric target levels "
-            "and all ensemble sizes after averaging over random seeds."
+            "Values are computed from all ensemble sizes after averaging over random seeds."
         )
 
-        if selected_benchmark != "All":
-            st.subheader("Mean Forward Model Runs vs Ensemble Size")
-            chart_source = (
-                filtered
-                if selected_target == "All targets"
-                else filtered[filtered[target_str_col] == selected_target]
-            )
-            chart_source = chart_source[chart_source["abbreviation"].isin(selected_methods)]
-            chart_df = chart_source.dropna(subset=["metric"]).groupby(
-                ["abbreviation", "ensemble_size"], as_index=False
-            ).agg(mean_forward_runs=("metric", "mean"))
-
-            all_ens_combos = chart_source[["abbreviation", "ensemble_size"]].drop_duplicates()
-            ens_ticks = sorted(all_ens_combos["ensemble_size"].unique().tolist()) if not all_ens_combos.empty else []
+        st.subheader("Mean Forward Model Runs vs Ensemble Size")
+        chart_source = filtered[filtered[target_str_col] == selected_target]
+        chart_source = chart_source[chart_source["abbreviation"].isin(selected_methods)]
+        chart_df = chart_source.dropna(subset=["metric"]).groupby(
+            ["abbreviation", "ensemble_size"], as_index=False
+        ).agg(mean_forward_runs=("metric", "mean"))
 
-            if not chart_df.empty:
-                _ok = chart_df[["abbreviation", "ensemble_size"]].assign(_ok=True)
-                fail_df = all_ens_combos.merge(_ok, on=["abbreviation", "ensemble_size"], how="left")
-                fail_df = fail_df[fail_df["_ok"].isna()].drop(columns="_ok").assign(mean_forward_runs=0.0)
-            else:
-                fail_df = all_ens_combos.assign(mean_forward_runs=0.0)
+        all_ens_combos = chart_source[["abbreviation", "ensemble_size"]].drop_duplicates()
+        ens_ticks = sorted(all_ens_combos["ensemble_size"].unique().tolist()) if not all_ens_combos.empty else []
 
-            all_failed = chart_df.empty
-            chart_layers = []
-            if not chart_df.empty:
-                chart_layers.append(
-                    alt.Chart(chart_df)
-                    .mark_line(point=True)
-                    .encode(
-                        x=alt.X(
-                            "ensemble_size:Q",
-                            title="Ensemble Size",
-                            axis=alt.Axis(values=ens_ticks, format="d"),
-                        ),
-                        y=alt.Y("mean_forward_runs:Q", title="Mean Forward Model Runs"),
-                        color=method_color,
-                        tooltip=["abbreviation", "ensemble_size", alt.Tooltip("mean_forward_runs:Q", format=".4f")],
-                    )
-                )
-            if not fail_df.empty:
-                y_fwd = (
-                    alt.Y("mean_forward_runs:Q", title="Mean Forward Model Runs", scale=alt.Scale(domain=[0, 1]))
-                    if all_failed
-                    else alt.Y("mean_forward_runs:Q", title="Mean Forward Model Runs")
+        if not chart_df.empty:
+            _ok = chart_df[["abbreviation", "ensemble_size"]].assign(_ok=True)
+            fail_df = all_ens_combos.merge(_ok, on=["abbreviation", "ensemble_size"], how="left")
+            fail_df = fail_df[fail_df["_ok"].isna()].drop(columns="_ok").assign(mean_forward_runs=0.0)
+        else:
+            fail_df = all_ens_combos.assign(mean_forward_runs=0.0)
+
+        all_failed  = chart_df.empty
+        chart_layers = []
+        if not chart_df.empty:
+            chart_layers.append(
+                alt.Chart(chart_df)
+                .mark_line(point=True)
+                .encode(
+                    x=alt.X(
+                        "ensemble_size:Q",
+                        title="Ensemble Size",
+                        axis=alt.Axis(values=ens_ticks, format="d"),
+                    ),
+                    y=alt.Y("mean_forward_runs:Q", title="Mean Forward Model Runs"),
+                    color=method_color,
+                    tooltip=["abbreviation", "ensemble_size", alt.Tooltip("mean_forward_runs:Q", format=".4f")],
                 )
-                chart_layers.append(
-                    alt.Chart(fail_df)
-                    .mark_point(shape="cross", angle=45, size=200, filled=True, opacity=1.0)
-                    .encode(
-                        x=alt.X(
-                            "ensemble_size:Q",
-                            title="Ensemble Size",
-                            axis=alt.Axis(values=ens_ticks, format="d"),
-                        ),
-                        y=y_fwd,
-                        color=method_color,
-                        tooltip=[
-                            alt.Tooltip("abbreviation:N", title="Method"),
-                            alt.Tooltip("ensemble_size:Q", title="Ensemble Size"),
-                            alt.Tooltip("mean_forward_runs:Q", title="Value (all failed)"),
-                        ],
-                    )
+            )
+        if not fail_df.empty:
+            y_fwd = (
+                alt.Y("mean_forward_runs:Q", title="Mean Forward Model Runs", scale=alt.Scale(domain=[0, 1]))
+                if all_failed
+                else alt.Y("mean_forward_runs:Q", title="Mean Forward Model Runs")
+            )
+            chart_layers.append(
+                alt.Chart(fail_df)
+                .mark_point(shape="cross", angle=45, size=200, filled=True, opacity=1.0)
+                .encode(
+                    x=alt.X(
+                        "ensemble_size:Q",
+                        title="Ensemble Size",
+                        axis=alt.Axis(values=ens_ticks, format="d"),
+                    ),
+                    y=y_fwd,
+                    color=method_color,
+                    tooltip=[
+                        alt.Tooltip("abbreviation:N", title="Method"),
+                        alt.Tooltip("ensemble_size:Q", title="Ensemble Size"),
+                        alt.Tooltip("mean_forward_runs:Q", title="Value (all failed)"),
+                    ],
                 )
-            if chart_layers:
-                st.altair_chart(alt.layer(*chart_layers), use_container_width=True)
+            )
+        if chart_layers:
+            st.altair_chart(alt.layer(*chart_layers), use_container_width=True)
 
     # Mean-iterations-for-coverage section (UQ only, when budget_store provided)
-    if budget_store is not None and not budget_store.empty and selected_benchmark != "All":
+    if budget_store is not None and not budget_store.empty:
         bf = budget_store[budget_store["benchmark"] == selected_benchmark].copy()
         bf[target_str_col] = bf[target_col].astype(str)
-        if selected_target != "All targets":
-            bf = bf[bf[target_str_col] == selected_target]
+        bf = bf[bf[target_str_col] == selected_target]
         bf = bf[bf["abbreviation"].isin(selected_methods)]
 
         iters_df = (
@@ -603,12 +615,8 @@ def render_leaderboard(
                 st.altair_chart(alt.layer(*iters_layers), use_container_width=True)
 
     # Failure panel — rendered regardless of whether the scored table has rows
-    if show_failure_panel and selected_benchmark != "All":
-        failure_source = (
-            filtered
-            if selected_target == "All targets"
-            else filtered[filtered[target_str_col] == selected_target]
-        )
+    if show_failure_panel:
+        failure_source = filtered[filtered[target_str_col] == selected_target]
         failure_source = failure_source[failure_source["abbreviation"].isin(selected_methods)]
         if not failure_source.empty:
             failure_df = failure_source.groupby(
@@ -616,12 +624,7 @@ def render_leaderboard(
             ).agg(mean_failure_rate=("failure_rate", "mean"))
             failure_df = failure_df.sort_values("ensemble_size")
 
-            target_str = (
-                "All Targets"
-                if selected_target == "All targets"
-                else f"Target {selected_target}"
-            )
-            st.subheader(f"Failure Rate of Hitting {target_str}")
+            st.subheader(f"Failure Rate of Hitting Target {selected_target}")
             ens_ticks_fail = sorted(failure_df["ensemble_size"].unique().tolist())
             failure_chart = (
                 alt.Chart(failure_df)

src/data_store.py

@@ -87,6 +87,15 @@ UQ_BUDGET_FILES: dict[str, list[tuple[str, str]]] = {
 # Budget = N_ens · k_iter where first k s.t. |S(q)−q| ≤ c·√(q(1−q)/N_y) for ALL q below.
 UQ_COVERAGE_QUANTILES: list[float] = [0.15, 0.5, 0.85]
 
+# Physical dimensions of each benchmark: (param_dim, state_dim, output_dim).
+# Used only for column-header annotations in the suitability table.
+BENCHMARK_DIMS: dict[str, tuple[int, int, int]] = {
+    "L63":                (2, 3, 9),
+    "L96":                (1, 40, 80),
+    "L96_NN_FORCING":     (61, 100, 200),
+    "L96_SPATIAL_FORCING": (40, 40, 80),
+}
+
 
 
 # ---------------------------------------------------------------------------

src/pages/OptimizationLeaderboard.py

@@ -4,11 +4,11 @@ import sys
 import streamlit as st
 
 try:
-    from data_store import load_metric_store
+    from data_store import load_metric_store, BENCHMARK_DIMS
     from common.leaderboard import render_leaderboard
 except ModuleNotFoundError:
     sys.path.append(str(Path(__file__).resolve().parents[1]))
-    from data_store import load_metric_store
+    from data_store import load_metric_store, BENCHMARK_DIMS
     from common.leaderboard import render_leaderboard
 
 st.set_page_config(page_title="Optimization Leaderboard", page_icon="📊", layout="wide")
@@ -31,5 +31,7 @@ render_leaderboard(
     target_label="RMSE Target Level",
     title="Optimization Leaderboard",
     state_prefix="opt",
+    default_target=1.1,
     raw_page="pages/RawData.py",
+    benchmark_dims=BENCHMARK_DIMS,
 )

src/pages/UQLeaderboard.py

@@ -4,11 +4,11 @@ import sys
 import streamlit as st
 
 try:
-    from data_store import load_uq_store, load_uq_budget_store, UQ_TARGET_LEVELS
+    from data_store import load_uq_store, load_uq_budget_store, UQ_TARGET_LEVELS, BENCHMARK_DIMS
     from common.leaderboard import render_leaderboard
 except ModuleNotFoundError:
     sys.path.append(str(Path(__file__).resolve().parents[1]))
-    from data_store import load_uq_store, load_uq_budget_store, UQ_TARGET_LEVELS
+    from data_store import load_uq_store, load_uq_budget_store, UQ_TARGET_LEVELS, BENCHMARK_DIMS
     from common.leaderboard import render_leaderboard
 
 st.set_page_config(page_title="UQ Leaderboard", page_icon="🎯", layout="wide")
@@ -33,8 +33,10 @@ render_leaderboard(
     target_label="UQ Target (coverage tolerance scaling)",
     title="Uncertainty Quantification Leaderboard",
     state_prefix="uq",
+    default_target=1.5,
     show_failure_panel=True,
     show_scoring_modes=False,
     canonical_target_levels=UQ_TARGET_LEVELS,
     budget_store=load_uq_budget_store(),
+    benchmark_dims=BENCHMARK_DIMS,
 )