climate-ref-pmp 0.5.0__py3-none-any.whl

climate_ref_pmp/__init__.py

@@ -0,0 +1,32 @@
+"""
+Rapid evaluating CMIP data
+"""
+
+import importlib.metadata
+
+from climate_ref_core.dataset_registry import dataset_registry_manager
+from climate_ref_core.providers import CondaDiagnosticProvider
+from climate_ref_pmp.diagnostics import AnnualCycle, ExtratropicalModesOfVariability
+
+__version__ = importlib.metadata.version("climate-ref-pmp")
+
+# Create the PMP diagnostics provider
+# PMP uses a conda environment to run the diagnostics
+provider = CondaDiagnosticProvider("PMP", __version__)
+
+provider.register(ExtratropicalModesOfVariability("PDO"))
+provider.register(ExtratropicalModesOfVariability("NPGO"))
+provider.register(ExtratropicalModesOfVariability("NAO"))
+provider.register(ExtratropicalModesOfVariability("NAM"))
+provider.register(ExtratropicalModesOfVariability("PNA"))
+provider.register(ExtratropicalModesOfVariability("NPO"))
+provider.register(ExtratropicalModesOfVariability("SAM"))
+provider.register(AnnualCycle())
+
+
+dataset_registry_manager.register(
+    "pmp-climatology",
+    "https://pub-b093171261094c4ea9adffa01f94ee06.r2.dev/",
+    package="climate_ref_pmp.dataset_registry",
+    resource="pmp_climatology.txt",
+)

climate_ref_pmp/dataset_registry/pmp_climatology.txt

