sverdrup 0.1.0__py3-none-any.whl

sverdrup/__main__.py

@@ -0,0 +1,49 @@
+"""Runnable entry point: ``python -m sverdrup <config.json>``."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+from sverdrup.adapters.executor_dask import ExecutorConfig
+from sverdrup.adapters.odc.fixtures import FixtureSource
+from sverdrup.application.pipeline import PipelineInputs, run_pipeline
+
+
+def main(argv: list[str]) -> int:
+    """Run a config-driven pipeline, or print usage when no config is given.
+
+    Args:
+        argv: The process argv (``argv[1]`` is the config path).
+
+    Returns:
+        Process exit code (0 on success).
+    """
+    if len(argv) < 2:
+        print("usage: python -m sverdrup <config.json>")
+        return 0
+    cfg = json.loads(Path(argv[1]).read_text())
+    src = FixtureSource(cfg["obs_path"], cfg.get("ref_path"))
+    inp = PipelineInputs(
+        mode=cfg["mode"],
+        method_name=cfg["method"],
+        source=src,
+        out_url=cfg["out_url"],
+        lon_range=tuple(cfg["lon_range"]),
+        lat_range=tuple(cfg["lat_range"]),
+        time_range=tuple(cfg["time_range"]),
+        output_times=cfg["output_times"],
+        params=cfg["params"],
+        grid_resolution_deg=cfg.get("grid_resolution_deg", 1.0),
+        executor=ExecutorConfig(**cfg.get("executor", {})),
+        rank=cfg.get("rank", 20),
+    )
+    product, scores = run_pipeline(inp)
+    reported = {k: v for k, v in scores.items() if k != "context_keys"}
+    print(f"wrote {len(product.per_time)} time(s); scores={reported}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv))

sverdrup/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

sverdrup/adapters/executor_dask.py

@@ -0,0 +1,74 @@
+"""Executor adapter: dask.distributed LocalCluster with a per-run BLAS/OpenMP knob (spec 5.9)."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Any, cast
+
+from sverdrup.application.solve import solve_unit
+from sverdrup.application.uow import UnitOfWork
+from sverdrup.core.product import Product
+
+
+@dataclass(frozen=True)
+class ExecutorConfig:
+    """Executor sizing: processes, threads-per-process (BLAS cap), and scheduler seam."""
+
+    n_processes: int = 4
+    threads_per_process: int = 1
+    scheduler_address: str | None = None  # None -> spin up a LocalCluster
+
+
+def _thread_env(threads: int) -> dict[str, str]:
+    """Return the BLAS/OpenMP thread-cap environment for one worker."""
+    t = str(threads)
+    return {"OMP_NUM_THREADS": t, "OPENBLAS_NUM_THREADS": t, "MKL_NUM_THREADS": t}
+
+
+class DaskExecutor:
+    """The sole Phase-1 executor adapter. Scaling out changes only scheduler_address."""
+
+    def __init__(self, config: ExecutorConfig) -> None:
+        """Store config; the cluster/client are created on context entry.
+
+        Args:
+            config: The executor configuration.
+        """
+        self.config = config
+        self._cluster: Any = None
+        self._client: Any = None
+
+    def __enter__(self) -> DaskExecutor:
+        """Start (or connect to) the cluster and open a client."""
+        from distributed import Client, LocalCluster
+
+        if self.config.scheduler_address:
+            self._client = Client(self.config.scheduler_address)  # type: ignore[no-untyped-call]
+        else:
+            self._cluster = LocalCluster(  # type: ignore[no-untyped-call]
+                n_workers=self.config.n_processes,
+                threads_per_worker=1,
+                processes=True,
+                env=_thread_env(self.config.threads_per_process),
+            )
+            self._client = Client(self._cluster)  # type: ignore[no-untyped-call]
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        """Tear down the client and cluster on context exit."""
+        if self._client:
+            self._client.close()
+        if self._cluster:
+            self._cluster.close()
+
+    def worker_env_sample(self) -> dict[str, str]:
+        """Return one worker's BLAS/OpenMP environment (proves the cap is applied)."""
+        keys = _thread_env(self.config.threads_per_process)
+        result = self._client.run(lambda: {k: os.environ.get(k, "") for k in keys})
+        return cast(dict[str, str], result.popitem()[1])
+
+    def submit(self, unit_of_work: UnitOfWork) -> Product:
+        """Run ``solve_unit`` on a worker and return the resulting Product."""
+        future = self._client.submit(solve_unit, unit_of_work, pure=False)
+        return cast(Product, future.result())

