Separate GBOED from IES and rerun

.cache/known_methods_snapshot.json

@@ -126,16 +126,20 @@
         "gradient_descent"
       ]
     },
-    "gboed": {
-      "abbreviation": "GBOED",
-      "Method": "Goal-oriented Bayesian Optimal Experimental Design",
+    "gboed-tmcmc": {
+      "abbreviation": "GBOED-TMCMC",
+      "Method": "Goal-oriented Bayesian Optimal Experimental Design (TMCMC)",
       "parallelism": "parallel-interacting",
       "update_type": "general",
       "method_goal": "uq",
       "emulator_use": "within-optimize",
       "aliases": [
         "gboed",
-        "boed"
+        "gboed-tmcmc",
+        "boed",
+        "gboed-tmcmc-eig",
+        "boed-tmcmc-eig",
+        "tmcmc-eig"
       ]
     },
     "lm-kgmm": {
@@ -193,7 +197,7 @@
     "rl-ddpg-short": {
       "abbreviation": "RL-DDPG-SHORT",
       "Method": "Reinforcement Learning (DDPG, short RL step)",
-      "parallelism": "serial",
+      "parallelism": "serial (short window)",
       "update_type": "gradient (score)",
       "method_goal": "optimization",
       "emulator_use": "none",
@@ -216,7 +220,7 @@
     "rl-td3-short": {
       "abbreviation": "RL-TD3-SHORT",
       "Method": "Reinforcement Learning (TD3, short RL step)",
-      "parallelism": "serial",
+      "parallelism": "serial (short window)",
       "update_type": "gradient (score)",
       "method_goal": "optimization",
       "emulator_use": "none",
@@ -235,6 +239,43 @@
         "rl-td3",
         "rl-td3-long"
       ]
+    },
+    "ies-iekf": {
+      "abbreviation": "IES-IEKF",
+      "Method": "Iterated Emulate-Sample (IEKF)",
+      "parallelism": "parallel-interacting",
+      "update_type": "general",
+      "method_goal": "uq",
+      "emulator_use": "within-optimize",
+      "aliases": [
+        "ies-iekf",
+        "boed-iekf"
+      ]
+    },
+    "gboed-iekf": {
+      "abbreviation": "GBOED-IEKF",
+      "Method": "Goal-oriented Bayesian Optimal Experimental Design (IEKF)",
+      "parallelism": "parallel-interacting",
+      "update_type": "general",
+      "method_goal": "uq",
+      "emulator_use": "within-optimize",
+      "aliases": [
+        "gboed-iekf",
+        "gboed-iekf-eig",
+        "boed-iekf-eig"
+      ]
+    },
+    "ies-tmcmc": {
+      "abbreviation": "IES-TMCMC",
+      "Method": "Iterated Emulate-Sample (TMCMC)",
+      "parallelism": "parallel-interacting",
+      "update_type": "general",
+      "method_goal": "uq",
+      "emulator_use": "within-optimize",
+      "aliases": [
+        "ies-tmcmc",
+        "boed-tmcmc"
+      ]
     }
   },
   "observed_methods": [

.claude/skills/leaderboard-manager/references/manage-display.md

@@ -23,9 +23,8 @@ next time someone edits the file.
 2. Benchmark selector (`st.selectbox("Benchmark", ...)`) — always a single benchmark;
    there is **no "All benchmarks" option**. Every chart and the table below operate on
    whatever `selected_benchmark` is currently chosen.
-3. **Controls — always visible**, not collapsed. Look for `st.subheader("Scoring &
-   Target Controls")`: target-level radio, scoring-mode radio (+ blend-weight slider
-   when "Custom Blend" is selected), and the "Methods to display in charts" pills
+3. **Controls — always visible**, not collapsed. Look for `st.subheader("Target &
+   Method Controls")`: target-level radio and the "Methods to display in charts" pills
    selector (see "Methods selector" below). These used to be wrapped in
    `st.expander(..., expanded=False)`; that was removed so users don't have to open a
    dropdown to see or change the target level.
@@ -67,7 +66,7 @@ list (not one-per-view):
 table_column_order = [
     "Placement", "abbreviation", "Method",
     "update_type", "parallelism", "method_goal", "emulator_use", "Score",
-    "Mean Forward Model Runs", "Minimum Forward Model Runs",
+    "Mean Forward Model Runs",
     "Mean Failure Rate (%)", "Optimal Ensemble Size", "Ensemble Sizes Used",
 ]
 ```
@@ -106,28 +105,14 @@ To add it:
 
 ---
 
-## Scoring modes
-
-The four scoring modes are defined in `scoring_options` (a list literal near the top of
-`render_leaderboard()`, right after `target_options` is computed):
-```python
-scoring_options = [
-    "Mean Forward Model Runs",
-    "Minimum Forward Model Runs",
-    "Smallest Optimal Ensemble Size",
-    "Custom Blend",
-]
-```
-
-Each mode maps to a sort key and a score column assignment inside `build_scored_table()`
-— search for the `if scoring_mode == "Mean Forward Model Runs": ... elif ...` chain. To
-**add a new scoring mode**, add its name to `scoring_options` and add an `elif` branch in
-that chain that sets `scored_df["Score"]`, `sort_columns`, and `ascending`.
+## Scoring
 
-The "Custom Blend" slider (`st.slider("Blend Weight: Forward Runs vs Ensemble Size", ...)`)
-is keyed to the session-state key `k_weight` and only rendered when
-`st.session_state[k_scoring] == "Custom Blend"` — no change needed when adding a
-non-blend mode. It lives in the always-visible controls section, not behind an expander.
+There is a single scoring basis: mean forward-model runs. The scoring-mode radio, the
+"Custom Blend" slider and the minimum-runs / ensemble-size modes were removed. In
+`build_scored_table()`, `Score` is the normalized 0-100 form of `Mean Forward Model Runs`
+(`mean_runs_score`), and rows are sorted by reliability, then mean runs, then optimal
+ensemble size. To reintroduce another mode, add a control above the target radio and branch
+on it where `Score` / `sort_columns` are set.
 
 ---
 

CLAUDE.md

@@ -57,6 +57,8 @@ calibration_benchmark/
 │   │   │                        when budget_store is None (Optimization board), instead renders a
 │   │   │                        "Mean Iterations to Reach Target" chart derived as metric/ensemble_size
 │   │   └── method_registry.py   KNOWN_METHODS registry + name canonicalization
+│   │                            SUITABILITY_FAMILIES — method families (CES, Kalman, Gradient, GFDT, RL, IES,
+│   │                            GBOED, General) grouping rows in the online + LaTeX suitability tables
 │   └── pages/
 │       ├── UQLeaderboard.py     🎯 UQ Leaderboard — calls render_leaderboard(load_uq_store())
 │       ├── MethodDetails.py     📘 Method configurations — per-method (selection-driven) technical
@@ -81,9 +83,19 @@ calibration_benchmark/
 │   ├── rl-td3/                  RL-TD3-SHORT / RL-TD3 (TD3 variant of the RL experiments; RL-TD3 files are `rl-td3-long` in the NetCDF) results (per-benchmark files)
 │   ├── rl-ddpg/                 RL-DDPG-SHORT / RL-DDPG (DDPG actor-critic; short RL step / standard-window RL step; RL-DDPG files are `rl-ddpg-long` in the NetCDF) results (per-benchmark files)
 │   ├── ces-eki-dmc_results/     CES-EKI-DMC ensemble-results files (UQ source)
-│   ├── gboed-uq_results/        GBOED ensemble-results files (UQ source)
+│   ├── gboed-uq_results/        GBOED ensemble-results files (UQ source; 2026-10-16 GBOED-TMCMC/IES-TMCMC and 2026-10-19 IEKF-based variants, all four benchmarks; files are named `boed-*`: `tmcmc-eig` = GBOED-TMCMC, `iekf-eig` = GBOED-IEKF, `iekf` = IES-IEKF, `tmcmc` = IES-TMCMC; IES = Iterated Emulate-Sample)
 │   ├── gnki-uq_results/         IEKF (a.k.a GNKI) ensemble-results files (UQ source)
 │   └── abc/                     ABC ensemble-results files (UQ source; per-benchmark files)
+├── offline-plots/               leaderboard_plot.py — matplotlib replica of the leaderboard charts
+│                                (failure rate, forward runs, iterations) for one benchmark/target,
+│                                serial vs ensemble panels, colors from METHOD_COLORS. Defaults to the
+│                                suitability-table target (1.1 opt / 1.5 UQ); writes to figures/.
+│                                `python offline-plots/leaderboard_plot.py [--board uq] [--methods ...]`
+│                                suitability_tables.py — regenerates tables/suitability_tables.tex (LaTeX
+│                                suitability grids, rows grouped by method family with \midrule) from the
+│                                current stores; `python offline-plots/suitability_tables.py`. New methods
+│                                must be listed in `SUITABILITY_FAMILIES` (method_registry.py) or it exits with an error.
+├── tables/                      suitability_tables.tex (generated), method_taxonomy_tables.tex (hand-written)
 ├── examples/                    lorenz_demo.ipynb + lorenz.py (reference, not app code)
 ├── From_Rob_6-10/               Raw collaborator data drop — NOT read by the app
 ├── .cache/                      known_methods_snapshot.json (auto-generated, safe to delete)
@@ -204,7 +216,10 @@ A quick taxonomy tree is rendered on the home page (`src/streamlit_app.py`).
 | `ces-eki-dmc` | CES-EKI-DMC | parallel-interacting | gradient (Kalman) | uq | after-optimize | — |
 | `adam` | ADAM | serial | gradient (exact) | optimization | none | — |
 | `lm` | LM | serial | gradient (exact) | optimization | none | gradient_descent |
-| `gboed` | GBOED | parallel-interacting | general | uq | within-optimize | boed |
+| `gboed-tmcmc` | GBOED-TMCMC | parallel-interacting | general | uq | within-optimize | gboed, boed, tmcmc-eig, boed-tmcmc-eig, gboed-tmcmc-eig |
+| `ies-iekf` | IES-IEKF | parallel-interacting | general | uq | within-optimize | boed-iekf |
+| `gboed-iekf` | GBOED-IEKF | parallel-interacting | general | uq | within-optimize | gboed-iekf-eig, boed-iekf-eig |
+| `ies-tmcmc` | IES-TMCMC | parallel-interacting | general | uq | within-optimize | boed-tmcmc |
 | `lm-kgmm` | LM-KGMM | serial | gradient (score) | optimization | none | — |
 | `lm-dsm` | LM-DSM | serial | gradient (score) | optimization | none | — |
 | `adam-kgmm` | ADAM-KGMM | serial | gradient (score) | optimization | none | — |
@@ -223,6 +238,10 @@ A quick taxonomy tree is rendered on the home page (`src/streamlit_app.py`).
 2. Add detail-page metadata to the inline `method_meta` dict in `src/pages/MethodDetails.py`
    keyed by **abbreviation** (e.g. `"TEKI"`). ⚠️ Metadata is split across both files.
 3. Place result NetCDF(s) in `data/` and add paths to `DATASET_FILES` in `src/data_store.py`.
+4. Add the abbreviation to a family in `SUITABILITY_FAMILIES` (`method_registry.py`; spelled-out family
+   names live in `FAMILY_FULL_NAMES` — add an entry there for any new family). Unlisted methods
+   appear in a trailing "Other" block of the online suitability table, and
+   `offline-plots/suitability_tables.py` refuses to run until they are assigned.
 
 ### Add an optimization benchmark dataset
 1. Add a `"BENCHMARK_NAME": [list_of_nc_paths]` entry to `DATASET_FILES` in `src/data_store.py`.
@@ -295,6 +314,12 @@ the `budget_store` parameter of `render_leaderboard()` in `src/common/leaderboar
 - **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.
+- **Family display names** — `SUITABILITY_FAMILIES` keys are short ids (`RL`, `GFDT`, ...); the UI shows `family_full_name(key)` from `FAMILY_FULL_NAMES` (suitability table, the family key under the home-page method table, and the per-family rows of the "Methods to display in charts" pills on both leaderboards; session keys `<prefix>_selected_methods__<family>`, with `<prefix>_selected_methods` mirroring the union).
+- **Suitability table families** — rows of the suitability table are grouped by `SUITABILITY_FAMILIES`
+  (family order = dict order, row order = list order). Online (`_render_suitability_table`) this shows as a
+  leading "Family" column labelled on the first row of each block with alternating gray shading, since
+  `st.dataframe` cannot draw rules; the LaTeX tables use `\midrule` between blocks. A family only appears on a
+  board where one of its methods has data.
 - **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.

data/{gboed-uq_results/boed_l63_ensemble_results_2026-07-30_minimal.nc → adam_results/leaderboard_adam_l96_flux-force_2026-10-21.nc}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:52616c824f068f6de1eb9ccf67f56a1000b56d1cd54c911daa817df4b600e26b
-size 673057
+oid sha256:539eb03a55d4ffe0a51b3b45db3b5dc0d0e159c8132e71639ba2eb5c0f72af95
+size 11440

data/gboed-uq_results/{boed_l96_const-force_2026-07-30_minimal.nc → boed-iekf-eig_l63_ensemble_results_2026-10-19_minimal.nc}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:84062bc4afda563eba840efcf06c70143037660e99f258d6ecba84538a308b78
-size 809857
+oid sha256:f65ab0ae11bc8774dff077565a96dea07329cc1fe9c1055e01de4942bbb609f2
+size 728387

data/gboed-uq_results/{boed_l96_vec-force_2026-08-07_minimal.nc → boed-iekf-eig_l96_const-force_2026-10-19_minimal.nc}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d1a3cd33db2cef7d81e31cf0a679e93955f3c851153eefbf2c719061b60330b9
-size 618337
+oid sha256:04951c1aa8553181100c69f4819c3df54d72a39c4d614624a56d778cef85c710
+size 728387

data/gboed-uq_results/boed-iekf-eig_l96_flux-force_2026-10-19_minimal.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4d65fc5289eece6735841ad4024b2fa3c9ec3d09e4a6c0442e3ef217399a9941
+size 728387

data/gboed-uq_results/boed-iekf-eig_l96_vec-force_2026-10-19_minimal.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:af1d2f624baf2e6c398718fa593caabccf7db232a133041bd3ed46eef28266a5
+size 728387

data/gboed-uq_results/boed-iekf_l63_ensemble_results_2026-10-19_minimal.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a39050677da137a8cb4ab906c5e4d6f532c0a4ef9c7c7dd0c60885e988554d48
+size 728383

data/gboed-uq_results/boed-iekf_l96_const-force_2026-10-19_minimal.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d2fdf0355c4c2461ff96c1bb610a472fa9c4f5379b55a748f74eb089daf5e2be
+size 728383

data/gboed-uq_results/boed-iekf_l96_flux-force_2026-10-19_minimal.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a61dab8820a1d681da06758a13ade609b2feeb1d0b9b95b645d858dd504d368d
+size 728383

data/gboed-uq_results/boed-iekf_l96_vec-force_2026-10-19_minimal.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f2779b4eec62487f8794e472fcf7abc3d2721549ce7d857c82f9ced4075551d7
+size 728383

data/gboed-uq_results/boed-tmcmc-eig_l63_ensemble_results_2026-10-16_minimal.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:add03f4917aeff93b36b051520b1341363c494905df5352c2ecdafa46d8be19a
+size 728388

data/gboed-uq_results/boed-tmcmc-eig_l96_const-force_2026-10-16_minimal.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c2312bf2553c4fb38c47f4ab50eb0f2d339d9af21dbcdb08ec549d224eaeee79
+size 728388

data/gboed-uq_results/boed-tmcmc-eig_l96_flux-force_2026-10-16_minimal.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ea5592248a9ef9f739d95825cdfe9a01fd76c6c6c50ecf2e341139e26af4d4a
+size 728388

data/gboed-uq_results/boed-tmcmc-eig_l96_vec-force_2026-10-16_minimal.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5c7924216ef9add1bd56e294d7bded10c7b0ca2df696b9c3f2ceec66bc2e8a9
+size 728388

data/gboed-uq_results/boed-tmcmc_l63_ensemble_results_2026-10-16_minimal.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ed95ad74202e40bcf6b412f37d2f35b4d8b5a66f1ae9effee9dac19f7068aaa
+size 728384

data/gboed-uq_results/boed-tmcmc_l96_const-force_2026-10-16_minimal.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5072b6ec954baeb5add8097a29a33ca82e4d55a9f81965d43ee2bb629e5e644
+size 728384

data/gboed-uq_results/boed-tmcmc_l96_flux-force_2026-10-16_minimal.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5cd0f8903089ebdb468e5b3e41ce08c89207905ef1f47135f1e5369fa1632203
+size 728384

data/gboed-uq_results/boed-tmcmc_l96_vec-force_2026-10-16_minimal.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9ac1182e23750b0db31239f52c8279771c8d6cbcfe66743184d2ffaa15b30194
+size 728384

data/levenberg_marquardt_results/leaderboard_lm_l96_flux-force_2026-10-20.nc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9e2a216e92286052411116fc527cb1d49e66272e522f48aeaf1d985aa3495976
+size 11440

src/common/leaderboard.py

@@ -25,13 +25,16 @@ import pandas as pd
 import streamlit as st
 
 try:
-    from common.method_registry import METHOD_COLORS
+    from common.method_registry import METHOD_COLORS, SUITABILITY_FAMILIES, family_full_name
 except ModuleNotFoundError:
-    from src.common.method_registry import METHOD_COLORS
+    from src.common.method_registry import METHOD_COLORS, SUITABILITY_FAMILIES, family_full_name
 
 _SUITABLE   = "#009E73"  # Okabe-Ito teal-green (colorblind-safe)
 _UNSUITABLE = "#C0392B"  # dark red
 _UNTESTED   = "#BDBDBD"  # gray
+# Alternating light grays for the family-label column of the suitability table, so
+# consecutive family blocks are visually distinct.
+_FAMILY_BGS = ("#E9ECEF", "#CED4DA")
 
 
 def _method_color(present_abbrevs: list[str]) -> alt.Color:
@@ -67,6 +70,24 @@ _UPDATE_TYPE_ORDER: dict[str, int] = {
 _RELIABLE_FAILURE_THRESHOLD = 20.0
 
 
+def _group_by_family(methods: list[str]) -> list[tuple[str, list[str]]]:
+    """Group method abbreviations into (family key, methods) in SUITABILITY_FAMILIES order.
+
+    Methods not listed in any family go into a trailing "Other" group.
+    """
+    groups: list[tuple[str, list[str]]] = []
+    placed: set[str] = set()
+    for fam, members in SUITABILITY_FAMILIES.items():
+        present = [m for m in members if m in methods]
+        if present:
+            groups.append((fam, present))
+            placed.update(present)
+    rest = [m for m in methods if m not in placed]
+    if rest:
+        groups.append(("Other", sorted(rest)))
+    return groups
+
+
 def _render_suitability_table(
     store: pd.DataFrame,
     target_col: str,
@@ -80,16 +101,20 @@ def _render_suitability_table(
         store["benchmark"].unique().tolist(),
         key=lambda bm: benchmark_dims[bm][0] if (benchmark_dims and bm in benchmark_dims) else bm,
     )
-    _abbr_update_type = (
-        store[["abbreviation", "update_type"]].dropna()
-        .drop_duplicates("abbreviation")
-        .set_index("abbreviation")["update_type"]
-        .to_dict()
-    )
+    # Rows are grouped into method families (SUITABILITY_FAMILIES); methods not listed
+    # there fall into a trailing "Other" family.
+    _family_of = {m: fam for fam, ms in SUITABILITY_FAMILIES.items() for m in ms}
+    _family_rank = {fam: i for i, fam in enumerate(SUITABILITY_FAMILIES)}
+    _row_rank = {m: i for ms in SUITABILITY_FAMILIES.values() for i, m in enumerate(ms)}
     methods = sorted(
         store["abbreviation"].dropna().unique().tolist(),
-        key=lambda a: (_UPDATE_TYPE_ORDER.get(_abbr_update_type.get(a, ""), 99), a),
+        key=lambda a: (
+            _family_rank.get(_family_of.get(a, ""), len(_family_rank)),
+            _row_rank.get(a, 0),
+            a,
+        ),
     )
+    family_label = {m: family_full_name(_family_of.get(m, "Other")) for m in methods}
 
     target_str     = str(float(suitability_target))
     target_str_col = f"{target_col}_str"
@@ -144,13 +169,27 @@ def _render_suitability_table(
     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"
+    # Leading "Family" column, labelled only on the first row of each family block so
+    # the families read as blocks (st.dataframe cannot draw rules between row groups).
+    shown_family = [
+        fam if i == 0 or fam != family_label[methods[i - 1]] else ""
+        for i, fam in enumerate(family_label[m] for m in methods)
+    ]
+    display_df.insert(0, "Family", shown_family)
+    block_idx, prev = -1, None
+    family_bg = []
+    for m in methods:
+        if family_label[m] != prev:
+            block_idx, prev = block_idx + 1, family_label[m]
+        family_bg.append(_FAMILY_BGS[block_idx % 2])
+    color_df.insert(0, "Family", family_bg)
 
     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"
+                fg = "#212529" if bg == _UNTESTED or bg in _FAMILY_BGS else "white"
                 result.loc[row, col] = (
                     f"background-color: {bg}; color: {fg}; "
                     "text-align: center; font-weight: bold"
@@ -165,7 +204,8 @@ def _render_suitability_table(
         "**Red** (failed): data present but no ensemble size met the criteria; "
         "the percentage is the lowest failure rate (share of runs that did not reach the target) "
         "across ensemble sizes. "
-        "**Gray (—)**: no data for this benchmark."
+        "**Gray (—)**: no data for this benchmark. "
+        "Rows are grouped into method families of similar construction (left column)."
     )
     st.dataframe(
         display_df.style.apply(_style, axis=None),
@@ -184,7 +224,6 @@ def render_leaderboard(
     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,
@@ -220,8 +259,6 @@ def render_leaderboard(
     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.
     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
@@ -263,18 +300,9 @@ def render_leaderboard(
             metric_store[target_col].astype(str).unique().tolist()
         )
 
-    scoring_options = [
-        "Mean Forward Model Runs",
-        "Minimum Forward Model Runs",
-        "Smallest Optimal Ensemble Size",
-        "Custom Blend",
-    ]
-
     # Session-state keys namespaced by state_prefix so two leaderboard pages
     # don't share control state.
     k_target  = f"{state_prefix}_selected_target"
-    k_scoring = f"{state_prefix}_scoring_mode"
-    k_weight  = f"{state_prefix}_fwdruns_weight_percent"
     k_methods = f"{state_prefix}_selected_methods"
 
     default_target_str = str(float(default_target))
@@ -286,17 +314,6 @@ def render_leaderboard(
         )
     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:
-        current_scoring_mode = scoring_options[0]
-
-    current_fwdruns_weight_percent = int(st.session_state.get(k_weight, 80))
-    current_fwdruns_weight_percent = max(0, min(100, current_fwdruns_weight_percent))
-
-    scoring_mode    = current_scoring_mode
-    fwdruns_weight  = current_fwdruns_weight_percent / 100.0
-    ensemble_weight = 1.0 - fwdruns_weight
-
     def build_scored_table(input_df: pd.DataFrame, add_rank: bool = True) -> pd.DataFrame:
         ranking_source = input_df[input_df[target_str_col] == selected_target]
         if ranking_source.empty:
@@ -316,7 +333,6 @@ def render_leaderboard(
             ["algorithm_type", "abbreviation", "Method"], as_index=False
         ).agg(
             **{"Mean Forward Model Runs": ("metric", "mean")},
-            **{"Minimum Forward Model Runs": ("metric", "min")},
             **{"Ensemble Sizes Used": ("ensemble_size", "nunique")},
         )
 
@@ -351,7 +367,6 @@ def render_leaderboard(
 
         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)
 
         mean_runs_min = scored_df["Mean Forward Model Runs"].min()
@@ -363,47 +378,13 @@ def render_leaderboard(
         else:
             scored_df["mean_runs_score"] = 100.0
 
-        minimum_runs_min = scored_df["Minimum Forward Model Runs"].min()
-        minimum_runs_max = scored_df["Minimum Forward Model Runs"].max()
-        if minimum_runs_max > minimum_runs_min:
-            scored_df["minimum_runs_score"] = (
-                100.0 * (minimum_runs_max - scored_df["Minimum Forward Model Runs"]) / (minimum_runs_max - minimum_runs_min)
-            )
-        else:
-            scored_df["minimum_runs_score"] = 100.0
-
-        ens_min = scored_df["Optimal Ensemble Size"].min()
-        ens_max = scored_df["Optimal Ensemble Size"].max()
-        if ens_max > ens_min:
-            scored_df["ensemble_score"] = (
-                100.0 * (ens_max - scored_df["Optimal Ensemble Size"]) / (ens_max - ens_min)
-            )
-        else:
-            scored_df["ensemble_score"] = 100.0
-
         scored_df["_unreliable"] = (
             scored_df["Mean Failure Rate (%)"].fillna(0.0) >= _RELIABLE_FAILURE_THRESHOLD
         )
 
-        if scoring_mode == "Mean Forward Model Runs":
-            scored_df["Score"] = scored_df["mean_runs_score"]
-            sort_columns = ["_unreliable", "Mean Forward Model Runs", "Optimal Ensemble Size", "abbreviation"]
-            ascending = [True, True, True, True]
-        elif scoring_mode == "Minimum Forward Model Runs":
-            scored_df["Score"] = scored_df["minimum_runs_score"]
-            sort_columns = ["_unreliable", "Minimum Forward Model Runs", "Optimal Ensemble Size", "abbreviation"]
-            ascending = [True, True, True, True]
-        elif scoring_mode == "Smallest Optimal Ensemble Size":
-            scored_df["Score"] = scored_df["ensemble_score"]
-            sort_columns = ["_unreliable", "Optimal Ensemble Size", "Mean Forward Model Runs", "abbreviation"]
-            ascending = [True, True, True, True]
-        else:
-            scored_df["Score"] = (
-                fwdruns_weight * scored_df["mean_runs_score"]
-                + ensemble_weight * scored_df["ensemble_score"]
-            )
-            sort_columns = ["_unreliable", "Score", "Mean Forward Model Runs", "Optimal Ensemble Size", "abbreviation"]
-            ascending = [True, False, True, True, True]
+        scored_df["Score"] = scored_df["mean_runs_score"]
+        sort_columns = ["_unreliable", "Mean Forward Model Runs", "Optimal Ensemble Size", "abbreviation"]
+        ascending = [True, True, True, True]
 
         scored_df = (
             scored_df.sort_values(sort_columns, ascending=ascending)
@@ -426,8 +407,8 @@ def render_leaderboard(
         if dnf_abbrevs:
             dnf_rows = failure_agg[failure_agg["abbreviation"].isin(dnf_abbrevs)].copy()
             for col in [
-                "Score", "mean_runs_score", "minimum_runs_score", "ensemble_score",
-                "Mean Forward Model Runs", "Minimum Forward Model Runs",
+                "Score", "mean_runs_score",
+                "Mean Forward Model Runs",
                 "Optimal Ensemble Size", "Ensemble Sizes Used",
             ]:
                 dnf_rows[col] = float("nan")
@@ -466,9 +447,22 @@ def render_leaderboard(
         # All runs failed at this target (or no data) — show every method so the
         # all-DNF warning/chart-suppression path still has something to work with.
         default_methods = available_methods
-    saved_methods = st.session_state.get(k_methods, default_methods)
-    valid_saved   = [m for m in saved_methods if m in available_methods]
+    # The selector is one pills widget per method family (one row each); the
+    # selection is the union of the family widgets, mirrored into k_methods.
+    method_groups = _group_by_family(available_methods)
+    family_keys   = {fam: f"{k_methods}__{fam}" for fam, _ in method_groups}
+    if any(wkey in st.session_state for wkey in family_keys.values()):
+        saved_methods = [
+            m for wkey in family_keys.values() for m in st.session_state.get(wkey) or []
+        ]
+    else:
+        saved_methods = default_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 default_methods
+    for fam, members in method_groups:
+        st.session_state[family_keys[fam]] = [
+            m for m in st.session_state[k_methods] if m in members
+        ]
 
     # Attach the four taxonomy tags (constant per abbreviation, so this is a
     # plain lookup merge rather than a groupby key threaded through every
@@ -490,22 +484,12 @@ def render_leaderboard(
             na_position="last",
         ).drop(columns=["_update_type_sort", "_is_dnf"]).reset_index(drop=True)
 
-    if scoring_mode == "Mean Forward Model Runs":
-        score_basis = "mean forward-model runs at the selected target level (lower is better)"
-    elif scoring_mode == "Minimum Forward Model Runs":
-        score_basis = "minimum forward-model runs at the selected target level (lower is better)"
-    elif scoring_mode == "Smallest Optimal Ensemble Size":
-        score_basis = "mean optimal ensemble size at the selected target level (lower is better)"
-    else:
-        score_basis = (
-            f"weighted blend of normalized forward-model-runs score ({fwdruns_weight:.0%}) "
-            f"and normalized ensemble-size score ({ensemble_weight:.0%})"
-        )
+    score_basis = "mean forward-model runs at the selected target level (lower is better)"
 
     # Controls — always visible (not collapsed behind a dropdown) so users can
-    # change target/scoring/methods even when the current selection yields all
+    # change target/methods even when the current selection yields all
     # failures.
-    st.subheader("Scoring & Target Controls")
+    st.subheader("Target & Method Controls")
     st.radio(
         target_label,
         options=target_options,
@@ -513,36 +497,20 @@ def render_leaderboard(
         key=k_target,
     )
 
-    if show_scoring_modes:
-        st.radio(
-            "Scoring Method",
-            options=scoring_options,
-            horizontal=True,
-            key=k_scoring,
+    st.markdown("**Methods to display in charts**")
+    st.caption("Defaults to the top 5 methods by current rank — click to add or remove. Rows are method families.")
+    for fam, members in method_groups:
+        st.pills(
+            family_full_name(fam),
+            options=members,
+            selection_mode="multi",
+            key=family_keys[fam],
         )
 
-        if st.session_state.get(k_scoring, "Mean Forward Model Runs") == "Custom Blend":
-            st.slider(
-                "Blend Weight: Forward Runs vs Ensemble Size",
-                min_value=0,
-                max_value=100,
-                step=5,
-                key=k_weight,
-                help=(
-                    "Higher forward-runs weight prioritizes fewer model evaluations; "
-                    "higher ensemble-size weight prioritizes smaller ensembles."
-                ),
-            )
-
-    st.pills(
-        "Methods to display in charts",
-        options=available_methods,
-        selection_mode="multi",
-        key=k_methods,
-        help="Defaults to the top 5 methods by current rank — click to add or remove.",
-    )
-
-    selected_methods = st.session_state.get(k_methods, available_methods)
+    selected_methods = [
+        m for fam, _ in method_groups for m in st.session_state.get(family_keys[fam]) or []
+    ]
+    st.session_state[k_methods] = selected_methods
     if not selected_methods:
         selected_methods = available_methods
 
@@ -840,7 +808,6 @@ def render_leaderboard(
         "emulator_use",
         "Score",
         "Mean Forward Model Runs",
-        "Minimum Forward Model Runs",
         "Mean Failure Rate (%)",
         "Optimal Ensemble Size",
         "Ensemble Sizes Used",
@@ -868,7 +835,6 @@ def render_leaderboard(
                 "Method": st.column_config.TextColumn("Method"),
                 "abbreviation": st.column_config.TextColumn("Abbrev."),
                 "Mean Forward Model Runs": st.column_config.NumberColumn("Mean Forward Model Runs", format="%.4f"),
-                "Minimum Forward Model Runs": st.column_config.NumberColumn("Minimum Forward Model Runs", format="%.4f"),
                 "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"),

src/common/method_registry.py

@@ -140,14 +140,14 @@ KNOWN_METHODS = {
         "emulator_use": "none",
         "aliases": ["lm", "levenberg_marquardt", "levenberg-marquardt", "gradient_descent"],
     },
-    "gboed": {
-        "abbreviation": "GBOED",
-        "Method": "Goal-oriented Bayesian Optimal Experimental Design",
+    "gboed-tmcmc": {
+        "abbreviation": "GBOED-TMCMC",
+        "Method": "Goal-oriented Bayesian Optimal Experimental Design (TMCMC)",
         "parallelism": "parallel-interacting",
         "update_type": "general",
         "method_goal": "uq",
         "emulator_use": "within-optimize",
-        "aliases": ["gboed", "boed"],
+        "aliases": ["gboed", "gboed-tmcmc", "boed", "gboed-tmcmc-eig", "boed-tmcmc-eig", "tmcmc-eig"],
     },
     "lm-kgmm": {
         "abbreviation": "LM-KGMM",
@@ -237,6 +237,33 @@ KNOWN_METHODS = {
         "emulator_use": "none",
         "aliases": ["rl-td3", "rl-td3-long"],
     },
+    "ies-iekf": {
+        "abbreviation": "IES-IEKF",
+        "Method": "Iterated Emulate-Sample (IEKF)",
+        "parallelism": "parallel-interacting",
+        "update_type": "general",
+        "method_goal": "uq",
+        "emulator_use": "within-optimize",
+        "aliases": ["ies-iekf", "boed-iekf"],
+    },
+    "gboed-iekf": {
+        "abbreviation": "GBOED-IEKF",
+        "Method": "Goal-oriented Bayesian Optimal Experimental Design (IEKF)",
+        "parallelism": "parallel-interacting",
+        "update_type": "general",
+        "method_goal": "uq",
+        "emulator_use": "within-optimize",
+        "aliases": ["gboed-iekf", "gboed-iekf-eig", "boed-iekf-eig"],
+    },
+    "ies-tmcmc": {
+        "abbreviation": "IES-TMCMC",
+        "Method": "Iterated Emulate-Sample (TMCMC)",
+        "parallelism": "parallel-interacting",
+        "update_type": "general",
+        "method_goal": "uq",
+        "emulator_use": "within-optimize",
+        "aliases": ["ies-tmcmc", "boed-tmcmc"],
+    },
 }
 
 
@@ -292,6 +319,41 @@ METHOD_COLORS: dict[str, str] = {
 }
 
 
+# Method families used to group rows in the suitability tables (the online table in
+# common/leaderboard.py and the LaTeX tables from offline-plots/suitability_tables.py).
+# The idea is to put methods of similar construction — and so similar performance —
+# next to each other.  Dict order = family order; list order = row order within a
+# family.  A family only appears on a board if one of its methods has data there.
+# Every method that can appear in a suitability table must be listed here.
+SUITABILITY_FAMILIES: dict[str, list[str]] = {
+    "CES": ["CES-EKI-CONST", "CES-EKI-DMC", "CES-IEKF-CONST"],
+    "Kalman": ["ETKI", "IEKF", "TEKI", "UKI"],
+    "Gradient": ["LM", "ADAM"],
+    "GFDT": ["LM-DSM", "ADAM-DSM", "LM-KGMM", "ADAM-KGMM"],
+    "RL": ["RL-DDPG", "RL-TD3", "RL-DDPG-SHORT", "RL-TD3-SHORT"],
+    "IES": ["IES-IEKF", "IES-TMCMC"],
+    "GBOED": ["GBOED-IEKF", "GBOED-TMCMC"],
+    "General": ["ABC", "HM"],
+}
+
+# Spelled-out display names for the SUITABILITY_FAMILIES keys (suitability table,
+# home-page key, and the grouped method selector on the leaderboards).
+FAMILY_FULL_NAMES: dict[str, str] = {
+    "CES": "Calibrate, Emulate, Sample (CES)",
+    "Kalman": "Kalman",
+    "Gradient": "Gradient",
+    "GFDT": "Generalized Fluctuation-Dissipation (GFDT)",
+    "RL": "Reinforcement Learning (RL)",
+    "IES": "Iterated Emulate-Sample (IES)",
+    "GBOED": "Goal-oriented Bayesian Experimental Design (GBOED)",
+    "General": "General",
+}
+
+
+def family_full_name(family: str) -> str:
+    return FAMILY_FULL_NAMES.get(family, family)
+
+
 def build_alias_lookup() -> dict[str, str]:
     lookup: dict[str, str] = {}
     for canonical_name, meta in KNOWN_METHODS.items():

src/data_store.py

@@ -65,6 +65,8 @@ DATASET_FILES = {
         "etki_results/leaderboard_etki_l96_flux-force_2026-09-10.nc",
         "iekf_results/leaderboard_iekf_l96_flux-force_2026-09-10.nc",
         "UKI_results/uki_l96_nn_forcing_ensemble_results.nc",
+        "adam_results/leaderboard_adam_l96_flux-force_2026-10-21.nc",
+        "levenberg_marquardt_results/leaderboard_lm_l96_flux-force_2026-10-20.nc",
         "opt_kgmm_score_lm/leaderboard_sblm_kgmm_parallel_l96_flux-force_2026-09-02.nc",
         "opt_dsm_score_lm/leaderboard_sblm_dsm_parallel_l96_flux-force_2026-08-12.nc",
         "opt_kgmm_score_adam/leaderboard_sbadam_kgmm_parallel_l96_flux-force_2026-09-11.nc",
@@ -129,7 +131,10 @@ UQ_BUDGET_FILES: dict[str, list[tuple[str, str]]] = {
         ("ces-eki-const", "ces-eki-const_results/ces-eki-const_l63_ensemble_results_2026-07-09_minimal.nc"),
         ("ces-iekf-const", "ces-iekf-const_results/ces-iekf-const_l63_ensemble_results_2026-07-17_minimal.nc"),
         ("hm", "history-matching-uq_results/history-matching_l63_ensemble_results_2026-09-15_minimal.nc"),
-        ("gboed", "gboed-uq_results/boed_l63_ensemble_results_2026-07-30_minimal.nc"),
+        ("gboed-tmcmc", "gboed-uq_results/boed-tmcmc-eig_l63_ensemble_results_2026-10-16_minimal.nc"),
+        ("ies-iekf", "gboed-uq_results/boed-iekf_l63_ensemble_results_2026-10-19_minimal.nc"),
+        ("gboed-iekf", "gboed-uq_results/boed-iekf-eig_l63_ensemble_results_2026-10-19_minimal.nc"),
+        ("ies-tmcmc", "gboed-uq_results/boed-tmcmc_l63_ensemble_results_2026-10-16_minimal.nc"),
         ("abc", "abc/leaderboard_abc_l63_2026-09-10_minimal.nc"),
     ],
     "L96":                [
@@ -138,7 +143,10 @@ UQ_BUDGET_FILES: dict[str, list[tuple[str, str]]] = {
         ("ces-eki-const", "ces-eki-const_results/ces-eki-const_l96_ensemble_results_2026-07-09_minimal.nc"),
         ("ces-iekf-const", "ces-iekf-const_results/ces-iekf-const_l96_ensemble_results_2026-07-17_minimal.nc"),
         ("hm", "history-matching-uq_results/history-matching_l96_const-force_2026-09-15_minimal.nc"),
-        ("gboed", "gboed-uq_results/boed_l96_const-force_2026-07-30_minimal.nc"),
+        ("gboed-tmcmc", "gboed-uq_results/boed-tmcmc-eig_l96_const-force_2026-10-16_minimal.nc"),
+        ("ies-iekf", "gboed-uq_results/boed-iekf_l96_const-force_2026-10-19_minimal.nc"),
+        ("gboed-iekf", "gboed-uq_results/boed-iekf-eig_l96_const-force_2026-10-19_minimal.nc"),
+        ("ies-tmcmc", "gboed-uq_results/boed-tmcmc_l96_const-force_2026-10-16_minimal.nc"),
         ("abc", "abc/leaderboard_abc_l96_const-force_2026-09-10_minimal.nc"),
     ],
     "L96_NN_FORCING":     [
@@ -147,6 +155,10 @@ UQ_BUDGET_FILES: dict[str, list[tuple[str, str]]] = {
         ("ces-eki-const", "ces-eki-const_results/ces-eki-const_l96_nn_forcing_ensemble_results_2026-07-09_minimal.nc"),
         ("ces-iekf-const", "ces-iekf-const_results/ces-iekf-const_l96_nn_forcing_ensemble_results_2026-07-17_minimal.nc"),
         ("hm", "history-matching-uq_results/history-matching_l96_flux-force_2026-09-15_minimal.nc"),
+        ("gboed-tmcmc", "gboed-uq_results/boed-tmcmc-eig_l96_flux-force_2026-10-16_minimal.nc"),
+        ("ies-iekf", "gboed-uq_results/boed-iekf_l96_flux-force_2026-10-19_minimal.nc"),
+        ("gboed-iekf", "gboed-uq_results/boed-iekf-eig_l96_flux-force_2026-10-19_minimal.nc"),
+        ("ies-tmcmc", "gboed-uq_results/boed-tmcmc_l96_flux-force_2026-10-16_minimal.nc"),
         ("abc", "abc/leaderboard_abc_l96_flux-force_2026-09-10_minimal.nc"),
     ],
     "L96_SPATIAL_FORCING": [
@@ -155,7 +167,10 @@ UQ_BUDGET_FILES: dict[str, list[tuple[str, str]]] = {
         ("ces-eki-const", "ces-eki-const_results/ces-eki-const_l96_spatial_forcing_ensemble_results_2026-07-09_minimal.nc"),
         ("ces-iekf-const", "ces-iekf-const_results/ces-iekf-const_l96_spatial_forcing_ensemble_results_2026-07-17_minimal.nc"),
         ("hm", "history-matching-uq_results/history-matching_l96_vec-force_2026-09-15_minimal.nc"),
-        ("gboed", "gboed-uq_results/boed_l96_vec-force_2026-08-07_minimal.nc"),
+        ("gboed-tmcmc", "gboed-uq_results/boed-tmcmc-eig_l96_vec-force_2026-10-16_minimal.nc"),
+        ("ies-iekf", "gboed-uq_results/boed-iekf_l96_vec-force_2026-10-19_minimal.nc"),
+        ("gboed-iekf", "gboed-uq_results/boed-iekf-eig_l96_vec-force_2026-10-19_minimal.nc"),
+        ("ies-tmcmc", "gboed-uq_results/boed-tmcmc_l96_vec-force_2026-10-16_minimal.nc"),
         ("abc", "abc/leaderboard_abc_l96_vec-force_2026-09-10_minimal.nc"),
     ],
 }

src/pages/MethodDetails.py

@@ -307,7 +307,7 @@ method_meta = {
         ],
         "notes": "**Empirically also gets stuck in local minima near the initial condition, regardless of the damping schedule** — the same failure mode as ADAM, unsurprising for any single-trajectory local optimizer on this multimodal, chaotic-dynamics calibration surface.",
     },
-    "GBOED": {
+    "GBOED-TMCMC": {
         "citation": "Holthuijzen et al. 2026",
         "url": "https://arxiv.org/abs/2508.13071",
         "source": "`uq_experiments/BayesianOptimalExperimentalDesign` — Goal-oriented BOED, Algorithm 2 of Holthuijzen et al. 2026.",
@@ -330,12 +330,18 @@ method_meta = {
             "switches from greedy to joint optimization once a greedy step's cost exceeds a threshold."
         ),
         "params": [
+            {"Parameter": "n_posterior_samples (TMCMC population)", "Value": "1000"},
+            {"Parameter": "tmcmc_burnin / tmcmc_thin", "Value": "5 / 1 (below TMCMC's 20 / 3 defaults)"},
+            {"Parameter": "n_eig_posterior_samples (EIG subsample X')", "Value": "50"},
+            {"Parameter": "eig_region / eig_ball_quantile", "Value": ":ball / 0.999 (χ² ball in prior-whitened space)"},
+            {"Parameter": "eig_optim_iters / eig_outer_iters", "Value": "500 / 20"},
             {"Parameter": "eig_call_limit", "Value": "2000 EIG evaluations"},
-            {"Parameter": "eig_outer_iters", "Value": "20"},
+            {"Parameter": "eig_g_tol / eig_f_reltol", "Value": "1e-3 / 1e-6"},
             {"Parameter": "eig_jitter", "Value": "1e-6 × GP signal variance"},
+            {"Parameter": "gp_optim_iters / gp_outer_iters", "Value": "50 / 3"},
             {"Parameter": "batch_init_strategy", "Value": ":posterior_subsample"},
         ],
-        "notes": "**Empirically, the inner EIG-maximization loop over candidate batches is a frequent source of problems (hitting the call-limit / outer-iteration guardrails, i.e. \"under-optimized\" batches), and every iteration slows down as the cumulative GP training set grows** (GP fit/predict cost scales super-linearly in training-set size) — this is also why the repo's own config drops to a smaller `max_iters` on the higher-dimensional L96 cases (\"it's so slow, so let's start here\").",
+        "notes": "**Both the Transitional MCMC (TMCMC) posterior sampling and the EIG batch optimization contribute to performance.** TMCMC needs a sufficiently large population (`n_posterior_samples`) to represent the posterior, particularly in higher dimensions; its cost grows roughly linearly with population size, and `tmcmc_burnin`/`tmcmc_thin` multiply the per-stage cost. The EIG objective uses only a small posterior subsample (`n_eig_posterior_samples`), as EIG costs ~n³ per output mode. **The inner EIG-maximization loop is a frequent source of problems (hitting the call-limit / outer-iteration guardrails, i.e. \"under-optimized\" batches), and every iteration slows down as the cumulative GP training set grows**, which is why the higher-dimensional L96 cases use a smaller `max_iters`.",
     },
     "LM-KGMM": {
         "citation": "Giorgini, Bischoff & Souza, arXiv:2503.18054, 2025",
@@ -622,6 +628,132 @@ method_meta = {
             "targets on L96 flux-force or vec-force within the budget."
         ),
     },
+    "IES-IEKF": {
+        "citation": "Elsaesser et al., J. Adv. Model. Earth Syst., 2025",
+        "url": "https://doi.org/10.1029/2024MS004713",
+        "source": "`uq_experiments/BayesianOptimalExperimentalDesign` — `boed_core.jl` (`run_iekf`, `acquire_batch`), variant `:iekf` (leaderboard key `boed-iekf`).",
+        "math": (
+            "An iterated emulate-sample loop. Iteration 1 forward-evaluates an "
+            "`N_ens`-point Latin-hypercube design in the truncated, prior-whitened parameter space. Each later "
+            "iteration: (i) refits one GP per whitened output mode on all `(θ, G(θ))` pairs collected so far; "
+            "(ii) draws an approximate posterior by running an IEKF (`GaussNewtonInversion`) on the GP-mean "
+            "forward map — no true forward evaluations — starting from 1000 LHS prior draws; (iii) takes the next "
+            "`N_ens` forward-model evaluation points as a random subsample of that IEKF ensemble. The batch is "
+            "forward-evaluated and appended to the training set, so each iteration emulates the forward model, "
+            "samples the posterior from the emulator, and spends its forward runs where that posterior has mass."
+        ),
+        "guardrails": (
+            "The posterior sampler is a fixed-step IEKF (`DefaultScheduler(0.1)`, 30 steps, total pseudo-time "
+            "T = 3), so it is a finite-time approximate posterior rather than a converged one; the observation "
+            "noise in whitened output space is the identity and the GP predictive variance is ignored. GP fits "
+            "keep kernel and noise hyperparameters inside bounds set relative to each mode's data scale (±2 "
+            "decades on length scales and signal std; noise std between 1e-3 and 1 of the signal std) to avoid "
+            "degenerate near-zero-noise fits, with `Fminbox` capped at 50 inner / 3 outer iterations. Inputs "
+            "and outputs are PCA-whitened and truncated against the prior and the observation covariance."
+        ),
+        "params": [
+            {"Parameter": "IEKF ensemble size (n_posterior_samples)", "Value": "1000"},
+            {"Parameter": "IEKF step size / steps", "Value": "0.1 / 30 (T = 3)"},
+            {"Parameter": "batch size per iteration", "Value": "N_ens (random subsample of the IEKF ensemble)"},
+            {"Parameter": "gp_optim_iters / gp_outer_iters", "Value": "50 / 3"},
+            {"Parameter": "retain_var (output whitening)", "Value": "0.99"},
+            {"Parameter": "retain_var_input (input whitening)", "Value": "0.99 (L63, L96 const) / 0.9 (vec, flux)"},
+        ],
+        "notes": (
+            "**Cheap per iteration:** no MCMC and no batch optimization, only GP-mean predictions "
+            "inside the IEKF. The batch is a plain draw from the posterior with no diversity criterion, so points are "
+            "not spread out deliberately. In the current UQ data (c = 1.5, best ensemble size) it needs a "
+            "mean budget of 5.0 on L63 and 5.4 on L96 const-force, but on the two high-dimensional L96 cases "
+            "(vec-force and NN flux-force) it fails on at least 35% and 40% of seeds, respectively, at every ensemble size."
+        ),
+    },
+    "GBOED-IEKF": {
+        "citation": "Holthuijzen et al. 2026 (EIG acquisition); IEKF posterior sampler replaces ST-MCMC",
+        "url": "https://arxiv.org/abs/2508.13071",
+        "source": "`uq_experiments/BayesianOptimalExperimentalDesign` — `boed_core.jl` (`run_iekf`, `optimize_batch`, `acquire_batch`), variant `:iekf_eig` (leaderboard key `boed-iekf-eig`).",
+        "math": (
+            "GBOED with the posterior sampler swapped for an IEKF. Iteration 1 forward-evaluates an `N_ens`-point "
+            "Latin-hypercube design in the truncated prior-whitened space. Each later iteration: (i) refits one GP "
+            "per whitened output mode on all `(θ, G(θ))` pairs so far; (ii) draws an approximate posterior by "
+            "running an IEKF (`GaussNewtonInversion`) on the GP-mean forward map — no true forward evaluations; "
+            "(iii) chooses the next `N_ens` evaluation points by jointly maximizing the closed-form Expected "
+            "Information Gain (EIG) of the whole batch against a 50-member random subsample X' of the IEKF "
+            "ensemble, starting from a random subsample of the full ensemble."
+        ),
+        "math_eq": r"\mathrm{EIG}(X) = \frac{1}{k}\sum_j \frac{1}{2}\log\frac{\det K_{pp}^{(j)}}{\det \Sigma'^{(j)}}, \quad \Sigma'^{(j)} = K_{pp}^{(j)} - K_{pc}^{(j)}\left(K_{cc}^{(j)}\right)^{-1}K_{cp}^{(j)}",
+        "guardrails": (
+            "The IEKF posterior is a fixed-step, finite-time approximation (`DefaultScheduler(0.1)`, 30 steps, "
+            "T = 3) that ignores the GP predictive variance. The batch is optimized with `Optim.jl`'s "
+            "`LBFGS` inside the χ² ball of the prior-whitened space (radial `tanh` squash, so every candidate "
+            "has radius below √χ²_k(0.999)), with a hard cap on raw EIG evaluations (`eig_call_limit`) and an "
+            "outer-iteration cap (`eig_outer_iters`) enforced manually, logging a warning that the returned "
+            "batch may be \"under-optimized\" if either is hit; a diagonal jitter (`eig_jitter`, relative to the "
+            "GP signal variance) stabilizes the covariance solves and log-determinants. GP fits use the same "
+            "data-relative hyperparameter bounds and iteration caps as IES-IEKF."
+        ),
+        "params": [
+            {"Parameter": "IEKF ensemble size (n_posterior_samples)", "Value": "1000"},
+            {"Parameter": "IEKF step size / steps", "Value": "0.1 / 30 (T = 3)"},
+            {"Parameter": "n_eig_posterior_samples (EIG subsample X')", "Value": "50"},
+            {"Parameter": "eig_region / eig_ball_quantile", "Value": ":ball / 0.999 (χ² ball in prior-whitened space)"},
+            {"Parameter": "eig_optim_iters / eig_outer_iters", "Value": "500 / 20"},
+            {"Parameter": "eig_call_limit", "Value": "2000 EIG evaluations"},
+            {"Parameter": "eig_g_tol / eig_f_reltol", "Value": "1e-3 / 1e-6"},
+            {"Parameter": "eig_jitter", "Value": "1e-6 × GP signal variance"},
+            {"Parameter": "gp_optim_iters / gp_outer_iters", "Value": "50 / 3"},
+            {"Parameter": "batch_init_strategy", "Value": ":posterior_subsample"},
+            {"Parameter": "retain_var / retain_var_input", "Value": "0.99 / 0.99 (L63, L96 const), 0.9 (vec, flux)"},
+        ],
+        "notes": (
+            "**Adds the EIG batch optimization to IES-IEKF while keeping the cheap IEKF posterior**, so it avoids "
+            "ST-MCMC cost but still pays for the inner EIG-maximization loop, which costs ~n³ per output mode in "
+            "the subsample size and slows every iteration as the cumulative GP training set grows; hitting its "
+            "call or outer-iteration limits gives \"under-optimized\" batches. In the current UQ data (c = 1.5, "
+            "best ensemble size) it has the lowest mean budget of the four variants on L63 (4.8) and ties "
+            "GBOED-TMCMC on L96 const-force (4.4). On the two high-dimensional L96 cases it has low budgets "
+            "(55 on vec-force, 50 on NN flux-force) but fails on at least 35% and 40% of seeds, respectively, "
+            "at every ensemble size, so it is not suitable there under the 20% failure threshold."
+        ),
+    },
+    "IES-TMCMC": {
+        "citation": "Elsaesser et al., J. Adv. Model. Earth Syst., 2025",
+        "url": "https://doi.org/10.1029/2024MS004713",
+        "source": "`uq_experiments/BayesianOptimalExperimentalDesign` — `boed_core.jl` (`run_tmcmc`, `boed_loglik`, `acquire_batch`), variant `:tmcmc` (leaderboard key `boed-tmcmc`).",
+        "math": (
+            "An iterated emulate-sample loop. Iteration 1 forward-evaluates an "
+            "`N_ens`-point Latin-hypercube design in the truncated, prior-whitened parameter space. Each later "
+            "iteration: (i) refits one GP per whitened output mode on all `(θ, G(θ))` pairs collected so far; "
+            "(ii) draws posterior samples from the GP-based posterior via Transitional/Sequential MCMC "
+            "(Ching & Chen, 2007), using the GP-marginal Gaussian likelihood below; (iii) takes the next `N_ens` "
+            "forward-model evaluation points as a random subsample of those posterior draws. The batch is "
+            "forward-evaluated and appended to the training set, so each iteration emulates the forward model, "
+            "samples the posterior from the emulator, and spends its forward runs where that posterior has mass."
+        ),
+        "math_eq": r"\log p(y\mid z) = \sum_j \left[-\frac{(\mu_j(z)-y_j)^2}{2\,(1+\sigma_j^2(z))} - \frac{1}{2}\log\left(2\pi\,(1+\sigma_j^2(z))\right)\right]",
+        "guardrails": (
+            "The likelihood includes the GP predictive variance `σ_j²(z)` (the whitened observation noise is the "
+            "identity), so the posterior widens where the surrogate is uncertain, and keeps the normalizing "
+            "log(2π·v) term because ST-MCMC needs a properly normalized density. TMCMC runs with burn-in and "
+            "thinning below its own 20 / 3 defaults since they multiply per-stage cost. GP fits keep "
+            "hyperparameters inside data-relative bounds (±2 decades on length scales and signal std; noise std "
+            "between 1e-3 and 1 of the signal std) to avoid the near-zero-noise fits that ST-MCMC resampling "
+            "can collapse onto, with `Fminbox` capped at 50 inner / 3 outer iterations."
+        ),
+        "params": [
+            {"Parameter": "n_posterior_samples (TMCMC population)", "Value": "1000"},
+            {"Parameter": "tmcmc_burnin / tmcmc_thin", "Value": "5 / 1 (below TMCMC's 20 / 3 defaults)"},
+            {"Parameter": "batch size per iteration", "Value": "N_ens (random subsample of the TMCMC draws)"},
+            {"Parameter": "gp_optim_iters / gp_outer_iters", "Value": "50 / 3"},
+            {"Parameter": "retain_var (output whitening)", "Value": "0.99"},
+            {"Parameter": "retain_var_input (input whitening)", "Value": "0.99 (L63, L96 const) / 0.9 (vec, flux)"},
+        ],
+        "notes": (
+            "**The batch is a plain draw from the ST-MCMC posterior, with no batch optimization.** TMCMC cost grows roughly linearly with "
+            "the population size, and a small population gives a degenerate posterior in the high-dimensional "
+            "L96 cases. In the current UQ data (c = 1.5, best ensemble size) its mean budget is 6.4 on L63 and 5.6 on L96 "
+            "const-force, but on L96 vec-force it is 240 and it fails on at least 85% of seeds at every ensemble size."
+        ),
+    },
 }
 
 # KNOWN_METHODS is the source of truth for the abbreviation/full-name list,

src/pages/UQLeaderboard.py

@@ -35,7 +35,6 @@ render_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,

src/streamlit_app.py

@@ -5,11 +5,11 @@ import pandas as pd
 import streamlit as st
 
 try:
-    from common.method_registry import KNOWN_METHODS
+    from common.method_registry import KNOWN_METHODS, SUITABILITY_FAMILIES, family_full_name
     from common.leaderboard import _UPDATE_TYPE_ORDER
 except ModuleNotFoundError:
     sys.path.append(str(Path(__file__).resolve().parent))
-    from common.method_registry import KNOWN_METHODS
+    from common.method_registry import KNOWN_METHODS, SUITABILITY_FAMILIES, family_full_name
     from common.leaderboard import _UPDATE_TYPE_ORDER
 
 st.set_page_config(page_title="Calibration Benchmark", page_icon="🏠", layout="wide")
@@ -156,6 +156,18 @@ st.caption(
     "general), not whether a method is 'Bayesian'."
 )
 
+_family_key_rows = [
+    {"Family": family_full_name(fam), "Algorithms": ", ".join(members)}
+    for fam, members in SUITABILITY_FAMILIES.items()
+]
+st.markdown("**Method families** — algorithms of similar construction, used to group the suitability tables and method selectors:")
+st.dataframe(
+    pd.DataFrame(_family_key_rows),
+    hide_index=True,
+    use_container_width=True,
+    height=int((len(_family_key_rows) + 1) * 35.2 + 3),
+)
+
 st.subheader("Key metric")
 st.markdown(
     "The reported metric is the **mean number of forward-model evaluations** required "