@@ -0,0 +1,25 @@
+PMP_obs4MIPsClims/pr/gr/v20250211/pr_mon_GPCP-Monthly-3-2_RSS_gr_198301-200412_AC_v20250211_interp_2.5x2.5.nc md5:02661bfe30f79b162619a960de08784d
+PMP_obs4MIPsClims/psl/gr/v20250224/psl_mon_ERA-5_PCMDI_gr_198101-200412_AC_v20250224_2.5x2.5.nc md5:098fddaadcc4b5b72771dc493293f68c
+PMP_obs4MIPsClims/rldscs/gr/v20250213/rldscs_mon_CERES-EBAF-4-2_RSS_gr_200101-200412_AC_v20250213_2.5x2.5.nc md5:f6ce612860eed79c04577f6bf53de6b8
+PMP_obs4MIPsClims/rlds/gr/v20250213/rlds_mon_CERES-EBAF-4-2_RSS_gr_200101-200412_AC_v20250213_2.5x2.5.nc md5:fe229671795fffc1209e364cdde6bc58
+PMP_obs4MIPsClims/rltcre/gr/v20250213/rltcre_mon_CERES-EBAF-4-2_RSS_gr_200101-200412_AC_v20250213_2.5x2.5.nc md5:28a2ea1301454f1c65381aaf18dc927f
+PMP_obs4MIPsClims/rlus/gr/v20250213/rlus_mon_CERES-EBAF-4-2_RSS_gr_200101-200412_AC_v20250213_2.5x2.5.nc md5:c29d0182a759aeaf62a741b8b277bd31
+PMP_obs4MIPsClims/rlutcs/gr/v20250213/rlutcs_mon_CERES-EBAF-4-2_RSS_gr_200101-200412_AC_v20250213_2.5x2.5.nc md5:d8255cb36020f616131e6abc3623c0ff
+PMP_obs4MIPsClims/rlut/gr/v20250213/rlut_mon_CERES-EBAF-4-2_RSS_gr_200101-200412_AC_v20250213_2.5x2.5.nc md5:92427d58e789c28e69d4e7ad7f10f78a
+PMP_obs4MIPsClims/rsdscs/gr/v20250213/rsdscs_mon_CERES-EBAF-4-2_RSS_gr_200101-200412_AC_v20250213_2.5x2.5.nc md5:4f7693ee9c739f8891d38430030d5d0f
+PMP_obs4MIPsClims/rsds/gr/v20250213/rsds_mon_CERES-EBAF-4-2_RSS_gr_200101-200412_AC_v20250213_2.5x2.5.nc md5:631b4d9168fd4b558f1db8f3dc7d9fd8
+PMP_obs4MIPsClims/rsdt/gr/v20250213/rsdt_mon_CERES-EBAF-4-2_RSS_gr_200101-200412_AC_v20250213_2.5x2.5.nc md5:6908e55d39dce5c696c2016c7a668759
+PMP_obs4MIPsClims/rstcre/gr/v20250213/rstcre_mon_CERES-EBAF-4-2_RSS_gr_200101-200412_AC_v20250213_2.5x2.5.nc md5:dcb2ec36efcac91fb1060b4f53b9dc3a
+PMP_obs4MIPsClims/rsuscs/gr/v20250213/rsuscs_mon_CERES-EBAF-4-2_RSS_gr_200101-200412_AC_v20250213_2.5x2.5.nc md5:0e06fdbab1f44a14d85774a65d3a97ab
+PMP_obs4MIPsClims/rsus/gr/v20250213/rsus_mon_CERES-EBAF-4-2_RSS_gr_200101-200412_AC_v20250213_2.5x2.5.nc md5:6ff6cf0d715bb12a4cceb5c05531682b
+PMP_obs4MIPsClims/rsutcs/gr/v20250213/rsutcs_mon_CERES-EBAF-4-2_RSS_gr_200101-200412_AC_v20250213_2.5x2.5.nc md5:982914ff7f625f43d6a86f5ab3dbf951
+PMP_obs4MIPsClims/rsut/gr/v20250213/rsut_mon_CERES-EBAF-4-2_RSS_gr_200101-200412_AC_v20250213_2.5x2.5.nc md5:36aee3f4ce60e468e0a5027482960e3b
+PMP_obs4MIPsClims/rt/gr/v20250213/rt_mon_CERES-EBAF-4-2_RSS_gr_200101-200412_AC_v20250213_2.5x2.5.nc md5:8904dfea492b121e7e4252ca340e782f
+PMP_obs4MIPsClims/ta/gr/v20250224/ta_mon_ERA-5_PCMDI_gr_198101-200412_AC_v20250224_2.5x2.5.nc md5:185f9c4382e1585bf4c91f30af371471
+PMP_obs4MIPsClims/tas/gr/v20250224/tas_mon_ERA-5_PCMDI_gr_198101-200412_AC_v20250224_2.5x2.5.nc md5:e9b825a3fcb8d246537dbf7533d0a85d
+PMP_obs4MIPsClims/ts/gr/v20250224/ts_mon_ERA-5_PCMDI_gr_198101-200412_AC_v20250224_2.5x2.5.nc md5:66df004506ddab80d980a37ede4b6298
+PMP_obs4MIPsClims/ua/gr/v20250224/ua_mon_ERA-5_PCMDI_gr_198101-200412_AC_v20250224_2.5x2.5.nc md5:267cf48858a079a500b1b6fc348f6411
+PMP_obs4MIPsClims/uas/gr/v20250224/uas_mon_ERA-5_PCMDI_gr_198101-200412_AC_v20250224_2.5x2.5.nc md5:7a31d4b16710d698805c601af4977065
+PMP_obs4MIPsClims/va/gr/v20250225/va_mon_ERA-5_PCMDI_gr_198101-200412_AC_v20250225_2.5x2.5.nc md5:f8ad5d3d6c7e31f4c76619ea3242f1ff
+PMP_obs4MIPsClims/vas/gr/v20250225/vas_mon_ERA-5_PCMDI_gr_198101-200412_AC_v20250225_2.5x2.5.nc md5:f009b3fd04e65f80e3336f2be8c99e05
+PMP_obs4MIPsClims/zg/gr/v20250225/zg_mon_ERA-5_PCMDI_gr_198101-200412_AC_v20250225_2.5x2.5.nc md5:6d20c4e668cc5c31920162cab0cb5579

climate_ref_pmp/diagnostics/__init__.py

@@ -0,0 +1,9 @@
+"""PMP diagnostics."""
+
+from climate_ref_pmp.diagnostics.annual_cycle import AnnualCycle
+from climate_ref_pmp.diagnostics.variability_modes import ExtratropicalModesOfVariability
+
+__all__ = [
+    "AnnualCycle",
+    "ExtratropicalModesOfVariability",
+]

climate_ref_pmp/diagnostics/annual_cycle.py