sverdrup/adapters/odc/download.py

@@ -0,0 +1,56 @@
+"""ODC THREDDS cache: fetch whole files and OPeNDAP-subset, into ./data/cache/."""
+
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+
+import requests
+import xarray as xr
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+CACHE = Path("data/cache")
+
+
+class ODCCache:
+    """A local content cache for ODC THREDDS files under ``./data/cache/``."""
+
+    def __init__(self, root: Path = CACHE) -> None:
+        """Create the cache root if needed.
+
+        Args:
+            root: The cache directory.
+        """
+        self.root = root
+        self.root.mkdir(parents=True, exist_ok=True)
+
+    def path_for(self, url: str) -> Path:
+        """Return the deterministic cache path for ``url``."""
+        h = hashlib.blake2b(url.encode(), digest_size=8).hexdigest()
+        return self.root / f"{h}_{url.rsplit('/', 1)[-1]}"
+
+    @retry(stop=stop_after_attempt(4), wait=wait_exponential(multiplier=1, max=30))
+    def fetch_file(self, url: str) -> Path:
+        """Download ``url`` to the cache (skipped if already present).
+
+        Args:
+            url: The file URL.
+
+        Returns:
+            The local cache path.
+        """
+        dest = self.path_for(url)
+        if dest.exists():
+            return dest
+        with requests.get(url, stream=True, timeout=120) as r:
+            r.raise_for_status()
+            tmp = dest.with_suffix(".part")
+            with tmp.open("wb") as f:
+                for chunk in r.iter_content(1 << 20):
+                    f.write(chunk)
+            tmp.replace(dest)
+        return dest
+
+    def open_dodsC(self, opendap_url: str) -> xr.Dataset:
+        """Open an OPeNDAP dataset lazily (no full download)."""
+        return xr.open_dataset(opendap_url)

sverdrup/adapters/odc/fixtures.py