@@ -0,0 +1,337 @@
+import datetime
+import json
+from collections.abc import Iterable
+from typing import Any
+
+from loguru import logger
+
+from climate_ref_core.datasets import FacetFilter, SourceDatasetType
+from climate_ref_core.diagnostics import (
+    CommandLineDiagnostic,
+    DataRequirement,
+    ExecutionDefinition,
+    ExecutionResult,
+)
+from climate_ref_pmp.pmp_driver import build_glob_pattern, build_pmp_command, process_json_result
+
+
+class AnnualCycle(CommandLineDiagnostic):
+    """
+    Calculate the annual cycle for a dataset
+    """
+
+    name = "Annual Cycle"
+    slug = "annual-cycle"
+    facets = ("model", "realization", "reference", "mode", "season", "method", "statistic")
+    data_requirements = (
+        # Surface temperature
+        (
+            DataRequirement(
+                source_type=SourceDatasetType.PMPClimatology,
+                filters=(FacetFilter(facets={"source_id": ("ERA-5",), "variable_id": ("ts",)}),),
+                group_by=("variable_id", "source_id"),
+            ),
+            DataRequirement(
+                source_type=SourceDatasetType.CMIP6,
+                filters=(
+                    FacetFilter(
+                        facets={
+                            "frequency": "mon",
+                            "experiment_id": ("amip", "historical", "hist-GHG", "piControl"),
+                            "variable_id": ("ts",),
+                        }
+                    ),
+                ),
+                group_by=("variable_id", "source_id", "experiment_id", "member_id"),
+            ),
+        ),
+        # Precipitation
+        (
+            DataRequirement(
+                source_type=SourceDatasetType.PMPClimatology,
+                filters=(FacetFilter(facets={"source_id": ("GPCP-Monthly-3-2",), "variable_id": ("pr",)}),),
+                group_by=("variable_id", "source_id"),
+            ),
+            DataRequirement(
+                source_type=SourceDatasetType.CMIP6,
+                filters=(
+                    FacetFilter(
+                        facets={
+                            "frequency": "mon",
+                            "experiment_id": ("amip", "historical", "hist-GHG", "piControl"),
+                            "variable_id": ("pr",),
+                        }
+                    ),
+                ),
+                group_by=("variable_id", "source_id", "experiment_id", "member_id"),
+            ),
+        ),
+    )
+
+    def __init__(self) -> None:
+        self.parameter_file_1 = "pmp_param_annualcycle_1-clims.py"
+        self.parameter_file_2 = "pmp_param_annualcycle_2-metrics.py"
+
+    def build_cmd(self, definition: ExecutionDefinition) -> Iterable[str]:
+        """
+        Build the command to run the diagnostic
+
+        Parameters
+        ----------
+        definition
+            Definition of the diagnostic execution
+
+        Returns
+        -------
+            Command arguments to execute in the PMP environment
+        """
+        raise NotImplementedError("Function not required")
+
+    def build_cmds(self, definition: ExecutionDefinition) -> list[list[str]]:
+        """
+        Build the command to run the diagnostic
+
+        Parameters
+        ----------
+        definition
+            Definition of the diagnostic execution
+
+        Returns
+        -------
+            Command arguments to execute in the PMP environment
+        """
+        input_datasets = definition.datasets[SourceDatasetType.CMIP6]
+        source_id = input_datasets["source_id"].unique()[0]
+        experiment_id = input_datasets["experiment_id"].unique()[0]
+        member_id = input_datasets["member_id"].unique()[0]
+        variable_id = input_datasets["variable_id"].unique()[0]
+
+        logger.debug(f"input_datasets['source_id'].unique(): {input_datasets['source_id'].unique()}")
+        logger.debug(f"input_datasets['experiment_id'].unique(): {input_datasets['experiment_id'].unique()}")
+        logger.debug(f"input_datasets['member_id'].unique(): {input_datasets['member_id'].unique()}")
+        logger.debug(f"input_datasets['variable_id'].unique(): {input_datasets['variable_id'].unique()}")
+
+        model_files_raw = input_datasets.path.to_list()
+        if len(model_files_raw) == 1:
+            model_files = model_files_raw[0]  # If only one file, use it directly
+        elif len(model_files_raw) > 1:
+            model_files = build_glob_pattern(model_files_raw)  # If multiple files, build a glob pattern
+        else:
+            raise ValueError("No model files found")
+
+        logger.debug("build_cmd start")
+
+        logger.debug(f"input_datasets: {input_datasets}")
+        logger.debug(f"input_datasets.keys(): {input_datasets.keys()}")
+        logger.debug(f"input_datasets['variable_id']: {input_datasets['variable_id']}")
+
+        logger.debug(f"source_id: {source_id}")
+        logger.debug(f"experiment_id: {experiment_id}")
+        logger.debug(f"member_id: {member_id}")
+        logger.debug(f"variable_id: {variable_id}")
+
+        reference_dataset = definition.datasets[SourceDatasetType.PMPClimatology]
+        reference_dataset_name = reference_dataset["source_id"].unique()[0]
+        reference_dataset_path = reference_dataset.datasets.iloc[0]["path"]
+
+        logger.debug(f"reference_dataset.datasets: {reference_dataset.datasets}")
+        logger.debug(f"reference_dataset['source_id']: {reference_dataset['source_id']}")
+        logger.debug(
+            f"reference_dataset.datasets.iloc[0]['path']: {reference_dataset.datasets.iloc[0]['path']}"
+        )
+
+        logger.debug(f"reference_dataset_name: {reference_dataset_name}")
+        logger.debug(f"reference_dataset_path: {reference_dataset_path}")
+
+        output_directory_path = str(definition.output_directory)
+
+        cmds = []
+
+        # ----------------------------------------------
+        # PART 1: Build the command to get climatologies
+        # ----------------------------------------------
+        # Model
+        data_name = f"{source_id}_{experiment_id}_{member_id}"
+        data_path = model_files
+        params = {
+            "driver_file": "mean_climate/pcmdi_compute_climatologies.py",
+            "parameter_file": self.parameter_file_1,
+            "vars": variable_id,
+            "infile": data_path,
+            "outfile": f"{output_directory_path}/{variable_id}_{data_name}_clims.nc",
+        }
+
+        cmds.append(build_pmp_command(**params))
+
+        # ----------------------------------------------
+        # PART 2: Build the command to calculate diagnostics
+        # ----------------------------------------------
+
+        # Reference
+        obs_dict = {
+            variable_id: {
+                reference_dataset_name: {
+                    "template": reference_dataset_path,
+                },
+                "default": reference_dataset_name,
+            }
+        }
+
+        # Generate a JSON file based on the obs_dict
+        with open(f"{output_directory_path}/obs_dict.json", "w") as f:
+            json.dump(obs_dict, f)
+
+        date = datetime.datetime.now().strftime("%Y%m%d")
+
+        params = {
+            "driver_file": "mean_climate/mean_climate_driver.py",
+            "parameter_file": self.parameter_file_2,
+            "vars": variable_id,
+            "custom_observations": f"{output_directory_path}/obs_dict.json",
+            "test_data_path": output_directory_path,
+            "test_data_set": source_id,
+            "realization": member_id,
+            "filename_template": f"{variable_id}_{data_name}_clims.198101-200512.AC.v{date}.nc",
+            "metrics_output_path": output_directory_path,
+            "cmec": "",
+        }
+
+        cmds.append(build_pmp_command(**params))
+
+        return cmds
+
+    def build_execution_result(self, definition: ExecutionDefinition) -> ExecutionResult:
+        """
+        Build a diagnostic result from the output of the PMP driver
+
+        Parameters
+        ----------
+        definition
+            Definition of the diagnostic execution
+
+        Returns
+        -------
+            Result of the diagnostic execution
+        """
+        input_datasets = definition.datasets[SourceDatasetType.CMIP6]
+        variable_id = input_datasets["variable_id"].unique()[0]
+
+        results_directory = definition.output_directory
+        png_directory = results_directory / variable_id
+        data_directory = results_directory / variable_id
+
+        logger.debug(f"results_directory: {results_directory}")
+        logger.debug(f"png_directory: {png_directory}")
+        logger.debug(f"data_directory: {data_directory}")
+
+        # Find the executions file
+        results_files = list(results_directory.glob("*_cmec.json"))
+        if len(results_files) != 1:  # pragma: no cover
+            return ExecutionResult.build_from_failure(definition)
+        else:
+            results_file = results_files[0]
+            logger.debug(f"results_file: {results_file}")
+
+        # Rewrite executions file for compatibility
+        with open(results_file) as f:
+            results = json.load(f)
+            results_transformed = _transform_results(results)
+
+        # Get the stem (filename without extension)
+        stem = results_file.stem
+
+        # Create the new filename
+        results_file_transformed = results_file.with_name(f"{stem}_transformed.json")
+
+        with open(results_file_transformed, "w") as f:
+            # Write the transformed executions back to the file
+            json.dump(results_transformed, f, indent=4)
+            logger.debug(f"Transformed executions written to {results_file_transformed}")
+
+        # Find the other outputs
+        png_files = list(png_directory.glob("*.png"))
+        data_files = list(data_directory.glob("*.nc"))
+
+        cmec_output, cmec_metric = process_json_result(results_file_transformed, png_files, data_files)
+
+        return ExecutionResult.build_from_output_bundle(
+            definition,
+            cmec_output_bundle=cmec_output,
+            cmec_metric_bundle=cmec_metric,
+        )
+
+    def run(self, definition: ExecutionDefinition) -> ExecutionResult:
+        """
+        Run the diagnostic on the given configuration.
+
+        Parameters
+        ----------
+        definition : ExecutionDefinition
+            The configuration to run the diagnostic on.
+
+        Returns
+        -------
+        :
+            The result of running the diagnostic.
+        """
+        logger.debug("PMP annual cycle run start")
+        cmds = self.build_cmds(definition)
+
+        runs = [self.provider.run(cmd) for cmd in cmds]
+        logger.debug(f"runs: {runs}")
+
+        return self.build_execution_result(definition)
+
+
+def _transform_results(data: dict[str, Any]) -> dict[str, Any]:
+    """
+    Transform the executions dictionary to match the expected structure.
+
+    Parameters
+    ----------
+    data : dict
+        The original executions dictionary.
+
+    Returns
+    -------
+    dict
+        The transformed executions dictionary.
+    """
+    # Remove the "CalendarMonths" key from the nested structure
+    if "RESULTS" in data:
+        models = list(data["RESULTS"].keys())
+        for model in models:
+            if "default" in data["RESULTS"][model]:
+                realizations = list(data["RESULTS"][model]["default"].keys())
+                if "attributes" in realizations:
+                    realizations.remove("attributes")
+                for realization in realizations:
+                    regions = list(data["RESULTS"][model]["default"][realization].keys())
+                    for region in regions:
+                        stats = list(data["RESULTS"][model]["default"][realization][region].keys())
+                        for stat in stats:
+                            if (
+                                "CalendarMonths"
+                                in data["RESULTS"][model]["default"][realization][region][stat]
+                            ):
+                                calendar_months = data["RESULTS"][model]["default"][realization][region][
+                                    stat
+                                ].pop("CalendarMonths")
+                                for i, value in enumerate(calendar_months):
+                                    key_name = f"CalendarMonth-{i + 1:02d}"
+                                    data["RESULTS"][model]["default"][realization][region][stat][key_name] = (
+                                        value
+                                    )
+
+    # Remove the "CalendarMonths" key from the nested structure in "DIMENSIONS"
+    if (
+        "DIMENSIONS" in data
+        and "season" in data["DIMENSIONS"]
+        and "CalendarMonths" in data["DIMENSIONS"]["season"]
+    ):
+        calendar_months = data["DIMENSIONS"]["season"].pop("CalendarMonths")
+        for i in range(1, 13):
+            key_name = f"CalendarMonth-{i:02d}"
+            data["DIMENSIONS"]["season"][key_name] = {}
+
+    return data

climate_ref_pmp/diagnostics/variability_modes.py

@@ -0,0 +1,174 @@
+from collections.abc import Iterable
+
+from loguru import logger
+
+from climate_ref_core.datasets import FacetFilter, SourceDatasetType
+from climate_ref_core.diagnostics import (
+    CommandLineDiagnostic,
+    DataRequirement,
+    ExecutionDefinition,
+    ExecutionResult,
+)
+from climate_ref_pmp.pmp_driver import build_pmp_command, process_json_result
+
+
+class ExtratropicalModesOfVariability(CommandLineDiagnostic):
+    """
+    Calculate the extratropical modes of variability for a given area
+    """
+
+    ts_modes = ("PDO", "NPGO", "AMO")
+    psl_modes = ("NAO", "NAM", "PNA", "NPO", "SAM")
+
+    facets = ("model", "realization", "reference", "mode", "season", "method", "statistic")
+
+    def __init__(self, mode_id: str):
+        self.mode_id = mode_id.upper()
+        self.name = f"Extratropical modes of variability: {mode_id}"
+        self.slug = f"extratropical-modes-of-variability-{mode_id.lower()}"
+
+        def get_data_requirements(
+            obs_source: str,
+            obs_variable: str,
+            cmip_variable: str,
+            extra_experiments: str | tuple[str, ...] | list[str] = (),
+            remove_experiments: str | tuple[str, ...] | list[str] = (),
+        ) -> tuple[DataRequirement, DataRequirement]:
+            filters = [
+                FacetFilter(
+                    facets={
+                        "frequency": "mon",
+                        "experiment_id": ("historical", "hist-GHG", "piControl", *extra_experiments),
+                        "variable_id": cmip_variable,
+                    }
+                )
+            ]
+
+            return (
+                DataRequirement(
+                    source_type=SourceDatasetType.obs4MIPs,
+                    filters=(
+                        FacetFilter(facets={"source_id": (obs_source,), "variable_id": (obs_variable,)}),
+                    ),
+                    group_by=("source_id", "variable_id"),
+                ),
+                DataRequirement(
+                    source_type=SourceDatasetType.CMIP6,
+                    filters=tuple(filters),
+                    group_by=("source_id", "experiment_id", "variant_label", "member_id"),
+                ),
+            )
+
+        if self.mode_id in self.ts_modes:
+            self.parameter_file = "pmp_param_MoV-ts.py"
+            self.data_requirements = get_data_requirements("HadISST-1-1", "ts", "ts")
+        elif self.mode_id in self.psl_modes:
+            self.parameter_file = "pmp_param_MoV-psl.py"
+            self.data_requirements = get_data_requirements("20CR", "psl", "psl", extra_experiments=("amip",))
+        else:
+            raise ValueError(
+                f"Unknown mode_id '{self.mode_id}'. Must be one of {self.ts_modes + self.psl_modes}"
+            )
+
+    def build_cmd(self, definition: ExecutionDefinition) -> Iterable[str]:
+        """
+        Build the command to run the diagnostic
+
+        Parameters
+        ----------
+        definition
+            Definition of the diagnostic execution
+
+        Returns
+        -------
+            Command arguments to execute in the PMP environment
+        """
+        input_datasets = definition.datasets[SourceDatasetType.CMIP6]
+        source_id = input_datasets["source_id"].unique()[0]
+        experiment_id = input_datasets["experiment_id"].unique()[0]
+        member_id = input_datasets["member_id"].unique()[0]
+
+        logger.debug(f"input_datasets: {input_datasets}")
+        logger.debug(f"source_id: {source_id}")
+        logger.debug(f"experiment_id: {experiment_id}")
+        logger.debug(f"member_id: {member_id}")
+
+        reference_dataset = definition.datasets[SourceDatasetType.obs4MIPs]
+        reference_dataset_name = reference_dataset["source_id"].unique()[0]
+        # reference_dataset_path = reference_dataset.datasets[0]["path"]
+        reference_dataset_path = reference_dataset.datasets.iloc[0]["path"]
+
+        logger.debug(f"reference_dataset: {reference_dataset}")
+        logger.debug(f"reference_dataset_name: {reference_dataset_name}")
+        logger.debug(f"reference_dataset_path: {reference_dataset_path}")
+
+        model_files = input_datasets.path.to_list()
+
+        if len(model_files) != 1:
+            # Have some logic to replace the dates in the filename with a wildcard
+            raise NotImplementedError("Only one model file is supported at this time.")
+
+        if isinstance(model_files, list):
+            modpath = " ".join([str(p) for p in model_files])
+        else:
+            modpath = model_files
+
+        if isinstance(reference_dataset_path, list):
+            reference_data_path = " ".join([str(p) for p in reference_dataset_path])
+        else:
+            reference_data_path = reference_dataset_path
+
+        # Build the command to run the PMP driver script
+        params = {
+            "driver_file": "variability_mode/variability_modes_driver.py",
+            "parameter_file": self.parameter_file,
+            "variability_mode": self.mode_id,
+            "modpath": modpath,
+            "modpath_lf": "none",
+            "exp": experiment_id,
+            "realization": member_id,
+            "modnames": source_id,
+            "reference_data_name": reference_dataset_name,
+            "reference_data_path": reference_data_path,
+            "results_dir": str(definition.output_directory),
+            "cmec": None,
+            "no_provenance": None,
+        }
+
+        # Add conditional parameters
+        if self.mode_id in ["SAM"]:  # pragma: no cover
+            params["osyear"] = 1950
+            params["oeyear"] = 2005
+
+        # Pass the parameters using **kwargs
+        return build_pmp_command(**params)
+
+    def build_execution_result(self, definition: ExecutionDefinition) -> ExecutionResult:
+        """
+        Build a diagnostic result from the output of the PMP driver
+
+        Parameters
+        ----------
+        definition
+            Definition of the diagnostic execution
+
+        Returns
+        -------
+            Result of the diagnostic execution
+        """
+        results_files = list(definition.output_directory.glob("*_cmec.json"))
+        if len(results_files) != 1:  # pragma: no cover
+            logger.warning(f"A single cmec output file not found: {results_files}")
+            return ExecutionResult.build_from_failure(definition)
+
+        # Find the other outputs
+        png_files = [definition.as_relative_path(f) for f in definition.output_directory.glob("*.png")]
+        data_files = [definition.as_relative_path(f) for f in definition.output_directory.glob("*.nc")]
+
+        cmec_output, cmec_metric = process_json_result(results_files[0], png_files, data_files)
+
+        return ExecutionResult.build_from_output_bundle(
+            definition,
+            cmec_output_bundle=cmec_output,
+            cmec_metric_bundle=cmec_metric,
+        )