@@ -0,0 +1,87 @@
+"""Offline fixture data-source for deterministic CI (wraps the same interface as ODC)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import dask.array as da
+import numpy as np
+import xarray as xr
+
+from sverdrup.core.observations import DiagonalErrorModel, ObsWindow
+from sverdrup.core.types import Field
+
+if TYPE_CHECKING:
+    from sverdrup.core.grid import GridSpec
+
+Range = tuple[float, float]
+
+
+class FixtureSource:
+    """A NetCDF-backed data source matching the ODC ``DataSource``/truth interface."""
+
+    def __init__(
+        self, obs_path: str, ref_path: str | None = None, noise: float = 0.01
+    ) -> None:
+        """Open the observation (and optional reference) datasets.
+
+        Args:
+            obs_path: Path to the along-track observation NetCDF.
+            ref_path: Optional path to the gridded reference NetCDF (OSSE truth).
+            noise: Per-observation error variance for the diagonal error model.
+        """
+        self._obs = xr.open_dataset(obs_path)
+        self._ref = xr.open_dataset(ref_path) if ref_path else None
+        self._noise = noise
+
+    def window(
+        self, *, lon_range: Range, lat_range: Range, time_range: Range
+    ) -> ObsWindow:
+        """Return a lazily-backed ``ObsWindow`` over the requested space-time box.
+
+        Args:
+            lon_range: Inclusive longitude bounds in degrees.
+            lat_range: Inclusive latitude bounds in degrees.
+            time_range: Inclusive time bounds in days.
+
+        Returns:
+            An ``ObsWindow`` whose values stay dask-lazy until materialised.
+        """
+        ds = self._obs
+        m = (
+            (ds.longitude >= lon_range[0])
+            & (ds.longitude <= lon_range[1])
+            & (ds.latitude >= lat_range[0])
+            & (ds.latitude <= lat_range[1])
+            & (ds.time >= time_range[0])
+            & (ds.time <= time_range[1])
+        )
+        sub = ds.where(m, drop=True)
+        n = int(sub.sizes["t"])
+        return ObsWindow.from_arrays(
+            sub.longitude.values,
+            sub.latitude.values,
+            sub.time.values,
+            da.from_array(sub.sla.values, chunks=max(1, n // 2)),  # type: ignore[no-untyped-call]
+            DiagonalErrorModel(np.full(n, self._noise)),
+            mission=sub.mission.values,
+        )
+
+    def truth(self, time_days: float, grid: GridSpec) -> Field | None:
+        """Return the reference field interpolated to grid nodes, or ``None`` for OSE.
+
+        Args:
+            time_days: The output time in days.
+            grid: The output grid.
+
+        Returns:
+            The ``(ny, nx)`` reference field, or ``None`` when no reference is set.
+        """
+        if self._ref is None:
+            return None
+        snap = self._ref.ssh.interp(time=time_days)
+        lon, lat = grid._lonlat_nodes()
+        vals = snap.interp(
+            longitude=("z", lon.ravel()), latitude=("z", lat.ravel())
+        ).values
+        return np.asarray(vals).reshape(grid.shape)

sverdrup/adapters/odc/natl60.py

@@ -0,0 +1,29 @@
+"""OSSE NATL60 source: nadir obs (whole) + daily CJM165 reference clipped to the eval window."""
+
+from __future__ import annotations
+
+from sverdrup.adapters.odc.download import ODCCache
+from sverdrup.adapters.odc.fixtures import FixtureSource
+
+WINDOW = ("2012-10-22", "2012-12-02")  # 42-day eval window
+OBS_URL = (
+    "https://tds.../2020a_SSH_mapping_NATL60/dc_obs/...tar.gz"  # documented endpoint
+)
+REF_DAILY_URL = "https://tds.../NATL60-CJM165/...daily...nc"
+
+
+class Natl60Source(FixtureSource):
+    """Phase-1 OSSE source. Until cached data is present, behaves as a FixtureSource."""
+
+    def __init__(
+        self, obs_path: str, ref_path: str, cache: ODCCache | None = None
+    ) -> None:
+        """Open the OSSE obs + daily reference (delegating to the fixture interface).
+
+        Args:
+            obs_path: Path to the nadir observation dataset.
+            ref_path: Path to the clipped daily reference dataset.
+            cache: Optional ODC cache (created on demand if omitted).
+        """
+        super().__init__(obs_path, ref_path)
+        self.cache = cache or ODCCache()

sverdrup/adapters/odc/ose.py

@@ -0,0 +1,31 @@
+"""OSE source: real along-track inputs; withheld CryoSat-2 as the independent eval signal."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from sverdrup.adapters.odc.fixtures import FixtureSource
+
+
+class OseSource(FixtureSource):
+    """Phase-1 OSE source. Truth is absent; CryoSat-2 is withheld for evaluation."""
+
+    def __init__(self, obs_path: str) -> None:
+        """Open the OSE along-track inputs (no reference truth).
+
+        Args:
+            obs_path: Path to the along-track observation dataset.
+        """
+        super().__init__(obs_path, ref_path=None)
+
+    def withheld(self) -> tuple[np.ndarray, np.ndarray]:
+        """Return the withheld CryoSat-2 along-track as ``(locations, values)``.
+
+        Returns:
+            A ``((k, 3), (k,))`` tuple of ``(lon, lat, time)`` locations and SLA values.
+        """
+        c2 = self._obs.where(self._obs.mission == "c2", drop=True)
+        locs = np.column_stack(
+            [c2.longitude.values, c2.latitude.values, c2.time.values]
+        )
+        return locs, np.asarray(c2.sla.values)

sverdrup/adapters/storage_fsspec.py