climate_ref_pmp/params/pmp_param_MoV-psl.py

@@ -0,0 +1,90 @@
+import datetime
+import os
+
+# =================================================
+# Background Information
+# -------------------------------------------------
+mip = "cmip6"
+exp = "historical"
+frequency = "mo"
+realm = "atm"
+
+# =================================================
+# Analysis Options
+# -------------------------------------------------
+variability_mode = "NAM"  # Available domains: NAM, NAO, SAM, PNA, PDO
+seasons = [
+    "DJF",
+    "MAM",
+    "JJA",
+    "SON",
+]  # Available seasons: DJF, MAM, JJA, SON, monthly, yearly
+
+ConvEOF = True  # Calculate conventioanl EOF for model
+CBF = True  # Calculate Common Basis Function (CBF) for model
+
+# =================================================
+# Miscellaneous
+# -------------------------------------------------
+update_json = False
+debug = False
+
+# =================================================
+# Observation
+# -------------------------------------------------
+reference_data_name = "NOAA-CIRES_20CR"
+reference_data_path = os.path.join(
+    "/p/user_pub/PCMDIobs/obs4MIPs/NOAA-ESRL-PSD/20CR/mon/psl/gn/latest",
+    "psl_mon_20CR_PCMDI_gn_187101-201212.nc",
+)
+
+varOBS = "psl"
+ObsUnitsAdjust = (True, "divide", 100.0)  # Pa to hPa; or (False, 0, 0)
+
+osyear = 1900
+oeyear = 2005
+eofn_obs = 1
+
+# =================================================
+# Models
+# -------------------------------------------------
+modpath = os.path.join(
+    "/p/css03/cmip5_css02/data/cmip5/output1/CSIRO-BOM/ACCESS1-0/historical/mon/atmos/Amon/r1i1p1/psl/1",
+    "psl_Amon_ACCESS1-0_historical_r1i1p1_185001-200512.nc",
+)
+
+modnames = ["ACCESS1-0"]
+
+realization = "r1i1p1f1"
+
+varModel = "psl"
+ModUnitsAdjust = (True, "divide", 100.0)  # Pa to hPa
+
+msyear = 1900
+meyear = 2005
+eofn_mod = 1
+
+# =================================================
+# Output
+# -------------------------------------------------
+case_id = f"{datetime.datetime.now():v%Y%m%d}"
+pmprdir = "/p/user_pub/pmp/pmp_results/"
+
+results_dir = os.path.join(
+    pmprdir,
+    "%(output_type)",
+    "variability_modes",
+    "%(mip)",
+    "%(exp)",
+    "%(case_id)",
+    "%(variability_mode)",
+    "%(reference_data_name)",
+)
+
+# Output for obs
+plot_obs = True  # Create map graphics
+nc_out_obs = True  # Write output in NetCDF
+
+# Output for models
+nc_out = True
+plot = True