@@ -0,0 +1,128 @@
+"""Local fsspec result-sink writing the persisted Product bundle + provenance (spec 5.8)."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import fsspec  # type: ignore[import-untyped]
+import numpy as np
+from fsspec import AbstractFileSystem
+
+from sverdrup.core.grid import GridSpec
+from sverdrup.core.product import PerTimeProduct, Product
+from sverdrup.core.provenance import ProductProvenance, UncertaintyProvenance
+from sverdrup.core.types import UncertaintyCapability
+from sverdrup.distributions.persisted import PersistedDistribution, PersistedFields
+
+
+def _prov_to_json(p: ProductProvenance) -> dict[str, Any]:
+    """Serialise product provenance to a JSON-safe dict."""
+    return {
+        "method": p.method,
+        "params_key": p.params_key,
+        "seed": p.seed,
+        "split_id": p.split_id,
+        "code_version": p.code_version,
+        "native_capability": p.uncertainty.native_capability.name,
+    }
+
+
+def _save_array(fs: AbstractFileSystem, path: str, arr: np.ndarray) -> None:
+    """Write a numpy array to ``path`` on filesystem ``fs``."""
+    with fs.open(path, "wb") as f:
+        np.save(f, arr)
+
+
+def _load_array(fs: AbstractFileSystem, path: str) -> np.ndarray:
+    """Read a numpy array from ``path`` on filesystem ``fs``."""
+    with fs.open(path, "rb") as f:
+        return np.asarray(np.load(f))
+
+
+class FsspecResultSink:
+    """Persists a Product bundle to any fsspec URL as per-time arrays + a JSON manifest."""
+
+    def write(self, product: Product, path: str) -> None:
+        """Write ``product`` to ``path`` (an fsspec URL).
+
+        Args:
+            product: The persisted Product bundle.
+            path: The destination fsspec URL (e.g. ``file://.../prod.zarr``).
+        """
+        fs, root = fsspec.core.url_to_fs(path)
+        fs.makedirs(root, exist_ok=True)
+        per_time_meta: list[dict[str, Any]] = []
+        for i, pt in enumerate(product.per_time):
+            base = pt.base
+            grp = f"{root}/t{i}"
+            fs.makedirs(grp, exist_ok=True)
+            arrays = {
+                "mean": base.fields.mean,
+                "marginal_variance": base.fields.marginal_variance,
+                "factor": base.fields.factor,
+                "residual": base.fields.residual,
+                "x": base.grid.x,
+                "y": base.grid.y,
+            }
+            for name, arr in arrays.items():
+                _save_array(fs, f"{grp}/{name}.npy", arr)
+            per_time_meta.append(
+                {
+                    "time_days": pt.time_days,
+                    "rank": base.fields.rank,
+                    "captured_energy": base.fields.captured_energy,
+                    "provenance": _prov_to_json(pt.provenance),
+                }
+            )
+        manifest = {
+            "times": product.times(),
+            "run": product.run_manifest,
+            "per_time": per_time_meta,
+        }
+        with fs.open(f"{root}/manifest.json", "w") as f:
+            json.dump(manifest, f)
+
+
+def read_product(path: str) -> Product:
+    """Reconstruct a Product bundle previously written by ``FsspecResultSink``.
+
+    Args:
+        path: The fsspec URL the product was written to.
+
+    Returns:
+        The reconstructed Product (persisted representation, not sample maps).
+    """
+    fs, root = fsspec.core.url_to_fs(path)
+    with fs.open(f"{root}/manifest.json") as f:
+        manifest = json.load(f)
+    per_time: list[PerTimeProduct] = []
+    for i, meta in enumerate(manifest["per_time"]):
+        grp = f"{root}/t{i}"
+        prov_meta = meta["provenance"]
+        fields = PersistedFields(
+            mean=_load_array(fs, f"{grp}/mean.npy"),
+            marginal_variance=_load_array(fs, f"{grp}/marginal_variance.npy"),
+            factor=_load_array(fs, f"{grp}/factor.npy"),
+            residual=_load_array(fs, f"{grp}/residual.npy"),
+            rank=meta["rank"],
+            seed=prov_meta["seed"],
+            captured_energy=meta["captured_energy"],
+        )
+        grid = GridSpec.lonlat(
+            _load_array(fs, f"{grp}/x.npy"), _load_array(fs, f"{grp}/y.npy")
+        )
+        prov = ProductProvenance(
+            method=prov_meta["method"],
+            params_key=prov_meta["params_key"],
+            seed=prov_meta["seed"],
+            split_id=prov_meta["split_id"],
+            code_version=prov_meta["code_version"],
+            input_manifest={},
+            uncertainty=UncertaintyProvenance(
+                UncertaintyCapability[prov_meta["native_capability"]], []
+            ),
+        )
+        dist = PersistedDistribution(grid, fields, prov.uncertainty, meta["time_days"])
+        per_time.append(PerTimeProduct(meta["time_days"], dist, {}, None, prov))
+    return Product(per_time=per_time, run_manifest=manifest["run"])

sverdrup/application/config.py

@@ -0,0 +1,24 @@
+"""Run configuration value objects."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from sverdrup.adapters.executor_dask import ExecutorConfig
+
+
+@dataclass(frozen=True)
+class RunConfig:
+    """The full specification of one pipeline run (OSSE or OSE)."""
+
+    mode: str  # "OSSE" | "OSE"
+    method_name: str
+    params: dict[str, float]
+    lon_range: tuple[float, float]
+    lat_range: tuple[float, float]
+    time_range: tuple[float, float]
+    output_times: list[float]
+    grid_resolution_deg: float = 0.25
+    executor: ExecutorConfig = field(default_factory=ExecutorConfig)
+    split_by: str = "mission"
+    rank: int = 40

sverdrup/application/pipeline.py

@@ -0,0 +1,167 @@
+"""End-to-end pipeline wiring: source -> executor.solve -> evaluate -> sink (spec 7)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, cast
+
+import numpy as np
+
+from sverdrup.adapters.executor_dask import DaskExecutor, ExecutorConfig
+from sverdrup.adapters.storage_fsspec import FsspecResultSink
+from sverdrup.application.splits import make_splits
+from sverdrup.application.uow import UnitOfWork
+from sverdrup.core.evaluation import ContextKey, EvalContext, Registry
+from sverdrup.core.grid import GridSpec
+from sverdrup.core.observations import DiagonalErrorModel, ObsWindow
+from sverdrup.core.parameters import ConstantProvider
+from sverdrup.core.product import Product
+from sverdrup.core.seeding import derive_seed
+from sverdrup.eval.accuracy import Accuracy
+from sverdrup.eval.calibration import Calibration
+from sverdrup.eval.groundtrack import GroundTrack
+
+Range = tuple[float, float]
+
+
+@dataclass
+class PipelineInputs:
+    """All inputs to one end-to-end pipeline run (OSSE or OSE)."""
+
+    mode: str
+    method_name: str
+    source: object
+    out_url: str
+    lon_range: Range
+    lat_range: Range
+    time_range: Range
+    output_times: list[float]
+    params: dict[str, float]
+    grid_resolution_deg: float = 1.0
+    executor: ExecutorConfig = field(default_factory=ExecutorConfig)
+    rank: int = 20
+
+
+def _grid(inp: PipelineInputs) -> GridSpec:
+    """Build the regular lon/lat output grid for the run."""
+    lons = np.arange(inp.lon_range[0], inp.lon_range[1] + 1e-9, inp.grid_resolution_deg)
+    lats = np.arange(inp.lat_range[0], inp.lat_range[1] + 1e-9, inp.grid_resolution_deg)
+    return GridSpec.lonlat(lons, lats)
+
+
+def run_pipeline(inp: PipelineInputs) -> tuple[Product, dict[str, Any]]:
+    """Run source -> dask solve -> sink -> evaluate and return ``(product, scores)``.
+
+    Args:
+        inp: The pipeline inputs.
+
+    Returns:
+        The persisted Product and the evaluator score dictionary.
+    """
+    grid = _grid(inp)
+    src = cast(Any, inp.source)
+    obs = src.window(
+        lon_range=inp.lon_range, lat_range=inp.lat_range, time_range=inp.time_range
+    )
+    train_obs, eval_locs, withheld_vals = _prepare(inp, obs)
+    params = ConstantProvider(inp.params)
+    seed = derive_seed(inp.method_name, params.params_key(), "tile0", 0)
+    uow = UnitOfWork(
+        "tile0",
+        inp.method_name,
+        params,
+        "train",
+        seed,
+        inp.output_times,
+        train_obs,
+        grid,
+        eval_locations=eval_locs,
+        derived_names=["firstdifference"],
+        rank=inp.rank,
+    )
+
+    with DaskExecutor(inp.executor) as ex:
+        product = ex.submit(uow)
+
+    FsspecResultSink().write(product, inp.out_url)
+    scores = _evaluate(inp, product, grid, eval_locs, withheld_vals)
+    return product, scores
+
+
+def _subset_obs(obs: ObsWindow, idx: np.ndarray) -> ObsWindow:
+    """Return the sub-window of ``obs`` at the given indices (preserves error variances)."""
+    coords = obs.coords()
+    var = np.diag(obs.error_model.as_matrix(len(obs)))
+    mission = obs.mission[idx] if obs.mission is not None else None
+    return ObsWindow.from_arrays(
+        coords[idx, 0],
+        coords[idx, 1],
+        coords[idx, 2],
+        obs.values()[idx],
+        DiagonalErrorModel(var[idx]),
+        mission=mission,
+    )
+
+
+def _prepare(
+    inp: PipelineInputs, obs: ObsWindow
+) -> tuple[ObsWindow, np.ndarray | None, np.ndarray | None]:
+    """Return ``(train_obs, eval_locations, withheld_values)``.
+
+    OSSE trains on all observations (truth supplies evaluation). OSE withholds the
+    CryoSat-2 mission from training and returns its locations/values for evaluation,
+    so the eval signal is genuinely independent (no autocorrelation leak).
+    """
+    if inp.mode == "OSE" and obs.mission is not None:
+        split = make_splits(obs, by="mission", locked_missions=["c2"])
+        train_obs = _subset_obs(obs, split.train_idx)
+        coords = obs.coords()
+        eval_locs = coords[split.locked_test_idx].copy()
+        eval_locs[:, 2] = inp.output_times[0]
+        withheld_vals = obs.values()[split.locked_test_idx]
+        return train_obs, eval_locs, withheld_vals
+    return obs, None, None
+
+
+def _evaluate(
+    inp: PipelineInputs,
+    product: Product,
+    grid: GridSpec,
+    eval_locs: np.ndarray | None,
+    withheld_vals: np.ndarray | None,
+) -> dict[str, Any]:
+    """Assemble the evaluation context and run every applicable evaluator.
+
+    OSSE calibrates/scores against the gridded truth; OSE scores against the
+    withheld CryoSat-2 along-track at the exact eval-point predictions. The
+    evaluator spine is identical — only the source and context differ.
+    """
+    pt = product.per_time[0]
+    base = pt.base
+    items: dict[ContextKey, object] = {
+        ContextKey.ORBIT_GEOMETRY: {"track_spacing_nodes": 4}
+    }
+    result: dict[str, np.ndarray] = {
+        "field": base.fields.mean,
+        "grid_mean": base.fields.mean,
+    }
+    if inp.mode == "OSSE":
+        truth = cast(Any, inp.source).truth(inp.output_times[0], grid)
+        truth = np.asarray(truth)
+        items[ContextKey.TRUTH] = {"field": truth}
+        items[ContextKey.WITHHELD_OBS] = {"values": truth.ravel()}
+        result["eval_mean"] = base.fields.mean.ravel()
+        result["eval_var"] = base.marginal_variance().ravel()
+    elif (
+        eval_locs is not None
+        and withheld_vals is not None
+        and pt.eval_points is not None
+    ):
+        items[ContextKey.WITHHELD_OBS] = {"values": withheld_vals}
+        result["eval_mean"] = pt.eval_points.mean
+        result["eval_var"] = pt.eval_points.variance
+    ctx = EvalContext(items)
+    reg = Registry([Accuracy(), Calibration(), GroundTrack(track_wavenumber=4)])
+    scores: dict[str, Any] = dict(reg.run(result, ctx))
+    scores["context_keys"] = {k.name for k in ctx.keys()}
+    return scores