diff --git a/Makefile b/Makefile index eee52c8a..78311c9d 100644 --- a/Makefile +++ b/Makefile @@ -29,12 +29,16 @@ checks: $(VENV_DIR) ## run all the checks echo "\n\n=== isort ==="; $(VENV_DIR)/bin/isort --check-only --quiet src tests|| echo "--- isort failed ---" >&2; \ echo "\n\n=== pydocstyle ==="; $(VENV_DIR)/bin/pydocstyle src || echo "--- pydocstyle failed ---" >&2; \ echo "\n\n=== pylint ==="; $(VENV_DIR)/bin/pylint src || echo "--- pylint failed ---" >&2; \ - echo "\n\n=== notebook tests 1 ==="; $(VENV_DIR)/bin/pytest notebooks/METEOR_Interface_Paper_plots.ipynb -r a --nbval --nbval-sanitize-with $(NOTEBOOKS_SANITIZE_FILE) || echo "--- notebook tests failed ---" >&2; \ + echo "\n\n=== tests ==="; $(VENV_DIR)/bin/pytest tests -r a --cov=meteor --cov-report='' \ + && $(VENV_DIR)/bin/coverage report --fail-under=90 || echo "--- tests failed ---" >&2; \ + echo + +.PHONY: test-notebooks +test-notebooks: $(VENV_DIR) ## run the notebook test suite + @echo "=== notebook tests 1 ==="; $(VENV_DIR)/bin/pytest notebooks/notebooks_v16_description_paper/METEOR_Interface_Paper_plots.ipynb -r a --nbval --nbval-sanitize-with $(NOTEBOOKS_SANITIZE_FILE) || echo "--- notebook tests failed ---" >&2; \ echo "\n\n=== notebook tests 2 ==="; $(VENV_DIR)/bin/pytest notebooks/GCAM_predict.ipynb -r a --nbval --nbval-sanitize-with $(NOTEBOOKS_SANITIZE_FILE) || echo "--- notebook tests failed ---" >&2; \ echo "\n\n=== notebook tests 3 ==="; $(VENV_DIR)/bin/pytest notebooks/METEOR_Interface_Examples.ipynb -r a --nbval --nbval-sanitize-with $(NOTEBOOKS_SANITIZE_FILE) || echo "--- notebook tests failed ---" >&2; \ echo "\n\n=== notebook tests 4 ==="; $(VENV_DIR)/bin/pytest notebooks/METEOR_Impacts_Clean_Demo.ipynb -r a --nbval --nbval-sanitize-with $(NOTEBOOKS_SANITIZE_FILE) || echo "--- notebook tests failed ---" >&2; \ - echo "\n\n=== tests ==="; $(VENV_DIR)/bin/pytest tests -r a --cov=meteor --cov-report='' \ - && $(VENV_DIR)/bin/coverage report --fail-under=90 || echo "--- tests failed ---" >&2; \ echo format-checks: $(VENV_DIR) ## run all the checks diff --git a/README.md b/README.md index 3353339b..f5dd167a 100644 --- a/README.md +++ b/README.md @@ -67,7 +67,8 @@ This interactive notebook covers: - ✅ **Spatial Detail**: Global, regional (AR6 regions), and point-based projections - ✅ **Multiple Variables**: Temperature, precipitation, and more with variable-specific treatment - ✅ **Impact Metrics**: Built-in calculation of degree days and custom impact assessments -- ✅ **Smart Caching**: Automatic caching of trained models and downloaded data +- ✅ **Crop Yield Impacts**: GGCMI Phase 2 emulators for maize, rice, soy, spring wheat, and winter wheat across 9 crop models (Franke et al. 2020) +- ✅ **Smart Caching**: Automatic caching of trained models and downloaded data. GGCMI coefficient files (~110 MB each) are downloaded on demand from [Zenodo record 3592453](https://zenodo.org/records/3592453) and stored under `/ggcm/` - ✅ **CMIP6 Integration**: Direct access to cloud-based CMIP6 data ## Architecture Overview @@ -100,9 +101,11 @@ Emissions/Concentrations → Pattern Scaling → Annual Climate → Monthly Base ### Documentation - **[METEOR Interface Examples](notebooks/METEOR_Interface_Examples.ipynb)**: Complete tutorial with visualizations +- **[GGCMI Phase 2 Crop Yield Impacts](docs/ggcm_crop_yield_impacts.md)**: Implementation notes and reference to Franke et al. (2020) ### Other Notebooks - `Climate_Bench_METEOR.ipynb`: ClimateBench metrics +- `METEOR_CropYield_Demo.ipynb`: Crop yield projections under SSP2-4.5 using GGCMI Phase 2 emulators ### Module Reference @@ -114,7 +117,8 @@ Emissions/Concentrations → Pattern Scaling → Annual Climate → Monthly Base | `cmip6_meteor_data_getter.py` | CMIP6 cloud data access | | `ensemble_output.py` | Output container classes | | `variable_transforms.py` | Variable-specific transformations | -| `impacts/` | Climate impact assessment | +| `impacts/` | Climate impact assessment (degree days, GGCMI Phase 2 crop yields) | +| `impacts/ggcm/` | GGCMI Phase 2 polynomial emulator, AgMERRA baseline, Zenodo catalog & downloader | | `prpatt.py` | Pattern scaling algorithms | | `scm_forcer_engine.py` | Simple climate model integration | diff --git a/docs/ggcm_crop_yield_impacts.md b/docs/ggcm_crop_yield_impacts.md new file mode 100644 index 00000000..7c4b0d59 --- /dev/null +++ b/docs/ggcm_crop_yield_impacts.md @@ -0,0 +1,216 @@ +# GGCMI Phase 2 Crop Yield Impacts + +This document describes METEOR's implementation of the GGCMI Phase 2 crop yield +emulators and explains how it maps onto the original published methodology. + +**Reference:** Franke, J. A., et al. (2020). The GGCMI Phase 2 emulators: global +gridded crop model yield responses to changes in CO2, temperature, water, and +nitrogen. *Geoscientific Model Development*, 13, 3995–4018. + + +**Original Python implementation:** + +--- + +## Background + +Process-based crop models are computationally expensive and hard to embed in +large-ensemble or integrated-assessment workflows. The GGCMI Phase 2 project +addressed this by running nine globally-gridded crop models across a structured +*parameter sweep* — up to 756 combinations of CO₂ concentration (C), temperature +perturbation (T), water supply (W), and nitrogen application (N), each repeated +under two growing-season adaptation assumptions (A0/A1) — and fitting a simple +polynomial to the climatological-mean yield response at every 0.5° grid cell. + +The result is a set of spatially-varying polynomial coefficient tensors that can +reproduce the long-term mean yield of each crop model under arbitrary future +C/T/W/N conditions at negligible computational cost. + +--- + +## The Polynomial (Eq. 1, Franke et al. 2020) + +The emulator evaluates a **34-term third-order polynomial** in four transformed +inputs: + +| Symbol | Physical meaning | Transformation | +|--------|-----------------|----------------| +| C | CO₂ concentration (ppm) | raw value | +| T | Temperature anomaly (°C) | `Ta − T_AgMERRA` | +| W | Precipitation ratio (–) | `Wa / W_AgMERRA` | +| N | Nitrogen application (kg N ha⁻¹ yr⁻¹) | raw value | + +> **Why anomalies?** The GGCMI Phase 2 simulations apply temperature +> perturbations as *additive mean shifts* and precipitation as *fractional +> multipliers* relative to the historical AgMERRA climatology. Converting +> absolute inputs to the same anomaly/ratio form before evaluating the polynomial +> is therefore essential for physical consistency. + +The 35th term of a full third-order polynomial in four variables would be N³, +but this term is **deliberately omitted** (Sect. 3.1, Franke et al.) because +the training data samples only three nitrogen levels — insufficient to constrain +a cubic in N. METEOR stores all 35 coefficient slots (K[0]…K[34]) in the +netCDF4 files, with K[34] set to zero for every model/crop/variant. + +The complete polynomial as stored in `coefficients.py`: + +``` +Yield = K[0] + + K[1]·C + K[2]·T + K[3]·W + K[4]·N + + K[5]·C² + K[6]·CT + K[7]·CW + K[8]·CN + + K[9]·T² + K[10]·TW + K[11]·TN + + K[12]·W² + K[13]·WN + + K[14]·N² + + K[15]·C³ + K[16]·C²T + K[17]·C²W + K[18]·C²N + + K[19]·CT² + K[20]·CTW + K[21]·CTN + + K[22]·CW² + K[23]·CWN + + K[24]·CN² + + K[25]·T³ + K[26]·T²W + K[27]·T²N + + K[28]·TW² + K[29]·TWN + + K[30]·TN² + + K[31]·W³ + K[32]·W²N + + K[33]·WN² + (K[34]·N³ omitted — cannot be fitted from three N levels) +``` + +Yields are clipped to zero from below; negative raw predictions are set to 0. + +--- + +## Input Clamping and Out-of-Bounds Diagnostics + +The polynomial is only reliable within the training ranges (Table 2, +Franke et al.): + +| Variable | Lower bound | Upper bound | +|----------|-------------|-------------| +| C | 360 ppm | 810 ppm | +| T | T_AgMERRA − 1 °C | T_AgMERRA + 6 °C | +| W | 0.5 × W_AgMERRA | 1.3 × W_AgMERRA | +| N | 10 kg ha⁻¹ yr⁻¹ | 200 kg ha⁻¹ yr⁻¹ | + +`get_yields()` clamps all inputs to these ranges before evaluation and returns +two diagnostic fields: + +- **`T_oob`** — per-cell temperature excess beyond the training boundary (°C; + negative = below lower bound) +- **`W_oob`** — per-cell precipitation excess (mm yr⁻¹; same sign convention) + +These can be used to flag grid cells where projections are extrapolating. + +--- + +## AgMERRA Baseline + +Most of the nine crop models in GGCMI Phase 2 use the AgMIP Modern-Era +Retrospective Analysis for Research and Applications (**AgMERRA**) as their +historical climate driver (Sect. 2.1, Franke et al.). The 1980–2010 +climatological mean temperature and precipitation fields from AgMERRA therefore +define the reference point against which the T and W inputs to the polynomial +are expressed. + +METEOR bundles two pre-computed 0.5° AgMERRA climatology files directly with +the package in `src/meteor/impacts/ggcm/data/`: + +| File | Variable | Units | +|------|----------|-------| +| `tas-avg-1980-2010-05deg-adjlon.nc4` | T_AgMERRA | °C | +| `pr-avg-avg-1980-2010-05deg-adjlon.nc4` | W_AgMERRA | mm yr⁻¹ | + +`load_agmerra_baseline()` in `baseline.py` reads these files and returns +NumPy arrays of shape (360, 720) (global 0.5° grid, 90°N–90°S, +180°W–180°E). Precipitation values are floored at 1 mm yr⁻¹ to avoid +division-by-zero when computing the W ratio. + +--- + +## Coefficient Files + +The fitted K tensors for each crop model / crop / adaptation-variant combination +are stored in netCDF4 files on Zenodo (record 3592453), one file per +combination. Each file contains a single variable `K_rf` of shape +`(35, 360, 720)` — 35 coefficient planes on the same 0.5° global grid. + +### Available combinations + +| | CARAIB | EPIC-TAMU | GEPIC | JULES | LPJ-GUESS | LPJmL | pDSSAT | PEPIC | PROMET | +|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:| +| maize | A0/A1 | A0/A1 | A0/A1 | A0 | A0/A1 | A0/A1 | A0/A1 | A0/A1 | A0/A1 | +| rice | A0/A1 | A0/A1 | A0/A1 | A0 | A0/A1 | A0/A1 | A0/A1 | A0/A1 | A0/A1 | +| soy | A0/A1 | A0/A1 | A0/A1 | A0 | — | A0/A1 | A0/A1 | A0/A1 | A0/A1 | +| spring_wheat | A0/A1 | A0/A1 | A0/A1 | A0 | A0/A1 | A0/A1 | A0/A1 | A0/A1 | A0/A1 | +| winter_wheat | A0/A1 | A0/A1 | A0/A1 | — | A0/A1 | A0/A1 | A0/A1 | A0/A1 | A0/A1 | + +JULES contributes A0 scenarios only; its seasonal-length adaptation could not +be represented under the A1 protocol. LPJ-GUESS did not simulate soybean. + +Adaptation scenarios: +- **A0** — no cultivar adaptation; growing seasons shorten in warmer climates +- **A1** — cultivar adaptation retains fixed growing-season length + +Files are downloaded on demand by `GgcmDownloader` with resume support; cached +under `/ggcm/`. + +--- + +## Integration into METEOR + +When crop yield impacts are requested via `generate_ensemble_outputs()`, the +`_apply_crop_yields()` method in `meteor_interface.py`: + +1. **Generates annual gridded T and P** from pattern scaling over the requested + year range (using the already-trained METEOR pattern models for both `tas` + and `pr`). +2. **Reconstructs absolute fields** by adding the piControl climatological mean + to pattern-scaling anomalies, converting units to °C and mm yr⁻¹. +3. **Regrids** both fields to the GGCM 0.5° grid via bilinear interpolation; + fills any coastal/polar NaN gaps with the AgMERRA climatological values. +4. **Reads CO₂** for each year from the scenario concentration data. +5. **Evaluates `get_yields()`** per crop with the pre-loaded K tensor, producing + a (360 × 720) yield field for each year. +6. **Aggregates spatially** using the same keys as the climate time series + (`"global"`, `"regional:CODE"`, `"point:LAT,LON"`, etc.). + +### Usage + +```python +ensemble = emulator.generate_ensemble_outputs( + scenario="ssp245", + start_year=2020, + end_year=2100, + timeseries=["global", "regional:EAS"], + impacts={ + "crop_yield": { + "crops": ["maize", "spring_wheat"], + "crop_model": "LPJmL", + "variant": "A0", + "N": 100, # kg N ha⁻¹ yr⁻¹ (uniform) + } + }, +) + +# Access results +maize_global = ensemble.crop_impacts["maize"]["global"] # (n_years,) ndarray +``` + +Results are stored on `EnsembleOutput.crop_impacts` as a nested dict: +`crop_impacts[crop][aggregation_key]` → 1-D NumPy array of annual yields in +t DM ha⁻¹ yr⁻¹. + +--- + +## Caveats and Limitations + +- The emulators capture **climatological-mean** yield responses only; year-to-year + variability is not represented (see Sect. 2.2, Franke et al., for discussion of + why annual and climatological responses differ). +- Nitrogen is applied **uniformly** across the globe. Country- or region-specific + fertilisation rates are not currently supported. +- Only **rainfed** yield emulators (`K_rf`) are used. Irrigated emulators exist + in the Zenodo archive but are not yet exposed. +- Grid cells outside the current cultivated extent may produce non-physical yield + estimates; the polynomial was validated primarily over harvested-area masks + (Sect. 4, Franke et al.). +- Projections exceeding the training bounds (notably T > T_AgMERRA + 6 °C under + high-end scenarios) are extrapolated; check `T_oob` / `W_oob` if this matters + for your application. diff --git a/notebooks/METEOR_CropYield_Demo.ipynb b/notebooks/METEOR_CropYield_Demo.ipynb new file mode 100644 index 00000000..623943b6 --- /dev/null +++ b/notebooks/METEOR_CropYield_Demo.ipynb @@ -0,0 +1,574 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5fd4d04b", + "metadata": {}, + "source": [ + "# METEOR Crop Yield Impact Demo\n", + "\n", + "Demonstrates the integrated GGCMI Phase 2 crop yield emulator.\n", + "\n", + "**What this notebook does:**\n", + "1. Trains METEOR for `tas` + `pr` on a CMIP6 model\n", + "2. Generates an SSP2-4.5 climate ensemble\n", + "3. Passes the `crop_yield` config to compute maize and spring wheat yields across SSP scenarios\n", + "4. Plots yield trajectories and a multi-scenario comparison\n", + "\n", + "Coefficient files (~110 MB each) are downloaded from Zenodo record 3592453 on first run and cached locally." + ] + }, + { + "cell_type": "markdown", + "id": "89b97e78", + "metadata": {}, + "source": [ + "## 1. Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8941d150", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Imports complete\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.ticker as mticker\n", + "from meteor import MeteorInterface\n", + "\n", + "CACHE_DIR = '../cache'\n", + "MODEL = 'NorESM2-MM'\n", + "CROP_MODEL = 'LPJmL'\n", + "CROPS = ['maize', 'spring_wheat']\n", + "VARIANT = 'A0' # no adaptation\n", + "N_FERT = 100 # kg N / ha / yr\n", + "\n", + "print('✅ Imports complete')" + ] + }, + { + "cell_type": "markdown", + "id": "9f3f70f2", + "metadata": {}, + "source": [ + "## 2. Create and train emulator\n", + "\n", + "Both `tas` and `pr` are required for the crop yield module." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c1936b07", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + "Training METEOR emulator for NorESM2-MM\n", + "Variables: tas, pr\n", + "============================================================\n", + "\n", + "🔧 Training TAS...\n", + " → Training pattern scaling model...\n", + " ⚠️ Cache miss: Model name mismatch: expected 'cmip6-NorESM2-MM-aer', found 'cmip6-NorESM2-MM-aer-tas'\n", + "🔧 Preparing pattern scaling training data for NorESM2-MM...\n", + " ✅ Training data prepared for experiments: ['base', 'co2x4', 'ssp245', 'sulxanom']\n", + "📥 Loading CICERO-SCM forcing data for ssp245...\n", + " ✅ Loaded 801 concentration records\n", + " ✅ Loaded 351 emission records\n", + " ✅ Config: 1750-2100, emissions start: 1850\n", + "📦 Loading cached pattern scaling model from ../cache/pattern_scaling/cmip6-NorESM2-MM-aer-tas_pattern_scaling.pkl\n", + "✅ Pattern scaling model loaded from ../cache/pattern_scaling/cmip6-NorESM2-MM-aer-tas_pattern_scaling.pkl\n", + " → Training noise model...\n", + "Model loaded from ../cache/noise_models/NorESM2-MM_tas_noise_model.pkl\n", + " ✓ Using cached noise model\n", + " ✅ TAS training complete\n", + "\n", + "🔧 Training PR...\n", + " → Training pattern scaling model...\n", + " ⚠️ Cache miss: Model name mismatch: expected 'cmip6-NorESM2-MM-aer', found 'cmip6-NorESM2-MM-aer-pr'\n", + "🔧 Preparing pattern scaling training data for NorESM2-MM...\n", + " ✅ Training data prepared for experiments: ['base', 'co2x4', 'ssp245', 'sulxanom']\n", + "📥 Loading CICERO-SCM forcing data for ssp245...\n", + " ✅ Loaded 801 concentration records\n", + " ✅ Loaded 351 emission records\n", + " ✅ Config: 1750-2100, emissions start: 1850\n", + "📦 Loading cached pattern scaling model from ../cache/pattern_scaling/cmip6-NorESM2-MM-aer-pr_pattern_scaling.pkl\n", + "✅ Pattern scaling model loaded from ../cache/pattern_scaling/cmip6-NorESM2-MM-aer-pr_pattern_scaling.pkl\n", + " → Training noise model...\n", + "Model loaded from ../cache/noise_models/NorESM2-MM_pr_noise_model.pkl\n", + " ✓ Using cached noise model\n", + " → Fitting gamma transform...\n", + " Reason: Ensure positive-only values (precipitation cannot be negative)\n", + " ✅ PR training complete\n", + "\n", + "============================================================\n", + "✅ All variables trained successfully\n", + "============================================================\n" + ] + } + ], + "source": [ + "emulator = MeteorInterface(\n", + " model=MODEL,\n", + " variables=['tas', 'pr'],\n", + " cache_dir=CACHE_DIR,\n", + ")\n", + "emulator.train(verbose=True)" + ] + }, + { + "cell_type": "markdown", + "id": "0ad14c96", + "metadata": {}, + "source": [ + "## 3. Generate SSP2-4.5 ensemble with crop yields\n", + "\n", + "Crop yield is computed from the **deterministic pattern scaling** (annual forced response) rather than individual monthly realisations, because annual noise averages to approximately zero and the GGCMI emulator takes annual-mean inputs. Results are therefore a single trajectory per aggregation region." + ] + }, + { + "cell_type": "markdown", + "id": "fff55be3", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d75f142d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + "Generating ensemble for ssp245\n", + " Years: 2015-2100\n", + " Realizations: 10\n", + "============================================================\n", + "\n", + "📊 Generating TAS...\n", + " → Time series: 4 aggregations\n", + " → Computing pattern scaling for tas, ssp245...\n", + " → Loading CMIP6 training data for ssp245...\n", + " → Loading piControl baseline for tas...\n", + " → Converting tas to anomalies from piControl baseline...\n", + " → Generating 10 stochastic PC realizations...\n", + " • global\n", + " • regional:EAS\n", + " • regional:SAS\n", + " • regional:WAF\n", + " → Computing impact metrics...\n", + " • HDD for global\n", + " • CDD for global\n", + " • HDD for regional:EAS\n", + " • CDD for regional:EAS\n", + " • HDD for regional:SAS\n", + " • CDD for regional:SAS\n", + " • HDD for regional:WAF\n", + " • CDD for regional:WAF\n", + " ✅ TAS complete\n", + "\n", + "📊 Generating PR...\n", + " → Time series: 4 aggregations\n", + " → Computing pattern scaling for pr, ssp245...\n", + " → Loading CMIP6 training data for ssp245...\n", + " → Loading piControl baseline for pr...\n", + " → Using 2015 baseline for PR instead of piControl\n", + " → Generating 10 stochastic PC realizations...\n", + " • global\n", + " • regional:EAS\n", + " • regional:SAS\n", + " • regional:WAF\n", + " ✅ PR complete\n", + "\n", + "🌾 Computing crop yield impacts...\n", + " → Computing annual pattern scaling for crop inputs...\n", + " → Loading piControl baseline for absolute T/P reconstruction...\n", + "\n", + "============================================================\n", + "✅ Generation complete\n", + "============================================================\n", + "\n", + "Crop impact keys: ['maize', 'spring_wheat']\n", + " maize / global: shape=(86,), mean=0.83 t dm/ha/yr\n", + " maize / regional:EAS: shape=(86,), mean=2.56 t dm/ha/yr\n", + " maize / regional:SAS: shape=(86,), mean=3.13 t dm/ha/yr\n", + " maize / regional:WAF: shape=(86,), mean=4.19 t dm/ha/yr\n", + " spring_wheat / global: shape=(86,), mean=0.52 t dm/ha/yr\n", + " spring_wheat / regional:EAS: shape=(86,), mean=1.81 t dm/ha/yr\n", + " spring_wheat / regional:SAS: shape=(86,), mean=0.77 t dm/ha/yr\n", + " spring_wheat / regional:WAF: shape=(86,), mean=1.50 t dm/ha/yr\n" + ] + } + ], + "source": [ + "ensemble_245 = emulator.generate_ensemble_outputs(\n", + " scenario='ssp245',\n", + " start_year=2015,\n", + " end_year=2100,\n", + " n_realizations=10,\n", + " timeseries=['global', 'regional:EAS', 'regional:SAS', 'regional:WAF'],\n", + " impacts={\n", + " 'tas': {'degree_days': {'hdd_base': 18.0}}, # existing impact\n", + " 'crop_yield': { # NEW\n", + " 'crops': CROPS,\n", + " 'crop_model': CROP_MODEL,\n", + " 'variant': VARIANT,\n", + " 'N': N_FERT,\n", + " },\n", + " },\n", + " verbose=True,\n", + ")\n", + "\n", + "print('\\nCrop impact keys:', list(ensemble_245.crop_impacts.keys()))\n", + "for crop in CROPS:\n", + " for key, arr in ensemble_245.crop_impacts[crop].items():\n", + " print(f' {crop} / {key}: shape={arr.shape}, mean={arr.mean():.2f} t dm/ha/yr')" + ] + }, + { + "cell_type": "markdown", + "id": "4e064ed3", + "metadata": {}, + "source": [ + "## 4. Plot global yield trajectories under SSP2-4.5" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "eb4db39d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "years_245 = np.arange(2015, 2101)\n", + "\n", + "crop_colors = {'maize': '#E76F51', 'spring_wheat': '#2A9D8F'}\n", + "crop_labels = {'maize': 'Maize', 'spring_wheat': 'Spring Wheat'}\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(13, 5), sharey=False)\n", + "\n", + "regions = [('global', 'Global'), ('regional:EAS', 'East Asia')]\n", + "\n", + "for ax, (reg_key, reg_label) in zip(axes, regions):\n", + " for crop in CROPS:\n", + " arr = ensemble_245.crop_impacts[crop][reg_key]\n", + " ax.plot(years_245, arr, color=crop_colors[crop],\n", + " linewidth=2, label=crop_labels[crop])\n", + "\n", + " ax.set_title(f'{reg_label} — SSP2-4.5 ({CROP_MODEL}/{VARIANT})', fontsize=11)\n", + " ax.set_xlabel('Year')\n", + " ax.set_ylabel('Yield (t dry matter / ha / yr)')\n", + " ax.legend(frameon=False)\n", + " ax.grid(alpha=0.3, linewidth=0.5)\n", + " ax.yaxis.set_major_formatter(mticker.FormatStrFormatter('%.1f'))\n", + "\n", + "plt.suptitle('METEOR × GGCMI Phase 2 Crop Yield Projections', fontsize=13, fontweight='bold')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "67cc77ce", + "metadata": {}, + "source": [ + "## 5. Multi-scenario comparison (global maize yield)\n", + "\n", + "Run the same crop config for SSP1-2.6, SSP3-7.0 and SSP5-8.5 and compare trajectories." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "88539955", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running ssp126...\n", + "Running ssp245...\n", + "Running ssp370...\n", + "Running ssp585...\n", + "✅ All scenarios complete\n" + ] + } + ], + "source": [ + "scenarios = {\n", + " 'ssp126': {'color': '#1a6faf', 'label': 'SSP1-2.6'},\n", + " 'ssp245': {'color': '#f4a261', 'label': 'SSP2-4.5'},\n", + " 'ssp370': {'color': '#e76f51', 'label': 'SSP3-7.0'},\n", + " 'ssp585': {'color': '#9e2a2b', 'label': 'SSP5-8.5'},\n", + "}\n", + "\n", + "crop_impacts_all = {}\n", + "\n", + "for ssp in scenarios:\n", + " print(f'Running {ssp}...')\n", + " ens = emulator.generate_ensemble_outputs(\n", + " scenario=ssp,\n", + " start_year=2015,\n", + " end_year=2100,\n", + " n_realizations=1,\n", + " timeseries=['global'],\n", + " impacts={\n", + " 'crop_yield': {\n", + " 'crops': ['maize'],\n", + " 'crop_model': CROP_MODEL,\n", + " 'variant': VARIANT,\n", + " 'N': N_FERT,\n", + " }\n", + " },\n", + " verbose=False,\n", + " )\n", + " crop_impacts_all[ssp] = ens.crop_impacts['maize']['global']\n", + "\n", + "print('✅ All scenarios complete')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d26ac8cb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " 2030 2060 2100 Δ2015→2100\n", + "SSP1-2.6 0.82 0.82 0.81 +0.01\n", + "SSP2-4.5 0.82 0.84 0.84 +0.04\n", + "SSP3-7.0 0.82 0.85 0.86 +0.06\n", + "SSP5-8.5 0.82 0.85 0.84 +0.04\n" + ] + } + ], + "source": [ + "years = np.arange(2015, 2101)\n", + "baseline = crop_impacts_all['ssp126'][0] # use first value as reference\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(13, 5))\n", + "\n", + "# Absolute yield\n", + "ax = axes[0]\n", + "for ssp, meta in scenarios.items():\n", + " ax.plot(years, crop_impacts_all[ssp], color=meta['color'],\n", + " linewidth=2, label=meta['label'])\n", + "ax.set_ylabel('Global maize yield (t dm / ha / yr)')\n", + "ax.set_xlabel('Year')\n", + "ax.set_title('Absolute yield')\n", + "ax.legend(frameon=False)\n", + "ax.grid(alpha=0.3, linewidth=0.5)\n", + "\n", + "# Change relative to 2015\n", + "ax = axes[1]\n", + "for ssp, meta in scenarios.items():\n", + " delta = crop_impacts_all[ssp] - crop_impacts_all[ssp][0]\n", + " ax.plot(years, delta, color=meta['color'],\n", + " linewidth=2, label=meta['label'])\n", + "ax.axhline(0, color='k', linewidth=0.8, linestyle='--')\n", + "ax.set_ylabel('Change in yield vs 2015 (t dm / ha / yr)')\n", + "ax.set_xlabel('Year')\n", + "ax.set_title('Change relative to 2015')\n", + "ax.legend(frameon=False)\n", + "ax.grid(alpha=0.3, linewidth=0.5)\n", + "\n", + "plt.suptitle(\n", + " f'Global Maize Yield — {CROP_MODEL} ({VARIANT}, N={N_FERT} kg/ha/yr)',\n", + " fontsize=13, fontweight='bold'\n", + ")\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Summary table\n", + "print(f'\\n{\" \":12} 2030 2060 2100 Δ2015→2100')\n", + "for ssp, meta in scenarios.items():\n", + " arr = crop_impacts_all[ssp]\n", + " y2030 = arr[2030-2015]\n", + " y2060 = arr[2060-2015]\n", + " y2100 = arr[-1]\n", + " delta = y2100 - arr[0]\n", + " print(f'{meta[\"label\"]:12} {y2030:.2f} {y2060:.2f} {y2100:.2f} {delta:+.2f}')" + ] + }, + { + "cell_type": "markdown", + "id": "d07debef", + "metadata": {}, + "source": [ + "## 6. Regional breakdown (end-of-century)\n", + "\n", + "Compare maize yield changes across regions for SSP2-4.5 and SSP5-8.5." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2fa5bc01", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running ssp245 regional...\n", + "Running ssp585 regional...\n", + "✅ Regional runs complete\n" + ] + } + ], + "source": [ + "REGIONS = {\n", + " 'global': 'Global',\n", + " 'regional:EAS': 'East Asia',\n", + " 'regional:SAS': 'South Asia',\n", + " 'regional:WAF': 'Western Africa',\n", + " 'regional:NEAF': 'NE Africa',\n", + " 'regional:ENA': 'E. N. America',\n", + " 'regional:WCE': 'W&C Europe',\n", + "}\n", + "\n", + "regional_results = {}\n", + "for ssp in ['ssp245', 'ssp585']:\n", + " print(f'Running {ssp} regional...')\n", + " ens = emulator.generate_ensemble_outputs(\n", + " scenario=ssp,\n", + " start_year=2015,\n", + " end_year=2100,\n", + " n_realizations=1,\n", + " timeseries=list(REGIONS.keys()),\n", + " impacts={\n", + " 'crop_yield': {\n", + " 'crops': ['maize'],\n", + " 'crop_model': CROP_MODEL,\n", + " 'variant': VARIANT,\n", + " 'N': N_FERT,\n", + " }\n", + " },\n", + " verbose=False,\n", + " )\n", + " regional_results[ssp] = {\n", + " reg: ens.crop_impacts['maize'][reg] for reg in REGIONS\n", + " }\n", + "\n", + "print('✅ Regional runs complete')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6066f0d3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "reg_labels = list(REGIONS.values())\n", + "reg_keys = list(REGIONS.keys())\n", + "\n", + "# Δ yield 2015→2081-2100 mean\n", + "def end_century_change(ssp, reg_key):\n", + " arr = regional_results[ssp][reg_key]\n", + " return arr[-20:].mean() - arr[0]\n", + "\n", + "delta_245 = [end_century_change('ssp245', k) for k in reg_keys]\n", + "delta_585 = [end_century_change('ssp585', k) for k in reg_keys]\n", + "\n", + "x = np.arange(len(reg_labels))\n", + "width = 0.35\n", + "\n", + "fig, ax = plt.subplots(figsize=(11, 5))\n", + "bars245 = ax.bar(x - width/2, delta_245, width, label='SSP2-4.5',\n", + " color='#f4a261', edgecolor='white')\n", + "bars585 = ax.bar(x + width/2, delta_585, width, label='SSP5-8.5',\n", + " color='#9e2a2b', edgecolor='white')\n", + "\n", + "ax.axhline(0, color='k', linewidth=0.8, linestyle='--')\n", + "ax.set_xticks(x)\n", + "ax.set_xticklabels(reg_labels, rotation=30, ha='right')\n", + "ax.set_ylabel('Δ maize yield 2081–2100 vs 2015 (t dm / ha / yr)')\n", + "ax.set_title(\n", + " f'End-of-century maize yield change by region\\n'\n", + " f'{CROP_MODEL} ({VARIANT}, N={N_FERT} kg/ha/yr)',\n", + " fontsize=12\n", + ")\n", + "ax.legend(frameon=False)\n", + "ax.grid(axis='y', alpha=0.3, linewidth=0.5)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/notebooks_v16_description_paper/METEOR_Interface_Paper_plots.ipynb b/notebooks/notebooks_v16_description_paper/METEOR_Interface_Paper_plots.ipynb index f8ce2e48..494c739e 100644 --- a/notebooks/notebooks_v16_description_paper/METEOR_Interface_Paper_plots.ipynb +++ b/notebooks/notebooks_v16_description_paper/METEOR_Interface_Paper_plots.ipynb @@ -2322,7 +2322,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.12" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/notebooks/paper b/notebooks/paper index 87ff6bd0..85bbacd9 160000 --- a/notebooks/paper +++ b/notebooks/paper @@ -1 +1 @@ -Subproject commit 87ff6bd00d00cca14d316ee4a00cb5e690dac3ca +Subproject commit 85bbacd9753ab359c499f9b2e5a0b1506dc4d168 diff --git a/pyproject.toml b/pyproject.toml index 567a7028..5c5a7a82 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -2,6 +2,9 @@ requires = ["setuptools", "setuptools-scm"] build-backend = "setuptools.build_meta" +[tool.setuptools.package-data] +meteor = ["impacts/ggcm/data/*.nc4"] + [project] name = "meteor" authors = [ @@ -41,6 +44,7 @@ dependencies = [ "scikit-learn", "statsmodels", "regionmask", + "requests", ] [project.optional-dependencies] @@ -112,5 +116,8 @@ skip = [ "src/meteor/_version.py", ] +[tool.black] +target-version = ["py312"] + # ... other project metadata fields as listed in: # https://packaging.python.org/en/latest/guides/writing-pyproject-toml/ \ No newline at end of file diff --git a/src/meteor/cache_handling.py b/src/meteor/cache_handling.py index 74dd6f5f..efd70a78 100644 --- a/src/meteor/cache_handling.py +++ b/src/meteor/cache_handling.py @@ -660,6 +660,27 @@ def get_pattern_scaling_cache_path(self, model_name, scenario="aer", variable=No cache_dir, f"cmip6-{model_name}-{scenario}_pattern_scaling.pkl" ) + def get_subdir(self, name): + """Return the path to a named subdirectory within the cache root. + + The directory is created on demand if it does not already exist. + Useful for non-CMIP6 data (e.g. GGCM coefficient files) that should + live alongside the standard cache structure. + + Parameters + ---------- + name : str + Subdirectory name (e.g. ``'ggcm'``). + + Returns + ------- + str + Absolute path to the subdirectory. + """ + subdir = os.path.join(self.cache_dir, name) + os.makedirs(subdir, exist_ok=True) + return subdir + def get_noise_model_cache_path(self, model_name, variable_name): """ Get the standardized cache file path for a noise model. diff --git a/src/meteor/ensemble_output.py b/src/meteor/ensemble_output.py index e6de46d6..64408c6a 100644 --- a/src/meteor/ensemble_output.py +++ b/src/meteor/ensemble_output.py @@ -76,19 +76,22 @@ class EnsembleOutput: >>> ensemble = emulator.generate(...) >>> >>> # Access time series - >>> tas_global = ensemble['tas'].timeseries['global'] - >>> pr_regional = ensemble['pr'].timeseries['regional:EAS'] + >>> tas_global = ensemble["tas"].timeseries["global"] + >>> pr_regional = ensemble["pr"].timeseries["regional:EAS"] >>> >>> # Access gridded outputs - >>> tas_2050 = ensemble['tas'].gridded['annual'][2050] + >>> tas_2050 = ensemble["tas"].gridded["annual"][2050] >>> >>> # Access impact metrics - >>> hdd = ensemble['tas'].impacts['hdd']['point:59.9,10.8'] + >>> hdd = ensemble["tas"].impacts["hdd"]["point:59.9,10.8"] """ def __init__(self, results=None, metadata=None): self.variables = results or {} self.metadata = metadata or {} + # Top-level dict for crop yield impacts, which depend on both tas and pr. + # Structure: {crop_name: {agg_key: np.ndarray (n_years,)}} + self.crop_impacts = {} def __getitem__(self, key): """Access variable outputs.""" diff --git a/src/meteor/impacts/__init__.py b/src/meteor/impacts/__init__.py index 68523c8e..9c9d8215 100644 --- a/src/meteor/impacts/__init__.py +++ b/src/meteor/impacts/__init__.py @@ -21,6 +21,7 @@ create_impact_ensemble, ensemble_statistics, ) +from .ggcm import GgcmDownloader, load_agmerra_baseline from .impacts_core import ImpactCalculator, ImpactEnsemble, ImpactResult __all__ = [ @@ -28,6 +29,8 @@ "ImpactResult", "ImpactEnsemble", "DegreeDaysCalculator", + "GgcmDownloader", + "load_agmerra_baseline", "apply_impact_calculator", "create_impact_ensemble", "ensemble_statistics", diff --git a/src/meteor/impacts/ggcm/__init__.py b/src/meteor/impacts/ggcm/__init__.py new file mode 100644 index 00000000..7e575b49 --- /dev/null +++ b/src/meteor/impacts/ggcm/__init__.py @@ -0,0 +1,38 @@ +""" +GGCM crop yield emulation for METEOR +===================================== + +Vendored and adapted from the GGCMI Phase 2 emulator +(Franke et al., 2020, https://doi.org/10.5194/gmd-13-3995-2020). + +Coefficient files (~110 MB each) are downloaded on demand from +Zenodo record 3592453 and stored in METEOR's cache directory. +The AgMERRA 1980-2010 climatological baseline is bundled with this package. +""" + +from .baseline import load_agmerra_baseline +from .coefficients import get_yields, load_coefficients +from .data_catalog import ( + CROP_MODELS, + CROPS, + get_available_crops, + get_available_models, + get_download_url, + get_filename, + is_available, +) +from .downloader import GgcmDownloader + +__all__ = [ + "load_agmerra_baseline", + "get_yields", + "load_coefficients", + "GgcmDownloader", + "CROPS", + "CROP_MODELS", + "is_available", + "get_filename", + "get_download_url", + "get_available_crops", + "get_available_models", +] diff --git a/src/meteor/impacts/ggcm/baseline.py b/src/meteor/impacts/ggcm/baseline.py new file mode 100644 index 00000000..7896671a --- /dev/null +++ b/src/meteor/impacts/ggcm/baseline.py @@ -0,0 +1,54 @@ +""" +Load the AgMERRA 1980-2010 climatological baseline bundled with METEOR. + +The two netCDF4 files bundled in meteor/impacts/ggcm/data/ are the +pre-processed AgMERRA averages required by the GGCMI Phase 2 emulator +(Franke et al., 2020) as the historical reference climate baseline. +They define the valid input ranges for temperature and precipitation and +set the reference point for the anomaly inputs to the polynomial. +""" + +import importlib.resources + +import netCDF4 as netcdf # pylint: disable=no-member +import numpy as np + + +def load_agmerra_baseline(): + """Load the bundled AgMERRA 1980-2010 climatological means. + + Returns + ------- + T_agmerra : np.ndarray, shape (360, 720) + Annual mean temperature in degrees Celsius. + Row 0 = 89.75 N, row 359 = -89.75 S, step 0.5 deg. + Column 0 = -179.75 W, column 719 = 179.75 E, step 0.5 deg. + W_agmerra : np.ndarray, shape (360, 720) + Annual mean precipitation in mm/yr, floor-clipped at 1 mm/yr + to avoid division-by-zero in the precipitation ratio computation. + """ + # pylint: disable=invalid-name + data_pkg = importlib.resources.files("meteor.impacts.ggcm.data") + + with importlib.resources.as_file( + data_pkg / "agmerra-tavg-avg-1980-2010-05deg-adjlon.nc4" + ) as p: + nc = netcdf.Dataset(str(p), "r") # pylint: disable=no-member + raw = nc.variables["tavg"][0, :, :] # MaskedArray, °C + # Convert to plain float64; fill masked ocean cells with 0 °C + T_agmerra = np.ma.filled(raw, 0.0).astype(np.float64) + nc.close() + + with importlib.resources.as_file( + data_pkg / "agmerra-prate-avg-1980-2010-05deg-adjlon.nc4" + ) as p: + nc = netcdf.Dataset(str(p), "r") # pylint: disable=no-member + raw = nc.variables["prate"][0, :, :] # MaskedArray, mm/day + # Convert to mm/yr; fill masked ocean cells with a small positive value + W_agmerra = np.ma.filled(raw, 1.0 / 365.25).astype(np.float64) * 365.25 + nc.close() + + # Floor precipitation to avoid divison by zero in the W ratio + W_agmerra[W_agmerra < 1] = 1.0 + + return T_agmerra, W_agmerra diff --git a/src/meteor/impacts/ggcm/coefficients.py b/src/meteor/impacts/ggcm/coefficients.py new file mode 100644 index 00000000..c033d04a --- /dev/null +++ b/src/meteor/impacts/ggcm/coefficients.py @@ -0,0 +1,129 @@ +""" +Vendored polynomial evaluator from the GGCMI Phase 2 emulator. + +Faithfully reproduces the core mathematics of Franke et al. (2020) +(https://doi.org/10.5194/gmd-13-3995-2020) without external dependencies +on the original ggcm_emulator package. +""" + +import netCDF4 as netcdf +import numpy as np + + +def load_coefficients(filepath): # pylint: disable=invalid-name + """Load the K coefficient tensor from a GGCMI Phase 2 nc4 file. + + Parameters + ---------- + filepath : str + Path to a file of the form + ``{CropModel}_{crop}_ggcmi_phase2_emulator_{variant}.nc4``. + + Returns + ------- + K : np.ndarray, shape (35, 360, 720) + Polynomial coefficients; spatially varying per 0.5-degree grid cell. + """ + nc = netcdf.Dataset(filepath, "r") # pylint: disable=no-member + K = np.array( # pylint: disable=invalid-name + nc.variables["K_rf"][:, :, :], dtype=np.float64 + ) + nc.close() + return K + + +def get_yields(K, Ca, Ta, Wa, Na, T_agmerra, W_agmerra): # pylint: disable=invalid-name + """Evaluate the 35-term GGCMI Phase 2 crop yield polynomial. + + Implements Equation (1) from Franke et al. (2020). Input bounds are + enforced by clamping; out-of-bounds offsets are returned so callers can + diagnose extrapolation. + + Parameters + ---------- + K : np.ndarray, shape (35, 360, 720) + Coefficient tensor loaded by :func:`load_coefficients`. + Ca : float + Global annual mean CO2 concentration (ppm). Valid range: 360-810. + Ta : np.ndarray, shape (360, 720) + Annual mean temperature in degrees Celsius on the 0.5-degree grid. + Must be absolute temperature (not an anomaly). + Wa : np.ndarray, shape (360, 720) + Annual mean precipitation in mm/yr on the 0.5-degree grid. + Must be absolute precipitation. + Na : float + Uniform nitrogen application (kg N / ha / yr). Valid range: 10-200. + T_agmerra : np.ndarray, shape (360, 720) + AgMERRA 1980-2010 temperature baseline in degrees Celsius. + W_agmerra : np.ndarray, shape (360, 720) + AgMERRA 1980-2010 precipitation baseline in mm/yr. + + Returns + ------- + Yield : np.ndarray, shape (360, 720) + Estimated crop yield in t dry matter / ha / yr. Clipped to >= 0. + W_oob : np.ndarray, shape (360, 720) + Precipitation out-of-bounds offset (mm/yr). Negative = below lower + bound; positive = above upper bound. + T_oob : np.ndarray, shape (360, 720) + Temperature out-of-bounds offset (degrees Celsius), same convention. + """ + # pylint: disable=invalid-name + # Clamp inputs to valid ranges + C_san = min(max(360.0, Ca), 810.0) + T_san = np.minimum(np.maximum(T_agmerra - 1.0, Ta), T_agmerra + 6.0) + W_san = np.minimum(np.maximum(0.5 * W_agmerra, Wa), 1.3 * W_agmerra) + N_san = min(max(10.0, Na), 200.0) + + T_oob = Ta - T_san + W_oob = Wa - W_san + + # Transform inputs for polynomial evaluation + C = C_san + T = T_san - T_agmerra # temperature anomaly from AgMERRA baseline + W = W_san / W_agmerra # precipitation ratio relative to AgMERRA baseline + N = N_san + + # 35-term third-order polynomial (Eq. 1, Franke et al. 2020) + # Python indices are shifted by -1 from the paper's 1-based notation. + Yield = ( + K[0] + + K[1] * C + + K[2] * T + + K[3] * W + + K[4] * N + + K[5] * C**2 + + K[6] * C * T + + K[7] * C * W + + K[8] * C * N + + K[9] * T**2 + + K[10] * T * W + + K[11] * T * N + + K[12] * W**2 + + K[13] * W * N + + K[14] * N**2 + + K[15] * C**3 + + K[16] * C**2 * T + + K[17] * C**2 * W + + K[18] * C**2 * N + + K[19] * C * T**2 + + K[20] * C * T * W + + K[21] * C * T * N + + K[22] * C * W**2 + + K[23] * C * W * N + + K[24] * C * N**2 + + K[25] * T**3 + + K[26] * T**2 * W + + K[27] * T**2 * N + + K[28] * T * W**2 + + K[29] * T * W * N + + K[30] * T * N**2 + + K[31] * W**3 + + K[32] * W**2 * N + + K[33] * W * N**2 + ) + + # Yield is non-negative by definition + Yield[Yield < 0] = 0.0 + + return Yield, W_oob, T_oob diff --git a/src/meteor/impacts/ggcm/data/__init__.py b/src/meteor/impacts/ggcm/data/__init__.py new file mode 100644 index 00000000..a7106664 --- /dev/null +++ b/src/meteor/impacts/ggcm/data/__init__.py @@ -0,0 +1 @@ +"""Bundled AgMERRA baseline data files for the GGCMI Phase 2 emulator.""" diff --git a/src/meteor/impacts/ggcm/data/agmerra-prate-avg-1980-2010-05deg-adjlon.nc4 b/src/meteor/impacts/ggcm/data/agmerra-prate-avg-1980-2010-05deg-adjlon.nc4 new file mode 100644 index 00000000..fe63b5e9 Binary files /dev/null and b/src/meteor/impacts/ggcm/data/agmerra-prate-avg-1980-2010-05deg-adjlon.nc4 differ diff --git a/src/meteor/impacts/ggcm/data/agmerra-tavg-avg-1980-2010-05deg-adjlon.nc4 b/src/meteor/impacts/ggcm/data/agmerra-tavg-avg-1980-2010-05deg-adjlon.nc4 new file mode 100644 index 00000000..919be709 Binary files /dev/null and b/src/meteor/impacts/ggcm/data/agmerra-tavg-avg-1980-2010-05deg-adjlon.nc4 differ diff --git a/src/meteor/impacts/ggcm/data_catalog.py b/src/meteor/impacts/ggcm/data_catalog.py new file mode 100644 index 00000000..6e444bc1 --- /dev/null +++ b/src/meteor/impacts/ggcm/data_catalog.py @@ -0,0 +1,134 @@ +""" +Static catalog of GGCM coefficient files hosted on Zenodo record 3592453. + +Reference: Franke, J. A., et al. (2020). The GGCMI Phase 2 emulators: global +gridded crop model yield responses to changes in CO2, temperature, water, and +nitrogen. Geoscientific Model Development, 13, 3995-4018. +https://doi.org/10.5194/gmd-13-3995-2020 +""" + +ZENODO_RECORD_ID = "3592453" +ZENODO_BASE_URL = f"https://zenodo.org/records/{ZENODO_RECORD_ID}/files" +ZENODO_API_URL = f"https://zenodo.org/api/records/{ZENODO_RECORD_ID}" + +CROPS = ["maize", "rice", "soy", "spring_wheat", "winter_wheat"] + +CROP_MODELS = [ + "CARAIB", + "EPIC-TAMU", + "GEPIC", + "JULES", + "LPJ-GUESS", + "LPJmL", + "pDSSAT", + "PEPIC", + "PROMET", +] + +# Availability matrix: model → crop → list of available variants +FILE_AVAILABILITY = { + "CARAIB": { + "maize": ["A0", "A1"], + "rice": ["A0", "A1"], + "soy": ["A0", "A1"], + "spring_wheat": ["A0", "A1"], + "winter_wheat": ["A0", "A1"], + }, + "EPIC-TAMU": { + "maize": ["A0", "A1"], + "rice": ["A0", "A1"], + "soy": ["A0", "A1"], + "spring_wheat": ["A0", "A1"], + "winter_wheat": ["A0", "A1"], + }, + "GEPIC": { + "maize": ["A0", "A1"], + "rice": ["A0", "A1"], + "soy": ["A0", "A1"], + "spring_wheat": ["A0", "A1"], + "winter_wheat": ["A0", "A1"], + }, + "JULES": { + "maize": ["A0"], + "rice": ["A0"], + "soy": ["A0"], + "spring_wheat": ["A0"], + }, + "LPJ-GUESS": { + "maize": ["A0", "A1"], + "rice": ["A0", "A1"], + "spring_wheat": ["A0", "A1"], + "winter_wheat": ["A0", "A1"], + }, + "LPJmL": { + "maize": ["A0", "A1"], + "rice": ["A0", "A1"], + "soy": ["A0", "A1"], + "spring_wheat": ["A0", "A1"], + "winter_wheat": ["A0", "A1"], + }, + "pDSSAT": { + "maize": ["A0", "A1"], + "rice": ["A0", "A1"], + "soy": ["A0", "A1"], + "spring_wheat": ["A0", "A1"], + "winter_wheat": ["A0", "A1"], + }, + "PEPIC": { + "maize": ["A0", "A1"], + "rice": ["A0", "A1"], + "soy": ["A0", "A1"], + "spring_wheat": ["A0", "A1"], + "winter_wheat": ["A0", "A1"], + }, + "PROMET": { + "maize": ["A0", "A1"], + "rice": ["A0", "A1"], + "soy": ["A0", "A1"], + "spring_wheat": ["A0", "A1"], + "winter_wheat": ["A0", "A1"], + }, +} + + +def is_available(crop_model, crop, variant="A0"): + """Return True if this model/crop/variant combination exists on Zenodo.""" + if crop_model not in FILE_AVAILABILITY: + return False + if crop not in FILE_AVAILABILITY[crop_model]: + return False + return variant in FILE_AVAILABILITY[crop_model][crop] + + +def get_filename(crop_model, crop, variant="A0"): + """Return the standardised filename for a given model/crop/variant.""" + return f"{crop_model}_{crop}_ggcmi_phase2_emulator_{variant}.nc4" + + +def get_download_url(crop_model, crop, variant="A0"): + """Return the full Zenodo download URL. + + Raises ValueError if the combination is not available. + """ + if not is_available(crop_model, crop, variant): + raise ValueError(f"Not available: {crop_model} / {crop} / {variant}") + return f"{ZENODO_BASE_URL}/{get_filename(crop_model, crop, variant)}" + + +def get_available_crops(crop_model=None): + """Return list of crops, optionally filtered to a specific model.""" + if crop_model is None: + return CROPS + return list(FILE_AVAILABILITY.get(crop_model, {}).keys()) + + +def get_available_models(crop=None): + """Return list of models, optionally filtered to those supporting a crop.""" + if crop is None: + return CROP_MODELS + return [m for m in CROP_MODELS if crop in FILE_AVAILABILITY.get(m, {})] + + +def get_available_variants(crop_model, crop): + """Return list of available variants for a model/crop combination.""" + return FILE_AVAILABILITY.get(crop_model, {}).get(crop, []) diff --git a/src/meteor/impacts/ggcm/downloader.py b/src/meteor/impacts/ggcm/downloader.py new file mode 100644 index 00000000..c69f2aa0 --- /dev/null +++ b/src/meteor/impacts/ggcm/downloader.py @@ -0,0 +1,129 @@ +""" +Download GGCMI Phase 2 coefficient files from Zenodo into METEOR's cache. + +Coefficient files (~110 MB each, 82 total across all models and crops) are +hosted at https://zenodo.org/records/3592453. This module integrates with +METEOR's CacheHandler so all GGCM data lands alongside cmip6/, pattern_scaling/, +etc. under the single METEOR cache root. +""" + +import logging +from pathlib import Path + +from . import data_catalog as catalog + +log = logging.getLogger(__name__) + +CHUNK_SIZE = 8192 # 8 KB streaming chunks + + +class GgcmDownloader: + """Download and manage GGCM polynomial coefficient files. + + Parameters + ---------- + cache_dir : str + Directory where coefficient files will be stored. Typically obtained + from ``cache_handler.get_subdir('ggcm')``. + """ + + def __init__(self, cache_dir): + self.cache_dir = Path(cache_dir) + self.cache_dir.mkdir(parents=True, exist_ok=True) + + def get_filepath(self, crop_model, crop, variant): + """Return the expected local path for a coefficient file.""" + return self.cache_dir / catalog.get_filename(crop_model, crop, variant) + + def ensure_files(self, crops, crop_model, variant="A0"): + """Ensure all required coefficient files are present. + + Validates the requested combination against the catalog, identifies + any missing files, and (after a single user prompt) downloads them + from Zenodo with progress bars. + + Parameters + ---------- + crops : list of str + Crop names to check (e.g. ``['maize', 'spring_wheat']``). + crop_model : str + GGCM model name (e.g. ``'LPJmL'``). + variant : str + ``'A0'`` (no adaptation) or ``'A1'`` (with adaptation). + + Raises + ------ + ValueError + If a requested crop/model/variant combination is not in the catalog. + ImportError + If ``requests`` is not installed. + """ + for crop in crops: + if not catalog.is_available(crop_model, crop, variant): + available = catalog.get_available_crops(crop_model) + raise ValueError( + f"Crop '{crop}' not available for model '{crop_model}' " + f"with variant '{variant}'. " + f"Available crops: {available}" + ) + + missing = [ + crop + for crop in crops + if not self.get_filepath(crop_model, crop, variant).exists() + ] + + if not missing: + return + + try: + import requests # pylint: disable=import-outside-toplevel + from tqdm import tqdm # pylint: disable=import-outside-toplevel + except ImportError as exc: + raise ImportError( + "The 'requests' package is required to download GGCM files.\n" + "Install it with: pip install requests" + ) from exc + + size_mb = len(missing) * 110 + print( + f"\nDownloading {len(missing)} GGCM coefficient file(s) for " + f"{crop_model} ({variant}) from Zenodo record {catalog.ZENODO_RECORD_ID}:" + ) + for crop in missing: + print(f" - {catalog.get_filename(crop_model, crop, variant)}") + print(f" (~{size_mb} MB total → {self.cache_dir})") + + for crop in missing: + url = catalog.get_download_url(crop_model, crop, variant) + dest = self.get_filepath(crop_model, crop, variant) + log.info("Downloading %s", dest.name) + self._download_file(url, dest, requests, tqdm) + + def _download_file(self, url, filepath, requests, tqdm): + """Stream a single file with resume capability and a progress bar.""" + resume_bytes = 0 + headers = {} + if filepath.exists(): + resume_bytes = filepath.stat().st_size + headers = {"Range": f"bytes={resume_bytes}-"} + + resp = requests.get(url, headers=headers, stream=True, timeout=60) + resp.raise_for_status() + + total = int(resp.headers.get("content-length", 0)) + resume_bytes + mode = "ab" if resume_bytes else "wb" + + with ( + open(filepath, mode) as fh, + tqdm( + total=total, + initial=resume_bytes, + unit="B", + unit_scale=True, + desc=filepath.name, + ) as pbar, + ): + for chunk in resp.iter_content(CHUNK_SIZE): + fh.write(chunk) + pbar.update(len(chunk)) diff --git a/src/meteor/meteor_interface.py b/src/meteor/meteor_interface.py index a8987333..1873624a 100644 --- a/src/meteor/meteor_interface.py +++ b/src/meteor/meteor_interface.py @@ -6,6 +6,8 @@ """ import os +from dataclasses import dataclass +from typing import Any import numpy as np import xarray as xr @@ -59,6 +61,90 @@ def _get_default_config(variable): return config +@dataclass +class PatternScalingResult: + """ + Result of a pattern scaling computation. + + Holds both the time-sliced pattern scaling output used directly by the + generators and the full-trajectory warming plus slice bookkeeping needed to + generate spun-up stochastic PCs over the full trajectory and slice them to + the requested output window. + + Attributes + ---------- + monthly_prediction : xr.DataArray + Monthly pattern prediction sliced to the requested output window. + monthly_warming : np.ndarray + Global-mean monthly warming sliced to the requested output window. + em_data : Any + Emissions data used to drive the pattern model. + conc_data : Any + Concentration data used to drive the pattern model. + full_monthly_warming : np.ndarray + Global-mean monthly warming over the full (un-sliced) trajectory. Used to + generate stochastic PCs so the autoregressive spin-up transient is parked + at the trajectory start rather than inside the output window. + base_year : int + First year of the full monthly trajectory (origin for all month indexing). + start_month_idx : int + Month index (relative to ``base_year``) of the first output month. + end_month_idx : int + Month index (relative to ``base_year``) one past the last output month. + """ + + monthly_prediction: xr.DataArray + monthly_warming: np.ndarray + em_data: Any + conc_data: Any + full_monthly_warming: np.ndarray + base_year: int + start_month_idx: int + end_month_idx: int + + +@dataclass +class GenerationInputs: + """ + Shared inputs prepared once per variable and consumed by both generators. + + Produced by :meth:`MeteorInterface._prepare_generation` and passed to both + ``_generate_timeseries`` and ``_generate_gridded`` so the two paths share the + same pattern scaling and the same spun-up stochastic PC realisations. + + Attributes + ---------- + pattern : PatternScalingResult + Pattern scaling result (sliced prediction/warming + slice bookkeeping). + stochastic_pcs : np.ndarray or None + Stochastic PCs generated once over the full trajectory and sliced to the + output window. Shape ``(n_realizations, n_months, n_modes)``. ``None`` when + ``include_noise`` is False. + """ + + pattern: PatternScalingResult + stochastic_pcs: Any + + +def _stack_realizations(realizations): + """ + Stack a list of per-realization DataArrays along a ``realization`` dimension. + + Parameters + ---------- + realizations : list of xr.DataArray + One DataArray per ensemble member. + + Returns + ------- + xr.DataArray + Concatenated array with a leading ``realization`` dimension. + """ + if len(realizations) > 1: + return xr.concat(realizations, dim="realization") + return realizations[0].expand_dims(realization=[0]) + + class MeteorInterface: """ High-level interface for training and generating METEOR emulators. @@ -86,42 +172,38 @@ class MeteorInterface: -------- >>> # Simple single-variable case >>> emulator = MeteorInterface( - ... model='NorESM2-MM', - ... variables='pr', - ... cache_dir='./cache' + ... model="NorESM2-MM", variables="pr", cache_dir="./cache" ... ) >>> emulator.train() >>> ensemble = emulator.generate_ensemble_outputs( - ... scenario='ssp245', + ... scenario="ssp245", ... start_year=2020, ... end_year=2100, ... n_realizations=100, - ... timeseries=['global', 'regional:EAS'] + ... timeseries=["global", "regional:EAS"], ... ) >>> >>> # Multi-variable with gridded output >>> emulator = MeteorInterface( - ... model='CESM2', - ... variables=['tas', 'pr'], - ... cache_dir='./cache' + ... model="CESM2", variables=["tas", "pr"], cache_dir="./cache" ... ) >>> emulator.train() >>> ensemble = emulator.generate_ensemble_outputs( - ... scenario='ssp245', + ... scenario="ssp245", ... start_year=2020, ... end_year=2100, ... n_realizations=100, - ... timeseries=['global'], - ... gridded={'annual': [2030, 2050, 2100]} + ... timeseries=["global"], + ... gridded={"annual": [2030, 2050, 2100]}, ... ) >>> >>> # Custom emissions scenario >>> ensemble = emulator.generate_ensemble_outputs( - ... scenario={'emissions': 'path/to/custom_emissions.txt'}, + ... scenario={"emissions": "path/to/custom_emissions.txt"}, ... start_year=2020, ... end_year=2100, ... n_realizations=100, - ... timeseries=['global'] + ... timeseries=["global"], ... ) """ @@ -224,15 +306,18 @@ def train(self, training_scenario="ssp245", variable_configs=None, verbose=True) >>> emulator.train() >>> >>> # Custom training scenario for all variables - >>> emulator.train(training_scenario='ssp370') + >>> emulator.train(training_scenario="ssp370") >>> >>> # Custom configuration with per-variable scenarios >>> emulator.train( - ... training_scenario='ssp245', # default for most variables + ... training_scenario="ssp245", # default for most variables ... variable_configs={ - ... 'tas': {'n_modes_noise': 40, 'use_exog': 'all'}, - ... 'pr': {'n_modes_noise': 40, 'training_scenario': 'ssp370'} # override for pr - ... } + ... "tas": {"n_modes_noise": 40, "use_exog": "all"}, + ... "pr": { + ... "n_modes_noise": 40, + ... "training_scenario": "ssp370", + ... }, # override for pr + ... }, ... ) """ if verbose: # pragma: no cover @@ -538,23 +623,23 @@ def generate_ensemble_outputs( -------- >>> # Generate ensemble with noise >>> ensemble = emulator.generate_ensemble_outputs( - ... scenario='ssp245', + ... scenario="ssp245", ... start_year=2020, ... end_year=2100, ... n_realizations=100, - ... timeseries=['global', 'regional:EAS', 'point:59.9,10.8'], - ... gridded={'annual': [2030, 2050, 2100]}, - ... impacts={'tas': {'degree_days': {'hdd_base': 18.0, 'cdd_base': 18.0}}} + ... timeseries=["global", "regional:EAS", "point:59.9,10.8"], + ... gridded={"annual": [2030, 2050, 2100]}, + ... impacts={"tas": {"degree_days": {"hdd_base": 18.0, "cdd_base": 18.0}}}, ... ) >>> >>> # Generate climatology only (no noise) >>> climatology = emulator.generate_ensemble_outputs( - ... scenario='ssp245', + ... scenario="ssp245", ... start_year=2020, ... end_year=2100, ... n_realizations=1, # Ignored, forced to 1 - ... timeseries=['global'], - ... include_noise=False + ... timeseries=["global"], + ... include_noise=False, ... ) """ # Handle climatology-only mode @@ -589,6 +674,24 @@ def generate_ensemble_outputs( var_output = VariableOutput(variable) + # Prepare shared generation inputs ONCE when both output types are + # requested, so the time series and gridded paths are driven by the + # same pattern scaling and the same spun-up stochastic PCs (mutually + # consistent noise). When only one type is requested there is nothing + # to be consistent with, so that generator builds its own inputs. + gen_inputs = None + if timeseries and gridded: + gen_inputs = self._prepare_generation( + variable, + scenario, + start_year, + end_year, + n_realizations, + include_noise=include_noise, + temp_scaling_ts=temp_scaling_ts, + verbose=verbose, + ) + # Generate timeseries if requested if timeseries: if verbose: # pragma: no cover @@ -600,6 +703,7 @@ def generate_ensemble_outputs( end_year, n_realizations, timeseries, + gen_inputs=gen_inputs, custom_regions=custom_regions, include_noise=include_noise, temp_scaling_ts=temp_scaling_ts, @@ -617,6 +721,7 @@ def generate_ensemble_outputs( end_year, n_realizations, gridded, + gen_inputs=gen_inputs, include_noise=include_noise, temp_scaling_ts=temp_scaling_ts, verbose=verbose, @@ -651,6 +756,22 @@ def generate_ensemble_outputs( }, ) + # Apply crop yield impacts if requested. + # These live on EnsembleOutput rather than on a single VariableOutput + # because they depend on both tas and pr together. + if impacts and "crop_yield" in impacts: + if verbose: # pragma: no cover + print("\n🌾 Computing crop yield impacts...") + ensemble.crop_impacts = self._apply_crop_yields( + scenario, + start_year, + end_year, + impacts["crop_yield"], + timeseries_keys=timeseries if timeseries else [], + custom_regions=custom_regions, + verbose=verbose, + ) + # Save if requested if save_to: ensemble.to_netcdf(save_to) @@ -693,8 +814,10 @@ def _get_or_compute_pattern_scaling( Returns ------- - tuple - (monthly_prediction_sliced, monthly_warming_sliced, em_data, conc_data) + PatternScalingResult + Sliced monthly prediction/warming plus the full-trajectory warming and + slice bookkeeping (``base_year``, ``start_month_idx``, ``end_month_idx``) + needed to generate spun-up stochastic PCs aligned to the output window. """ # Parse scenario input scenario_info = parse_scenario_input(scenario) @@ -824,7 +947,16 @@ def _get_or_compute_pattern_scaling( ) monthly_warming_sliced = full_monthly_warming[start_month_idx:end_month_idx] - return monthly_prediction_sliced, monthly_warming_sliced, em_data, conc_data + return PatternScalingResult( + monthly_prediction=monthly_prediction_sliced, + monthly_warming=monthly_warming_sliced, + em_data=em_data, + conc_data=conc_data, + full_monthly_warming=full_monthly_warming, + base_year=base_year, + start_month_idx=start_month_idx, + end_month_idx=end_month_idx, + ) # TODO - possibly add verbosity? def _compute_timeseries_scaling( @@ -937,61 +1069,50 @@ def _compute_timeseries_scaling( ) return annual_prediction_base + annual_prediction_anomaly * temp_scaling - def _generate_timeseries( + def _prepare_generation( self, variable, scenario, start_year, end_year, n_realizations, - aggregations, - custom_regions=None, include_noise=True, temp_scaling_ts=None, verbose=True, ): """ - Generate time series outputs with spatial aggregations. + Prepare the shared inputs consumed by both output generators. + + Computes pattern scaling once and generates the stochastic PCs once over + the FULL trajectory (so the autoregressive spin-up transient is parked at + the trajectory start, not inside the output window), then slices the PCs to + the requested output window. The resulting :class:`GenerationInputs` is + passed to both ``_generate_timeseries`` and ``_generate_gridded`` so the two + paths are driven by identical pattern scaling and identical noise draws. Parameters ---------- variable : str - Climate variable to generate - scenario : str - Emission scenario ('ssp245', 'ssp585', etc.) - start_year : int - Start year - end_year : int - End year (inclusive) + Climate variable ('tas', 'pr'). + scenario : str or dict + Scenario specification (see :meth:`generate_ensemble_outputs`). + start_year, end_year : int + Output window (inclusive). n_realizations : int - Number of ensemble members - aggregations : list of str - Spatial aggregations to compute: - - 'global': Global mean - - 'regional:CODE': AR6 region mean (e.g., 'regional:NEU') - - 'regional:custom:NAME': Custom region (requires custom_regions dict) - - 'point:LAT,LON': Single grid point (e.g., 'point:59.9,10.8') - custom_regions : dict, optional - Custom region definitions: {'name': {'lat': (min, max), 'lon': (min, max)}} + Number of ensemble members. include_noise : bool - If True, add stochastic noise; if False, return forced response only + If False, no PCs are generated (climatology only). + temp_scaling_ts : xr.DataArray, optional + Optional global-mean temperature trajectory to scale the pattern to. verbose : bool - Print progress messages + Print progress messages. Returns ------- - dict - Dictionary mapping aggregation names to xarray DataArrays - with shape (n_realizations, n_months) + GenerationInputs + Shared pattern scaling result and (window-sliced) stochastic PCs. """ - # Always use the TRAINING scenario for transform fitting, not the - # prediction scenario. default is ssp245 - transform_training_scenario = self._training_config.get(variable, {}).get( - "training_scenario", "ssp245" - ) - - # Get pattern scaling results - pattern_result = self._get_or_compute_pattern_scaling( + pattern = self._get_or_compute_pattern_scaling( variable, scenario, start_year, @@ -999,10 +1120,75 @@ def _generate_timeseries( temp_scaling_ts=temp_scaling_ts, verbose=verbose, ) - monthly_prediction = pattern_result[0] - monthly_warming = pattern_result[1] - # Get CMIP6 data for transform fitting + stochastic_pcs = None + if include_noise: + noise_model = self.noise_models[variable] + if verbose: # pragma: no cover + print( + f" → Generating {n_realizations} stochastic PC realizations " + "(full trajectory, spun-up)..." + ) + # Generate over the FULL trajectory so spin-up is resolved before the + # output window, then slice to the window on a January boundary + # (start_month_idx is always a multiple of 12). + full_pcs = noise_model.generate_stochastic_pcs( + pattern.full_monthly_warming, + n_realizations=n_realizations, + random_seed=None, + ) + if full_pcs.ndim == 2: + # Single realization -> add leading realization axis + full_pcs = full_pcs[np.newaxis, ...] + stochastic_pcs = full_pcs[ + :, pattern.start_month_idx : pattern.end_month_idx, : + ] + + return GenerationInputs(pattern=pattern, stochastic_pcs=stochastic_pcs) + + def _get_transform_config(self, variable): + """ + Return the resolved transform config for a variable, or None. + + Handles both the fitted case (stored as a dict with a ``'config'`` entry) + and the not-yet-fitted case (stored as a ``VariableTransformConfig``). + """ + transform_info = self.transforms.get(variable, None) + if isinstance(transform_info, dict): + return transform_info.get("config") + return transform_info + + def _load_transform_reference(self, variable, start_year, end_year, verbose=True): + """ + Load and prepare CMIP6 reference data for distribution-transform fitting. + + Only needed for variables that have a distribution transform (e.g. ``pr``). + Returns the gridded CMIP6 reference field sliced to the output window plus, + for precipitation, the gridded first-year baseline field. The timeseries + path aggregates these per requested region; the gridded path uses them + directly with the per-gridpoint (3D) transform. + + Parameters + ---------- + variable : str + Climate variable. + start_year, end_year : int + Output window (inclusive). + verbose : bool + Print progress messages. + + Returns + ------- + tuple + ``(ssp_data, pr_first_year_mean)`` where ``ssp_data`` is the gridded + reference field (anomalies for ``tas``, absolute for ``pr``) and + ``pr_first_year_mean`` is the gridded first-year baseline field for + ``pr`` (``None`` otherwise). + """ + transform_training_scenario = self._training_config.get(variable, {}).get( + "training_scenario", "ssp245" + ) + if verbose: # pragma: no cover print( f" → Loading CMIP6 training data for {transform_training_scenario}..." @@ -1011,47 +1197,37 @@ def _generate_timeseries( ["historical", transform_training_scenario], self.model, monthly=True )[variable] - # Load piControl data for baseline (used for temperature anomalies) if verbose: # pragma: no cover print(f" → Loading piControl baseline for {variable}...") picontrol_data = self.data_getter.make_meteor_training_data_composite( ["piControl"], self.model, monthly=True )[variable] - # Compute piControl climatology (mean across all time) picontrol_mean = picontrol_data.mean(dim="month") - # For precipitation: use first-year (2015) baseline instead of piControl - # This is because CMIP6 scenarios in 2015 already include ~1°C of historical - # warming effects on precipitation, so using piControl would create a ~2-4% bias. - # We use the first 12 months of the prediction period (start_year) as the baseline. - # Note: ssp_data is a composite starting from historical (~1850), so we need to - # find the correct index for start_year. + pr_first_year_mean = None + + # For precipitation: use first-year baseline instead of piControl. CMIP6 + # scenarios already include ~1°C of historical warming effects on + # precipitation, so piControl would create a ~2-4% bias. Use the first 12 + # months of the prediction period (start_year) as the baseline. ssp_data is + # a composite starting from historical (~1850), so find the index for + # start_year. if variable == "pr": - # Infer composite start year from the data length and structure - # Historical experiments in CMIP6 typically start at 1850 - # We can infer this from the data by checking if it includes historical n_months = len(ssp_data.month) - # Check if ssp_data has a 'start_year' attribute (set by data getter) - # Otherwise infer from experiment structure if hasattr(ssp_data, "start_year"): composite_start_year = int(ssp_data.start_year) else: # Default assumption: historical+scenario composite starts at 1850 - # If the data is shorter than expected, calculate backwards from end_year expected_months_from_1850 = (end_year - 1850 + 1) * 12 if n_months < expected_months_from_1850: - # Data is shorter - calculate start year from data length composite_start_year = end_year - (n_months // 12) + 1 else: composite_start_year = 1850 start_year_idx = (start_year - composite_start_year) * 12 - end_year_idx = ( - end_year - composite_start_year + 1 - ) * 12 # +1 for inclusive + end_year_idx = (end_year - composite_start_year + 1) * 12 # inclusive - # Validate indices are within bounds - fail loudly if not composite_end_year = composite_start_year + n_months // 12 - 1 if start_year_idx < 0: @@ -1075,9 +1251,9 @@ def _generate_timeseries( month=slice(start_year_idx, start_year_idx + 12) ).mean(dim="month") - # CRITICAL: Slice ssp_data to only the prediction period (start_year to end_year) - # for Gamma transform fitting. Using the full historical+scenario composite - # would result in a lower mean distribution, causing negative bias. + # CRITICAL: Slice ssp_data to only the prediction period for Gamma + # transform fitting. Using the full historical+scenario composite would + # result in a lower mean distribution, causing negative bias. ssp_data = ssp_data.isel(month=slice(start_year_idx, end_year_idx)) if verbose: # pragma: no cover @@ -1085,9 +1261,8 @@ def _generate_timeseries( f" → Using {start_year} baseline for PR instead of piControl" ) - # For temperature: convert CMIP6 to anomalies (pattern scaling outputs anomalies) - # For precipitation: keep CMIP6 as absolute values (for Gamma transform fitting) - # but we'll add first-year baseline to pattern output below + # For temperature: convert CMIP6 to anomalies (pattern scaling outputs + # anomalies). For precipitation keep absolute values for Gamma fitting. if variable == "tas": if verbose: # pragma: no cover print( @@ -1095,36 +1270,92 @@ def _generate_timeseries( ) ssp_data = ssp_data - picontrol_mean - # ✅ Generate stochastic PCs (or skip if climatology only) - noise_model = self.noise_models[variable] - stochastic_pcs = None + return ssp_data, pr_first_year_mean - if include_noise: - # CRITICAL: Generate stochastic PCs ONCE for all aggregations - # This ensures all spatial scales share the same underlying variability - if verbose: # pragma: no cover - print( - f" → Generating {n_realizations} stochastic PC realizations..." - ) + def _generate_timeseries( + self, + variable, + scenario, + start_year, + end_year, + n_realizations, + aggregations, + gen_inputs=None, + custom_regions=None, + include_noise=True, + temp_scaling_ts=None, + verbose=True, + ): + """ + Generate time series outputs with spatial aggregations. - stochastic_pcs = noise_model.generate_stochastic_pcs( - monthly_warming, - n_realizations=n_realizations, - random_seed=None, # Can expose this as parameter if needed + Parameters + ---------- + variable : str + Climate variable to generate + scenario : str + Emission scenario ('ssp245', 'ssp585', etc.) + start_year : int + Start year + end_year : int + End year (inclusive) + n_realizations : int + Number of ensemble members + aggregations : list of str + Spatial aggregations to compute: + - 'global': Global mean + - 'regional:CODE': AR6 region mean (e.g., 'regional:NEU') + - 'regional:custom:NAME': Custom region (requires custom_regions dict) + - 'point:LAT,LON': Single grid point (e.g., 'point:59.9,10.8') + custom_regions : dict, optional + Custom region definitions: {'name': {'lat': (min, max), 'lon': (min, max)}} + include_noise : bool + If True, add stochastic noise; if False, return forced response only + verbose : bool + Print progress messages + + Returns + ------- + dict + Dictionary mapping aggregation names to xarray DataArrays + with shape (n_realizations, n_months) + """ + # Build shared generation inputs if not provided by the caller. + if gen_inputs is None: + gen_inputs = self._prepare_generation( + variable, + scenario, + start_year, + end_year, + n_realizations, + include_noise=include_noise, + temp_scaling_ts=temp_scaling_ts, + verbose=verbose, ) - else: - if verbose: # pragma: no cover + + monthly_prediction = gen_inputs.pattern.monthly_prediction + monthly_warming = gen_inputs.pattern.monthly_warming + stochastic_pcs = gen_inputs.stochastic_pcs + noise_model = self.noise_models[variable] + + # Resolve transform and (only if needed) load CMIP6 reference data. + # tas has no transform, so its reference data is never loaded. + transform_config = self._get_transform_config(variable) + ssp_data = None + pr_first_year_mean = None + if transform_config and transform_config.transform_type: + ssp_data, pr_first_year_mean = self._load_transform_reference( + variable, start_year, end_year, verbose=verbose + ) + + if verbose: # pragma: no cover + if include_noise: + print(" → Using shared stochastic PC realizations") + else: print(" → Climatology only (no stochastic variability)") # Generate outputs for each aggregation results = {} - transform_info = self.transforms.get(variable, None) - - # Handle both dict (fitted) and VariableTransformConfig (not fitted) cases - if isinstance(transform_info, dict): - transform_config = transform_info.get("config") - else: - transform_config = transform_info # It's a VariableTransformConfig object for agg in aggregations: if verbose: # pragma: no cover @@ -1135,6 +1366,8 @@ def _generate_timeseries( # Pattern scaling outputs anomalies, but Gamma transform needs absolute values # We use first-year (2015) baseline instead of piControl to match CMIP6 starting point pr_baseline_agg = None + # CMIP6 reference aggregation, only needed/available when a transform exists + cmip6_agg = None if agg == "global": # Global mean @@ -1156,7 +1389,8 @@ def _generate_timeseries( else: # Climatology only: return pattern scaling with shape (1, time) raw_ensemble = pattern_agg[np.newaxis, :] - cmip6_agg = global_mean(ssp_data) + if ssp_data is not None: + cmip6_agg = global_mean(ssp_data) elif agg.startswith("regional:"): # Check if it's a custom region @@ -1180,7 +1414,8 @@ def _generate_timeseries( pattern_agg = regional_mean( monthly_prediction, region_mask=region_mask ).values - cmip6_agg = regional_mean(ssp_data, region_mask=region_mask) + if ssp_data is not None: + cmip6_agg = regional_mean(ssp_data, region_mask=region_mask) if variable == "pr": pr_baseline_agg = float( regional_mean( @@ -1226,7 +1461,8 @@ def _generate_timeseries( else: # Climatology only: return pattern scaling with shape (1, time) raw_ensemble = pattern_agg[np.newaxis, :] - cmip6_agg = regional_mean(ssp_data, region_code=region_code) + if ssp_data is not None: + cmip6_agg = regional_mean(ssp_data, region_code=region_code) elif agg.startswith("point:"): # Point extraction @@ -1254,7 +1490,8 @@ def _generate_timeseries( else: # Climatology only: return pattern scaling with shape (1, time) raw_ensemble = pattern_agg[np.newaxis, :] - cmip6_agg = extract_point(ssp_data, lat, lon) + if ssp_data is not None: + cmip6_agg = extract_point(ssp_data, lat, lon) else: raise ValueError(f"Unknown aggregation type: {agg}") @@ -1335,6 +1572,7 @@ def _generate_gridded( end_year, n_realizations, gridded_spec, + gen_inputs=None, include_noise=True, temp_scaling_ts=None, verbose=True, @@ -1356,41 +1594,62 @@ def _generate_gridded( Dictionary with keys 'annual', 'monthly', 'climatology' containing xarray DataArrays with gridded fields """ - # Get pattern scaling results (from cache or compute) - pattern_result = ( - self._get_or_compute_pattern_scaling( # pylint: disable=unused-variable + # Build shared generation inputs if not provided by the caller. The PCs + # are generated once over the full trajectory (spun-up) and sliced to the + # output window, then sliced again per output field below. + if gen_inputs is None: + gen_inputs = self._prepare_generation( variable, scenario, start_year, end_year, + n_realizations, + include_noise=include_noise, temp_scaling_ts=temp_scaling_ts, verbose=verbose, ) - ) - monthly_prediction = pattern_result[0] - monthly_warming = pattern_result[1] - # Get noise model + monthly_prediction = gen_inputs.pattern.monthly_prediction + monthly_warming = gen_inputs.pattern.monthly_warming + stochastic_pcs = gen_inputs.stochastic_pcs noise_model = self.noise_models[variable] - # Generate stochastic PCs (or skip if climatology only) - if include_noise: - if verbose: # pragma: no cover - print(f" → Generating {n_realizations} gridded realizations") - else: + if not include_noise: if verbose: # pragma: no cover print(" → Generating gridded climatology (no noise)") - n_realizations = 1 # Force to 1 for climatology + elif verbose: # pragma: no cover + print(" → Using shared stochastic PC realizations (gridded)") + + # Resolve transform and (only for transform variables, e.g. pr) load the + # CMIP6 reference field and fit the per-gridpoint target distribution once. + transform_config = self._get_transform_config(variable) + target_params = None + pr_baseline_field = None + if transform_config and transform_config.transform_type: + ssp_data, pr_baseline_field = self._load_transform_reference( + variable, start_year, end_year, verbose=verbose + ) + if verbose: # pragma: no cover + print( + f" → Fitting per-gridpoint {transform_config.transform_type} " + "target distribution..." + ) + target_params = transform_config.fit_3d_func( + ssp_data, transform_config.transform_type + ) # Extract requested time slices results = {} n_months = len(monthly_warming) - # Helper to convert year to month index + # Window-relative month index. monthly_prediction, monthly_warming and the + # sliced stochastic PCs all share the same origin (start_year), which is + # derived from base_year inside _get_or_compute_pattern_scaling, so all + # three stay aligned. def year_to_month_idx(year): return (year - start_year) * 12 - # Annual means + # Annual means (12-month average of each year) if "annual" in gridded_spec: if verbose: # pragma: no cover print( @@ -1401,38 +1660,19 @@ def year_to_month_idx(year): start_idx = year_to_month_idx(year) end_idx = start_idx + 12 if start_idx >= 0 and end_idx <= n_months: - # Generate realizations for this year - year_realizations = [] - for i in range(n_realizations): # pylint: disable=unused-variable - if include_noise: - # Generate full field with noise - realization = noise_model.generate_realization( - monthly_warming[start_idx:end_idx], - n_realizations=1, - noise_only=True, - add_base=monthly_prediction.isel( - month=slice(start_idx, end_idx) - ), - ) - else: - # Just use pattern scaling - realization = monthly_prediction.isel( - month=slice(start_idx, end_idx) - ) - - # Average over 12 months - annual_mean = realization.mean(dim="month") - year_realizations.append(annual_mean) - - # Stack realizations - if len(year_realizations) > 1: - annual_fields[year] = xr.concat( - year_realizations, dim="realization" - ) - else: - annual_fields[year] = year_realizations[0].expand_dims( - realization=[0] - ) + annual_fields[year] = self._generate_gridded_slice( + monthly_prediction, + monthly_warming, + noise_model, + stochastic_pcs, + start_idx, + end_idx, + include_noise, + reduce_time=True, + transform_config=transform_config, + target_params=target_params, + pr_baseline_field=pr_baseline_field, + ) else: if verbose: # pragma: no cover print( @@ -1440,7 +1680,7 @@ def year_to_month_idx(year): ) results["annual"] = annual_fields - # Monthly fields + # Monthly fields (all 12 months retained) if "monthly" in gridded_spec: if verbose: # pragma: no cover print( @@ -1451,34 +1691,19 @@ def year_to_month_idx(year): start_idx = year_to_month_idx(year) end_idx = start_idx + 12 if start_idx >= 0 and end_idx <= n_months: - # Generate realizations for this year - year_realizations = [] - for i in range(n_realizations): - if include_noise: - # Generate full field with noise - realization = noise_model.generate_realization( - monthly_warming[start_idx:end_idx], - n_realizations=1, - noise_only=True, - add_base=monthly_prediction.isel( - month=slice(start_idx, end_idx) - ), - ) - else: - # Just use pattern scaling - realization = monthly_prediction.isel( - month=slice(start_idx, end_idx) - ) - - year_realizations.append(realization) - - # Stack realizations (shape: realizations, month, lat, lon) - if len(year_realizations) > 1: - year_months = xr.concat(year_realizations, dim="realization") - else: - year_months = year_realizations[0].expand_dims(realization=[0]) - - monthly_fields[year] = year_months + monthly_fields[year] = self._generate_gridded_slice( + monthly_prediction, + monthly_warming, + noise_model, + stochastic_pcs, + start_idx, + end_idx, + include_noise, + reduce_time=False, + transform_config=transform_config, + target_params=target_params, + pr_baseline_field=pr_baseline_field, + ) else: if verbose: # pragma: no cover print( @@ -1499,38 +1724,21 @@ def year_to_month_idx(year): start_idx = year_to_month_idx(clim_start) end_idx = year_to_month_idx(clim_end + 1) # +1 to include end year if start_idx >= 0 and end_idx <= n_months: - # Generate realizations for this period - clim_realizations = [] - for i in range(n_realizations): - if include_noise: - # Generate full field with noise - realization = noise_model.generate_realization( - monthly_warming[start_idx:end_idx], - n_realizations=1, - noise_only=True, - add_base=monthly_prediction.isel( - month=slice(start_idx, end_idx) - ), - ) - else: - # Just use pattern scaling - realization = monthly_prediction.isel( - month=slice(start_idx, end_idx) - ) - - # Average over all months in period - clim_mean = realization.mean(dim="month") - clim_realizations.append(clim_mean) - - # Stack realizations - if len(clim_realizations) > 1: - climatology_fields[f"{clim_start}-{clim_end}"] = xr.concat( - clim_realizations, dim="realization" - ) - else: - climatology_fields[f"{clim_start}-{clim_end}"] = ( - clim_realizations[0].expand_dims(realization=[0]) + climatology_fields[f"{clim_start}-{clim_end}"] = ( + self._generate_gridded_slice( + monthly_prediction, + monthly_warming, + noise_model, + stochastic_pcs, + start_idx, + end_idx, + include_noise, + reduce_time=True, + transform_config=transform_config, + target_params=target_params, + pr_baseline_field=pr_baseline_field, ) + ) else: if verbose: # pragma: no cover print( @@ -1543,6 +1751,145 @@ def year_to_month_idx(year): return results + def _generate_gridded_slice( + self, + monthly_prediction, + monthly_warming, + noise_model, + stochastic_pcs, + start_idx, + end_idx, + include_noise, + reduce_time, + transform_config=None, + target_params=None, + pr_baseline_field=None, + ): + """ + Generate one gridded output slice (annual / monthly / climatology). + + Unifies the three previously-duplicated gridded loops. The only behavioural + differences between output types are the month range (``start_idx`` / + ``end_idx``, window-relative) and whether the time axis is averaged away + (``reduce_time``). + + Noise is taken from the shared spun-up PCs (sliced to this window) so that + gridded fields are consistent with the time series outputs and carry full + stationary variability. Any distribution transform (e.g. precipitation + Gamma) is applied to the MONTHLY field *before* time-averaging, since the + transform is a per-gridpoint quantile map over the sample axis. + + Parameters + ---------- + monthly_prediction : xr.DataArray + Window-sliced monthly pattern prediction (month, lat, lon). + monthly_warming : np.ndarray + Window-sliced global-mean monthly warming. + noise_model : object + Fitted noise model for this variable. + stochastic_pcs : np.ndarray or None + Window-sliced shared PCs (n_realizations, n_months, n_modes), or None + when ``include_noise`` is False. + start_idx, end_idx : int + Window-relative month indices bounding this slice. + include_noise : bool + Whether to add stochastic noise. + reduce_time : bool + If True, average over the month axis (annual / climatology); if False, + keep all months (monthly fields). + transform_config : VariableTransformConfig, optional + Distribution transform configuration (e.g. for ``pr``). + target_params : dict, optional + Pre-fitted per-gridpoint target distribution parameters. + pr_baseline_field : xr.DataArray, optional + Gridded first-year baseline (lat, lon) added to anomalies before the + transform to obtain absolute precipitation. + + Returns + ------- + xr.DataArray + Stacked realizations with a leading ``realization`` dimension. + """ + base_slice = monthly_prediction.isel(month=slice(start_idx, end_idx)) + + if include_noise: + pcs_slice = stochastic_pcs[:, start_idx:end_idx, :] + realizations = noise_model.generate_realization( + monthly_warming[start_idx:end_idx], + noise_only=True, + add_base=base_slice, + stochastic_pcs=pcs_slice, + ) + if not isinstance(realizations, list): + realizations = [realizations] + else: + realizations = [base_slice] + + ensemble = _stack_realizations(realizations) + + # Apply the distribution transform on the monthly field, before averaging. + if transform_config and transform_config.transform_type: + ensemble = self._apply_gridded_transform( + ensemble, transform_config, target_params, pr_baseline_field + ) + + if reduce_time: + ensemble = ensemble.mean(dim="month") + + return ensemble + + def _apply_gridded_transform( + self, ensemble, transform_config, target_params, pr_baseline_field + ): + """ + Apply a per-gridpoint distribution transform to a gridded ensemble. + + Mirrors the time series transform but uses the 3D (per-gridpoint) fitting + and application path. The input must still retain its month axis so that + each gridpoint has a sample distribution to map. + + Parameters + ---------- + ensemble : xr.DataArray + Generated ensemble (realization, month, lat, lon). + transform_config : VariableTransformConfig + Transform configuration providing ``fit_3d_func`` / ``apply_func``. + target_params : dict + Pre-fitted per-gridpoint target distribution parameters. + pr_baseline_field : xr.DataArray or None + Gridded first-year baseline added to convert anomalies to absolute + values before the transform (precipitation). + + Returns + ------- + xr.DataArray + Transformed ensemble with the same coords/dims as the input. + """ + data = ensemble + if pr_baseline_field is not None: + # The CMIP6 reference field carries a singleton "ens" dimension (added + # by the data getter via expand_dims). Reduce the baseline to its + # spatial (lat, lon) grid so it broadcasts cleanly over the ensemble's + # (realization, month, lat, lon) dims instead of appending a spurious + # trailing axis. + extra_dims = [d for d in pr_baseline_field.dims if d not in ("lat", "lon")] + if extra_dims: + pr_baseline_field = pr_baseline_field.isel( + {d: 0 for d in extra_dims}, drop=True + ) + # Broadcast (lat, lon) baseline over realization and month + data = data + pr_baseline_field + + # Fit Gaussian per gridpoint to the generated ensemble, then map to target. + gaussian_params = transform_config.fit_3d_func(data.values, "gaussian") + transformed = transform_config.apply_func( + data.values, + gaussian_params, + target_params, + target_dist=transform_config.transform_type, + ) + return xr.DataArray(transformed, coords=data.coords, dims=data.dims) + def _apply_impacts( self, var_output, variable, impact_configs, custom_regions=None, verbose=True ): @@ -1576,7 +1923,6 @@ def _apply_impacts( # Check if degree days are requested if "degree_days" in impact_configs: - dd_config = impact_configs["degree_days"] # Determine base temperature - use hdd_base if provided, otherwise cdd_base @@ -1662,6 +2008,255 @@ def _apply_impacts( return impacts + def _apply_crop_yields( + self, + scenario, + start_year, + end_year, + crop_config, + timeseries_keys=None, + custom_regions=None, + verbose=True, + ): + """Apply the GGCMI Phase 2 crop yield emulator to METEOR pattern outputs. + + Uses annual gridded T and P from the pattern scaling (the deterministic + forced response) to drive the polynomial emulator of Franke et al. (2020). + Annual noise averages to approximately zero so the forced response is the + appropriate input for annual-mean crop yield calculations. + + Parameters + ---------- + scenario : str or dict + Scenario passed to generate_ensemble_outputs. + start_year : int + First year of output. + end_year : int + Last year of output (inclusive). + crop_config : dict + Keys: + + ``crops`` : list of str + Crop names, e.g. ``['maize', 'spring_wheat']``. + ``crop_model`` : str, optional + GGCM model name (default ``'LPJmL'``). + ``variant`` : str, optional + ``'A0'`` (default) or ``'A1'`` (with adaptation). + ``N`` : float, optional + Uniform N fertilizer in kg N/ha/yr (default ``100``). + + timeseries_keys : list of str, optional + Aggregation keys matching the ``timeseries`` argument of + generate_ensemble_outputs. Defaults to ``['global']``. + custom_regions : dict, optional + Custom region bounding boxes for ``regional:custom:NAME`` keys. + verbose : bool + Print progress messages. + + Returns + ------- + dict + ``{crop_name: {agg_key: np.ndarray of shape (n_years,)}}`` + Yield in t dry matter / ha / yr. + """ + # pylint: disable=too-many-locals,too-many-branches,import-outside-toplevel + from .impacts.ggcm.baseline import load_agmerra_baseline + from .impacts.ggcm.coefficients import get_yields, load_coefficients + from .impacts.ggcm.downloader import GgcmDownloader + + # --- Validate requirements --- + if "tas" not in self.variables or "pr" not in self.variables: + raise ValueError( + "Crop yield impacts require both 'tas' and 'pr' in the emulator " + "variables list. Include both when creating MeteorInterface." + ) + + crops = crop_config.get("crops", ["maize"]) + if isinstance(crops, str): + crops = [crops] + crop_model = crop_config.get("crop_model", "LPJmL") + variant = crop_config.get("variant", "A0") + n_fert = float(crop_config.get("N", 100)) + agg_keys = list(timeseries_keys) if timeseries_keys else ["global"] + + # --- Ensure coefficient files are present (downloads if missing) --- + ggcm_dir = self.cache_handler.get_subdir("ggcm") + downloader = GgcmDownloader(ggcm_dir) + downloader.ensure_files(crops, crop_model, variant) + + # --- AgMERRA baseline bundled with the package --- + T_agmerra, W_agmerra = ( # pylint: disable=invalid-name + load_agmerra_baseline() + ) # (360, 720) + + # GGCM 0.5-degree target grid + lat_ggcm = np.arange(89.75, -90.0, -0.5) # 360 values + lon_ggcm = np.arange(-179.75, 180.0, 0.5) # 720 values + + # --- Forcing data (emissions + concentrations) --- + scenario_info = parse_scenario_input(scenario) + if scenario_info["type"] == "ssp": + em_data, conc_data = load_emissions_concentrations_from_name( + scenario_info["name"] + ) + else: + em_data, conc_data = load_emissions_concentrations( + scenario_info["emissions"], scenario_info["concentrations"] + ) + + # CO2 per year (ppm) from concentration data + co2_series = conc_data["CO2"] + + # --- Annual gridded pattern scaling predictions --- + if verbose: # pragma: no cover + print(" → Computing annual pattern scaling for crop inputs...") + annual_tas = self.pattern_models["tas"].predict_from_combined_experiment( + em_data, conc_data, ["tas"] + )["tas"] + annual_pr = self.pattern_models["pr"].predict_from_combined_experiment( + em_data, conc_data, ["pr"] + )["pr"] + + # 'time' dimension contains datetime64 values; filter to requested year range + time_mask = (annual_tas.time.dt.year >= start_year) & ( + annual_tas.time.dt.year <= end_year + ) + annual_tas = annual_tas.sel(time=time_mask) + annual_pr = annual_pr.sel(time=time_mask) + years = [int(y) for y in annual_tas.time.dt.year.values] + + # --- piControl climatological gridded mean --- + # Used to reconstruct absolute T and P from pattern scaling anomalies. + if verbose: # pragma: no cover + print( + " → Loading piControl baseline for absolute T/P reconstruction..." + ) + picontrol = self.data_getter.make_meteor_training_data( + "piControl", self.model, monthly=True + ) + # The data getter adds an 'ens' dim AND a 'month' dim; we need to + # average over ALL non-spatial dimensions to get a pure (lat, lon) field. + spatial_dims = {"lat", "lon", "latitude", "longitude"} + non_spatial_dims_tas = [ + d for d in picontrol["tas"].dims if d not in spatial_dims + ] + non_spatial_dims_pr = [d for d in picontrol["pr"].dims if d not in spatial_dims] + picontrol_tas_mean = picontrol["tas"].mean(non_spatial_dims_tas) # (lat, lon) K + picontrol_pr_mean = picontrol["pr"].mean( + non_spatial_dims_pr + ) # (lat, lon) kg m-2 s-1 + + # --- Detect lat/lon coordinate names in pattern scaling output --- + def _find_coord(da, candidates): + return next((c for c in da.coords if c.lower() in candidates), None) + + lat_n = _find_coord(annual_tas, ("lat", "latitude")) + lon_n = _find_coord(annual_tas, ("lon", "longitude")) + if lat_n is None or lon_n is None: + raise ValueError( + "Cannot find lat/lon coordinates in pattern scaling output. " + f"Available coords: {list(annual_tas.coords)}" + ) + + lat_n_pc = _find_coord(picontrol_tas_mean, ("lat", "latitude")) + lon_n_pc = _find_coord(picontrol_tas_mean, ("lon", "longitude")) + + # --- Regrid piControl means to 0.5-degree grid (done once) --- + picontrol_tas_ggcm = picontrol_tas_mean.interp( + {lat_n_pc: lat_ggcm, lon_n_pc: lon_ggcm}, method="linear" + ).values # (360, 720) K + picontrol_pr_ggcm = picontrol_pr_mean.interp( + {lat_n_pc: lat_ggcm, lon_n_pc: lon_ggcm}, method="linear" + ).values # (360, 720) kg m-2 s-1 + + # --- Load K coefficient tensors --- + k_by_crop = { + crop: load_coefficients( + str(downloader.get_filepath(crop_model, crop, variant)) + ) + for crop in crops + } + + # --- Initialise output containers --- + crop_results = {crop: {key: [] for key in agg_keys} for crop in crops} + + # --- Year loop --- + for i, year in enumerate(years): + # Pattern scaling annual anomalies on native CMIP6 grid + tas_anom = annual_tas.isel(time=i) # (lat, lon) K anomaly + pr_anom = annual_pr.isel(time=i) # (lat, lon) kg m-2 s-1 anomaly + + # Regrid anomalies to 0.5-degree grid + tas_anom_ggcm = tas_anom.interp( + {lat_n: lat_ggcm, lon_n: lon_ggcm}, method="linear" + ).values + pr_anom_ggcm = pr_anom.interp( + {lat_n: lat_ggcm, lon_n: lon_ggcm}, method="linear" + ).values + + # Absolute values + tas_celsius = (tas_anom_ggcm + picontrol_tas_ggcm) - 273.15 # °C + pr_mmyr = (pr_anom_ggcm + picontrol_pr_ggcm) * 86400.0 * 365.25 # mm/yr + + # Fill NaN (coastal/polar interpolation gaps) with climatological reference + tas_celsius = np.where(np.isfinite(tas_celsius), tas_celsius, T_agmerra) + pr_mmyr = np.where(np.isfinite(pr_mmyr), pr_mmyr, W_agmerra) + + # CO2 for this year + ca = float( + co2_series.loc[year] + if year in co2_series.index + else co2_series.iloc[-1] + ) + + for crop in crops: + yield_arr, _, _ = get_yields( + k_by_crop[crop], + ca, + tas_celsius, + pr_mmyr, + n_fert, + T_agmerra, + W_agmerra, + ) + # Wrap as xr.DataArray for METEOR's spatial aggregation utilities + yield_da = xr.DataArray( + yield_arr, + coords={"lat": lat_ggcm, "lon": lon_ggcm}, + dims=["lat", "lon"], + ) + + for key in agg_keys: + if key == "global": + val = float(global_mean(yield_da).values) + elif key.startswith("regional:custom:"): + region_name = key.split(":")[2] + if custom_regions and region_name in custom_regions: + bbox = custom_regions[region_name] + mask = create_region_mask(yield_da, bbox=bbox) + val = float( + yield_da.where(mask).mean(["lat", "lon"]).values + ) + else: + raise ValueError( + f"Custom region '{region_name}' not found in custom_regions" + ) + elif key.startswith("regional:"): + region = key.split(":")[1] + val = float(regional_mean(yield_da, region).values) + elif key.startswith("point:"): + lat_p, lon_p = map(float, key.split(":")[1].split(",")) + val = float(extract_point(yield_da, lat_p, lon_p).values) + else: + raise ValueError(f"Unknown aggregation type: {key}") + crop_results[crop][key].append(val) + + # Convert lists → numpy arrays + return { + crop: {key: np.array(vals) for key, vals in agg.items()} + for crop, agg in crop_results.items() + } + def __repr__(self): """Return string representation of MeteorInterface.""" status = "trained" if all(self._is_trained.values()) else "not trained" diff --git a/src/meteor/noise_generator.py b/src/meteor/noise_generator.py index 483b80b8..3c7c849d 100644 --- a/src/meteor/noise_generator.py +++ b/src/meteor/noise_generator.py @@ -443,6 +443,7 @@ def generate_realization( random_seed=None, noise_only=False, add_base=None, + stochastic_pcs=None, ): """ Generate stochastic climate realizations. @@ -464,6 +465,12 @@ def generate_realization( Base climatology to add to each realization. If provided, the addition is done efficiently in NumPy before XArray conversion, avoiding expensive XArray operations. Must have compatible shape with the output. + stochastic_pcs : np.ndarray, optional + Pre-generated stochastic PCs from :meth:`generate_stochastic_pcs`. If + provided, these PCs are used instead of generating fresh ones, enabling + self-consistent ensemble generation shared with regional/global means. + Shape ``(n_time, n_modes)`` or ``(n_realizations, n_time, n_modes)``. + When provided, ``n_realizations`` is inferred from the array. Returns ------- @@ -474,7 +481,7 @@ def generate_realization( if not self.fitted: raise ValueError("Model must be fitted before generating realizations") - if random_seed is not None: + if random_seed is not None and stochastic_pcs is None: np.random.seed(random_seed) # Create time coordinate (shared across all realizations) @@ -526,11 +533,25 @@ def generate_realization( base_clim_np = base_values.reshape(n_time, n_lat, n_lon) + # Use pre-generated PCs if provided (self-consistent ensembles), else + # generate a fresh stochastic component per realization. + if stochastic_pcs is not None: + if stochastic_pcs.ndim == 2: + pcs_to_use = [stochastic_pcs] + else: + pcs_to_use = list(stochastic_pcs) + n_realizations = len(pcs_to_use) + else: + pcs_to_use = None + # Generate realizations (only stochastic component varies) realizations = [] - for _ in range(n_realizations): + for i in range(n_realizations): # Generate stochastic component (this is the only unique part per realization) - synthetic_pcs = self._generate_stochastic_pcs(X_exog, n_time) + if pcs_to_use is not None: + synthetic_pcs = pcs_to_use[i] + else: + synthetic_pcs = self._generate_stochastic_pcs(X_exog, n_time) # Reconstruct anomalies (NumPy) reconstructed_anomalies = synthetic_pcs @ self.pca.components_ diff --git a/tests/unit/impacts/test_ggcm_baseline.py b/tests/unit/impacts/test_ggcm_baseline.py new file mode 100644 index 00000000..ba7b152c --- /dev/null +++ b/tests/unit/impacts/test_ggcm_baseline.py @@ -0,0 +1,98 @@ +""" +Unit tests for the AgMERRA baseline loader. +============================================ + +The AgMERRA 1980-2010 climatological means are bundled with METEOR and +loaded by ``meteor.impacts.ggcm.baseline.load_agmerra_baseline``. + +These tests verify: +- Arrays have the expected 0.5-degree global grid shape (360 × 720). +- Temperature values are physically plausible (global land range ≈ −60 … 45 °C). +- Precipitation values are all ≥ 1.0 mm/yr (floor applied to avoid division + by zero in the W-ratio calculation of the GGCMI polynomial). +- Both arrays are of dtype float64. +""" + +import numpy as np +import pytest + +from meteor.impacts.ggcm.baseline import load_agmerra_baseline + + +@pytest.fixture(scope="module") +def agmerra(): + """Load baseline once per test module.""" + return load_agmerra_baseline() + + +# Testing agmerra array shapes are correct + + +def test_temperature_shape(agmerra): + T_agmerra, _ = agmerra + assert T_agmerra.shape == ( + 360, + 720, + ), "Expected global 0.5-degree grid (360 lat × 720 lon)" + + +def test_precipitation_shape(agmerra): + _, W_agmerra = agmerra + assert W_agmerra.shape == (360, 720) + + +# Testing agmerra data types are correct +def test_temperature_dtype(agmerra): + T_agmerra, _ = agmerra + assert T_agmerra.dtype == np.float64 + + +def test_precipitation_dtype(agmerra): + _, W_agmerra = agmerra + assert W_agmerra.dtype == np.float64 + + +def test_temperature_is_ndarray(agmerra): + T_agmerra, _ = agmerra + assert isinstance(T_agmerra, np.ndarray) + # Must NOT be a masked array – ocean cells were already filled + assert not isinstance(T_agmerra, np.ma.MaskedArray) + + +def test_precipitation_is_ndarray(agmerra): + _, W_agmerra = agmerra + assert isinstance(W_agmerra, np.ndarray) + assert not isinstance(W_agmerra, np.ma.MaskedArray) + + +# Testing agmerra physical plausibility and spatial variation +def test_temperature_range(agmerra): + """Global mean temperatures should lie in a plausible range.""" + T_agmerra, _ = agmerra + assert T_agmerra.min() >= -80.0, "Some cells below −80 °C is implausible" + assert T_agmerra.max() <= 60.0, "Some cells above 60 °C is implausible" + + +def test_precipitation_floor(agmerra): + """All W_agmerra values must be >= 1.0 mm/yr (floor applied in loader).""" + _, W_agmerra = agmerra + assert np.all(W_agmerra >= 1.0), ( + "Precipitation floor of 1 mm/yr not applied; " + "division-by-zero risk in W-ratio computation" + ) + + +def test_precipitation_no_negative(agmerra): + _, W_agmerra = agmerra + assert np.all(W_agmerra >= 0.0) + + +def test_temperature_has_spatial_variation(agmerra): + """Non-constant: pole-to-equator temperature gradient should exist.""" + T_agmerra, _ = agmerra + assert T_agmerra.std() > 1.0, "Suspiciously uniform temperature grid" + + +def test_precipitation_has_spatial_variation(agmerra): + _, W_agmerra = agmerra + assert W_agmerra.std() > 1.0 diff --git a/tests/unit/impacts/test_ggcm_catalog.py b/tests/unit/impacts/test_ggcm_catalog.py new file mode 100644 index 00000000..f5ddcd29 --- /dev/null +++ b/tests/unit/impacts/test_ggcm_catalog.py @@ -0,0 +1,332 @@ +""" +Unit tests for the GGCMI Phase 2 data catalog and downloader. +============================================================== + +Verifies catalog metadata and the downloader's validation logic without +making any network requests. + +Catalog covers 9 crop models × 5 crops × 2 adaptation variants (A0 / A1) +as described in Table 1 of Franke et al. (2020), GMD 13, 3995-4018. +""" + +from unittest.mock import MagicMock, patch + +import pytest + +from meteor.impacts.ggcm import data_catalog as catalog +from meteor.impacts.ggcm.downloader import GgcmDownloader + +# --------------------------------------------------------------------------- +# Catalog: known models and crops +# --------------------------------------------------------------------------- + + +def test_all_nine_models_present(): + """Nine crop models participated in GGCMI Phase 2 (Table 1).""" + expected = { + "CARAIB", + "EPIC-TAMU", + "GEPIC", + "JULES", + "LPJ-GUESS", + "LPJmL", + "pDSSAT", + "PEPIC", + "PROMET", + } + assert expected == set(catalog.CROP_MODELS) + + +def test_five_crops_present(): + expected = {"maize", "rice", "soy", "spring_wheat", "winter_wheat"} + assert expected == set(catalog.CROPS) + + +def test_LPJmL_supports_all_crops_A0_A1(): + """LPJmL provides both A0 and A1 for all five crops.""" + for crop in catalog.CROPS: + assert catalog.is_available("LPJmL", crop, "A0") + assert catalog.is_available("LPJmL", crop, "A1") + + +def test_JULES_A0_only(): + """JULES participated only in A0 scenarios.""" + for crop in ["maize", "rice", "soy", "spring_wheat"]: + assert catalog.is_available("JULES", crop, "A0") + assert not catalog.is_available("JULES", crop, "A1") + + +def test_JULES_no_winter_wheat(): + """JULES did not provide winter wheat data.""" + assert not catalog.is_available("JULES", "winter_wheat", "A0") + + +def test_LPJ_GUESS_no_soy(): + """LPJ-GUESS did not simulate soy.""" + assert not catalog.is_available("LPJ-GUESS", "soy", "A0") + + +# --------------------------------------------------------------------------- +# Catalog: is_available() +# --------------------------------------------------------------------------- + + +def test_returns_false_for_unknown_model(): + assert not catalog.is_available("UNKNOWN_MODEL", "maize", "A0") + + +def test_returns_false_for_unknown_crop(): + assert not catalog.is_available("LPJmL", "quinoa", "A0") + + +def test_returns_false_for_unknown_variant(): + assert not catalog.is_available("LPJmL", "maize", "A2") + + +def test_returns_true_for_known_combination(): + assert catalog.is_available("pDSSAT", "spring_wheat", "A1") + + +# --------------------------------------------------------------------------- +# Catalog: get_filename() +# --------------------------------------------------------------------------- + + +def test_filename_pattern(): + name = catalog.get_filename("LPJmL", "maize", "A0") + assert name == "LPJmL_maize_ggcmi_phase2_emulator_A0.nc4" + + +def test_filename_variant_A1(): + name = catalog.get_filename("pDSSAT", "rice", "A1") + assert name == "pDSSAT_rice_ggcmi_phase2_emulator_A1.nc4" + + +def test_filename_contains_model_crop_variant(): + name = catalog.get_filename("GEPIC", "winter_wheat", "A0") + assert "GEPIC" in name + assert "winter_wheat" in name + assert "A0" in name + assert name.endswith(".nc4") + + +# --------------------------------------------------------------------------- +# Catalog: get_download_url() +# --------------------------------------------------------------------------- + + +def test_url_contains_record_id(): + url = catalog.get_download_url("LPJmL", "maize", "A0") + assert catalog.ZENODO_RECORD_ID in url + + +def test_url_ends_with_filename(): + url = catalog.get_download_url("LPJmL", "maize", "A0") + assert url.endswith(catalog.get_filename("LPJmL", "maize", "A0")) + + +def test_url_raises_for_unavailable(): + with pytest.raises(ValueError, match="Not available"): + catalog.get_download_url("JULES", "maize", "A1") + + +def test_url_raises_for_unknown_model(): + with pytest.raises(ValueError): + catalog.get_download_url("FAKE_MODEL", "maize", "A0") + + +# --------------------------------------------------------------------------- +# Catalog: get_available_crops() and get_available_models() +# --------------------------------------------------------------------------- + + +def test_get_available_crops_no_filter(): + crops = catalog.get_available_crops() + assert set(crops) == set(catalog.CROPS) + + +def test_get_available_crops_filtered_by_model(): + crops = catalog.get_available_crops("JULES") + # JULES has no winter wheat + assert "winter_wheat" not in crops + + +def test_get_available_models_no_filter(): + models = catalog.get_available_models() + assert set(models) == set(catalog.CROP_MODELS) + + +def test_get_available_models_filtered_by_crop(): + # LPJ-GUESS doesn't simulate soy; check it's excluded + soy_models = catalog.get_available_models("soy") + assert "LPJ-GUESS" not in soy_models + assert "LPJmL" in soy_models + + +def test_get_available_variants_known(): + variants = catalog.get_available_variants("LPJmL", "maize") + assert set(variants) == {"A0", "A1"} + + +def test_get_available_variants_A0_only(): + variants = catalog.get_available_variants("JULES", "maize") + assert variants == ["A0"] + + +def test_get_available_variants_unknown_model(): + assert catalog.get_available_variants("UNKNOWN", "maize") == [] + + +def test_get_available_variants_unknown_crop(): + assert catalog.get_available_variants("LPJmL", "quinoa") == [] + + +# --------------------------------------------------------------------------- +# Downloader: validation without network calls +# --------------------------------------------------------------------------- + + +def test_get_filepath_returns_correct_path(tmp_path): + dl = GgcmDownloader(str(tmp_path)) + fp = dl.get_filepath("LPJmL", "maize", "A0") + assert fp == tmp_path / "LPJmL_maize_ggcmi_phase2_emulator_A0.nc4" + + +def test_ensure_files_raises_for_unavailable_crop(tmp_path): + dl = GgcmDownloader(str(tmp_path)) + with pytest.raises(ValueError, match="not available"): + dl.ensure_files(["quinoa"], "LPJmL", "A0") + + +def test_ensure_files_raises_for_unavailable_model(tmp_path): + dl = GgcmDownloader(str(tmp_path)) + with pytest.raises(ValueError): + dl.ensure_files(["maize"], "FAKE_MODEL", "A0") + + +def test_ensure_files_raises_for_JULES_A1(tmp_path): + dl = GgcmDownloader(str(tmp_path)) + with pytest.raises(ValueError): + dl.ensure_files(["maize"], "JULES", "A1") + + +def test_ensure_files_returns_early_if_all_present(tmp_path): + """No download attempted when all files already exist.""" + dl = GgcmDownloader(str(tmp_path)) + # Create a dummy file so the downloader thinks it's already cached + dummy = tmp_path / catalog.get_filename("LPJmL", "maize", "A0") + dummy.touch() + # Should return without error and without trying to import requests + dl.ensure_files(["maize"], "LPJmL", "A0") # no exception + + +def test_cache_dir_created_on_init(tmp_path): + subdir = tmp_path / "ggcm" / "nested" + GgcmDownloader(str(subdir)) + assert subdir.is_dir() + + +def test_ensure_files_raises_import_error_when_requests_missing(tmp_path): + """If requests is not installed, ensure_files raises ImportError.""" + dl = GgcmDownloader(str(tmp_path)) # maize file does NOT exist + with patch.dict("sys.modules", {"requests": None, "tqdm": None}): + with pytest.raises(ImportError, match="requests"): + dl.ensure_files(["maize"], "LPJmL", "A0") + + +def test_ensure_files_downloads_missing_files(tmp_path): + """When files are missing, ensure_files calls _download_file for each.""" + dl = GgcmDownloader(str(tmp_path)) + mock_requests = MagicMock() + mock_tqdm_cls = MagicMock() + with ( + patch( + "meteor.impacts.ggcm.downloader.GgcmDownloader._download_file" + ) as mock_dl, + patch( + "builtins.__import__", + side_effect=_make_importer(mock_requests, mock_tqdm_cls), + ), + ): + dl.ensure_files(["maize", "rice"], "LPJmL", "A0") + assert mock_dl.call_count == 2 + + +def test_download_file_streams_chunks(tmp_path): + """_download_file writes response chunks to disk.""" + dest = tmp_path / "test.nc4" + chunks = [b"chunk1", b"chunk2", b"chunk3"] + + mock_resp = MagicMock() + mock_resp.headers = {"content-length": str(sum(len(c) for c in chunks))} + mock_resp.iter_content.return_value = iter(chunks) + + mock_requests = MagicMock() + mock_requests.get.return_value = mock_resp + + mock_pbar = MagicMock() + mock_pbar.__enter__ = MagicMock(return_value=mock_pbar) + mock_pbar.__exit__ = MagicMock(return_value=False) + mock_tqdm_cls = MagicMock(return_value=mock_pbar) + + dl = GgcmDownloader(str(tmp_path)) + dl._download_file("http://example.com/test.nc4", dest, mock_requests, mock_tqdm_cls) + + assert dest.exists() + assert dest.read_bytes() == b"".join(chunks) + mock_requests.get.assert_called_once_with( + "http://example.com/test.nc4", headers={}, stream=True, timeout=60 + ) + + +def test_download_file_resumes_partial(tmp_path): + """_download_file sends a Range header when a partial file exists.""" + dest = tmp_path / "partial.nc4" + existing = b"already_here" + dest.write_bytes(existing) + + new_chunk = b"_rest" + mock_resp = MagicMock() + mock_resp.headers = {"content-length": str(len(new_chunk))} + mock_resp.iter_content.return_value = iter([new_chunk]) + + mock_requests = MagicMock() + mock_requests.get.return_value = mock_resp + + mock_pbar = MagicMock() + mock_pbar.__enter__ = MagicMock(return_value=mock_pbar) + mock_pbar.__exit__ = MagicMock(return_value=False) + mock_tqdm_cls = MagicMock(return_value=mock_pbar) + + dl = GgcmDownloader(str(tmp_path)) + dl._download_file( + "http://example.com/partial.nc4", dest, mock_requests, mock_tqdm_cls + ) + + assert dest.read_bytes() == existing + new_chunk + _, kwargs = mock_requests.get.call_args + assert kwargs["headers"] == {"Range": f"bytes={len(existing)}-"} + + +# --------------------------------------------------------------------------- +# Helper for patching builtins.__import__ selectively +# --------------------------------------------------------------------------- + +_real_import = ( + __builtins__.__import__ if hasattr(__builtins__, "__import__") else __import__ +) + + +def _make_importer(mock_requests, mock_tqdm_cls): + """Return an __import__ side-effect that returns mocks for requests/tqdm.""" + + def _import(name, *args, **kwargs): + if name == "requests": + return mock_requests + if name == "tqdm": + mod = MagicMock() + mod.tqdm = mock_tqdm_cls + return mod + return _real_import(name, *args, **kwargs) + + return _import diff --git a/tests/unit/impacts/test_ggcm_polynomial.py b/tests/unit/impacts/test_ggcm_polynomial.py new file mode 100644 index 00000000..58bc2de1 --- /dev/null +++ b/tests/unit/impacts/test_ggcm_polynomial.py @@ -0,0 +1,613 @@ +""" +Unit tests for the GGCMI Phase 2 polynomial evaluator. +======================================================= + +These tests verify that ``get_yields`` in ``meteor.impacts.ggcm.coefficients`` +faithfully implements Equation (1) from Franke et al. (2020) [GMD 13, 3995-4018, +https://doi.org/10.5194/gmd-13-3995-2020]: + + Y = sum_{i<=j<=k} K_{ijk} * C^i * T^j * W^k * N^l + +where the polynomial is third-order in C, T, W, N with the N³ term omitted (it +cannot be fitted from three N levels). + +Key invariants verified: +- Each of the 34 polynomial terms is evaluated correctly in isolation. +- The input variables are the *transformed* quantities: C (raw, ppm), + T (temperature anomaly from AgMERRA baseline, °C), + W (precipitation ratio to AgMERRA baseline, dimensionless), N (raw, kg/ha/yr). +- Inputs are clamped to the GGCMI Phase 2 valid ranges before evaluation. +- Out-of-bounds offsets (T_oob, W_oob) correctly reflect the un-clamped excess. +- Yield is clipped to zero from below. +- N³ is NOT included in the polynomial. +""" + +from unittest.mock import MagicMock, patch + +import numpy as np + +from meteor.impacts.ggcm.coefficients import get_yields, load_coefficients + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + +GRID_SHAPE = (3, 4) # small grid for speed; 360×720 arithmetic is unchanged + +# Realistic AgMERRA-style baseline grids +T_BASE = np.full(GRID_SHAPE, 15.0) # 15 °C everywhere +W_BASE = np.full(GRID_SHAPE, 600.0) # 600 mm/yr everywhere + + +def _zero_K(): + """Return a K tensor of all zeros in shape (35, *GRID_SHAPE).""" + return np.zeros((35,) + GRID_SHAPE) + + +def _standard_inputs(): + """In-range inputs that produce zero anomalies: T=0, W=1.""" + Ta = T_BASE.copy() # Ta == T_agmerra → anomaly = 0 + Wa = W_BASE.copy() # Wa == W_agmerra → ratio = 1 + Ca = 400.0 + Na = 100.0 + return Ca, Ta, Wa, Na + + +# --------------------------------------------------------------------------- +# Output shape and dtype +# --------------------------------------------------------------------------- + + +def test_yield_shape(): + K = _zero_K() + Ca, Ta, Wa, Na = _standard_inputs() + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + assert yld.shape == GRID_SHAPE + + +def test_w_oob_shape(): + K = _zero_K() + Ca, Ta, Wa, Na = _standard_inputs() + _, w_oob, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + assert w_oob.shape == GRID_SHAPE + + +def test_t_oob_shape(): + K = _zero_K() + Ca, Ta, Wa, Na = _standard_inputs() + _, _, t_oob = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + assert t_oob.shape == GRID_SHAPE + + +# --------------------------------------------------------------------------- +# Non-negativity of yield +# --------------------------------------------------------------------------- + + +def test_yield_clipped_to_zero(): + K = _zero_K() + K[0] = -999.0 # large negative intercept → raw yield < 0 + Ca, Ta, Wa, Na = _standard_inputs() + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + assert np.all(yld == 0.0) + + +def test_positive_yield_unchanged(): + K = _zero_K() + K[0] = 3.5 # positive intercept → yield = 3.5 + Ca, Ta, Wa, Na = _standard_inputs() + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 3.5) + + +# --------------------------------------------------------------------------- +# Polynomial term isolation tests +# Each test sets exactly one coefficient and verifies the contribution. +# Standard conditions: Ca=400, Ta=T_BASE, Wa=W_BASE, Na=100 +# → C=400, T=0, W=1, N=100 (at AgMERRA baseline) +# Varying Ta or Wa shifts T or W away from baseline. +# --------------------------------------------------------------------------- + + +def test_K0_intercept(): + """K[0]: constant term.""" + K = _zero_K() + K[0] = 7.0 + Ca, Ta, Wa, Na = _standard_inputs() + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 7.0) + + +def test_K1_linear_C(): + """K[1]: linear C term. With Ca=400, yield = 400.""" + K = _zero_K() + K[1] = 1.0 + Ca, Ta, Wa, Na = _standard_inputs() + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 400.0) + + +def test_K2_linear_T(): + """K[2]: linear T term. T is the *anomaly* from T_agmerra.""" + K = _zero_K() + K[2] = 1.0 + Ca = 400.0 + Ta = T_BASE + 2.0 # anomaly = 2 (within [T-1, T+6]) + Wa = W_BASE.copy() + Na = 100.0 + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 2.0) + + +def test_K2_linear_T_at_baseline_zero(): + """K[2]: when Ta equals T_agmerra, T anomaly = 0 → no contribution.""" + K = _zero_K() + K[2] = 99.0 + Ca, Ta, Wa, Na = _standard_inputs() # Ta == T_BASE + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 0.0) + + +def test_K3_linear_W(): + """K[3]: linear W term. W is the *ratio* Wa/W_agmerra.""" + K = _zero_K() + K[3] = 1.0 + Ca = 400.0 + Ta = T_BASE.copy() + Wa = W_BASE.copy() # ratio = 1 + Na = 100.0 + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 1.0) + + +def test_K3_linear_W_ratio(): + """K[3]: W = 1.2×W_base → ratio = 1.2.""" + K = _zero_K() + K[3] = 1.0 + Ca = 400.0 + Ta = T_BASE.copy() + Wa = 1.2 * W_BASE # within 1.3×W_base limit + Na = 100.0 + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 1.2, rtol=1e-10) + + +def test_K4_linear_N(): + """K[4]: linear N term. Na=150 → N=150.""" + K = _zero_K() + K[4] = 1.0 + Ca, Ta, Wa, _ = _standard_inputs() + Na = 150.0 + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 150.0) + + +def test_K5_C_squared(): + """K[5]: C² term. C=400 → contribution = 160 000.""" + K = _zero_K() + K[5] = 1.0 + Ca, Ta, Wa, Na = _standard_inputs() + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 400.0**2) + + +def test_K9_T_squared(): + """K[9]: T² term. T=3 → contribution = 9.""" + K = _zero_K() + K[9] = 1.0 + Ca = 400.0 + Ta = T_BASE + 3.0 + Wa = W_BASE.copy() + Na = 100.0 + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 9.0) + + +def test_K10_TW_interaction(): + """K[10]: T·W cross term. T=2, W=1.1 → 2.2.""" + K = _zero_K() + K[10] = 1.0 + Ca = 400.0 + Ta = T_BASE + 2.0 + Wa = 1.1 * W_BASE + Na = 100.0 + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 2.0 * 1.1, rtol=1e-10) + + +def test_K12_W_squared(): + """K[12]: W² term. W=1 (baseline) → 1. W=1.2 → 1.44.""" + K = _zero_K() + K[12] = 1.0 + Ca = 400.0 + Ta = T_BASE.copy() + Wa = 1.2 * W_BASE + Na = 100.0 + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 1.2**2, rtol=1e-10) + + +def test_K14_N_squared(): + """K[14]: N² term. N=50 → 2500.""" + K = _zero_K() + K[14] = 1.0 + Ca = 400.0 + Ta = T_BASE.copy() + Wa = W_BASE.copy() + Na = 50.0 + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 50.0**2) + + +def test_K15_C_cubed(): + """K[15]: C³ term. C=400 → 64 000 000.""" + K = _zero_K() + K[15] = 1.0 + Ca, Ta, Wa, Na = _standard_inputs() + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 400.0**3) + + +def test_K25_T_cubed(): + """K[25]: T³ term. T=2 → 8.""" + K = _zero_K() + K[25] = 1.0 + Ca = 400.0 + Ta = T_BASE + 2.0 + Wa = W_BASE.copy() + Na = 100.0 + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 8.0) + + +def test_K31_W_cubed(): + """K[31]: W³ term. W=1.1 → 1.331.""" + K = _zero_K() + K[31] = 1.0 + Ca = 400.0 + Ta = T_BASE.copy() + Wa = 1.1 * W_BASE + Na = 100.0 + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 1.1**3, rtol=1e-10) + + +def test_K33_WN_squared(): + """K[33]: W·N² term. W=1.2, N=50 → 1.2 × 2500 = 3000.""" + K = _zero_K() + K[33] = 1.0 + Ca = 400.0 + Ta = T_BASE.copy() + Wa = 1.2 * W_BASE + Na = 50.0 + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 1.2 * 50.0**2, rtol=1e-10) + + +# --------------------------------------------------------------------------- +# N³ absence (paper: term omitted because only 3 N levels in training data) +# --------------------------------------------------------------------------- + + +def test_K34_N3_not_included(): + K = _zero_K() + K[0] = 5.0 # baseline yield + K[34] = 1e6 # enormous N³ coefficient that WOULD dominate if included + Ca = 400.0 + Ta = T_BASE.copy() + Wa = W_BASE.copy() + Na = 200.0 + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + # Yield should be just K[0]=5, unaffected by K[34] + np.testing.assert_allclose(yld, 5.0) + + +# --------------------------------------------------------------------------- +# Multi-term superposition (linearity check) +# --------------------------------------------------------------------------- + + +def test_intercept_plus_T_term(): + """K[0]=1, K[2]=2: at T=3 → yield = 1 + 2*3 = 7.""" + K = _zero_K() + K[0] = 1.0 + K[2] = 2.0 + Ca = 400.0 + Ta = T_BASE + 3.0 + Wa = W_BASE.copy() + Na = 100.0 + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 7.0) + + +def test_intercept_T_T2_T3_combination(): + """K[0]=1, K[2]=2, K[9]=0.5, K[25]=0.1 at T=2 → 1+4+2+0.8 = 7.8.""" + K = _zero_K() + K[0] = 1.0 + K[2] = 2.0 + K[9] = 0.5 + K[25] = 0.1 + Ca = 400.0 + Ta = T_BASE + 2.0 + Wa = W_BASE.copy() + Na = 100.0 + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + expected = 1.0 + 2.0 * 2 + 0.5 * 4 + 0.1 * 8 # = 7.8 + np.testing.assert_allclose(yld, expected, rtol=1e-12) + + +def test_W_ratio_terms(): + """K[3]=1, K[12]=1, K[31]=1 at W=1.2 → 1.2 + 1.44 + 1.728 = 4.368.""" + K = _zero_K() + K[3] = 1.0 + K[12] = 1.0 + K[31] = 1.0 + Ca = 400.0 + Ta = T_BASE.copy() + Wa = 1.2 * W_BASE + Na = 100.0 + yld, _, _ = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + w = 1.2 + expected = w + w**2 + w**3 + np.testing.assert_allclose(yld, expected, rtol=1e-10) + + +# --------------------------------------------------------------------------- +# Input clamping (GGCMI Phase 2 valid ranges, Table 2, Franke et al. 2020) +# --------------------------------------------------------------------------- + + +def test_CO2_below_min_clamped_to_360(): + K = _zero_K() + K[1] = 1.0 # linear C: yield == C_san + Ca = 200.0 # below 360 + Ta, Wa = T_BASE.copy(), W_BASE.copy() + yld, _, _ = get_yields(K, Ca, Ta, Wa, 100.0, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 360.0) + + +def test_CO2_above_max_clamped_to_810(): + K = _zero_K() + K[1] = 1.0 + Ca = 1200.0 # above 810 + Ta, Wa = T_BASE.copy(), W_BASE.copy() + yld, _, _ = get_yields(K, Ca, Ta, Wa, 100.0, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 810.0) + + +def test_CO2_midrange_unchanged(): + K = _zero_K() + K[1] = 1.0 + Ca = 550.0 + Ta, Wa = T_BASE.copy(), W_BASE.copy() + yld, _, _ = get_yields(K, Ca, Ta, Wa, 100.0, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 550.0) + + +def test_T_below_min_clamped(): + """Ta well below T_agmerra - 1 → T_san = T_agmerra - 1 → T_anomaly = -1. + + A large intercept (K[0]=10) keeps the total yield positive so we can + verify the clamped anomaly contribution (10 + 1×(−1) = 9) without the + non-negativity clip obscuring the result. + """ + K = _zero_K() + K[0] = 10.0 # intercept keeps yield > 0 + K[2] = 1.0 # linear T: adds T_anomaly + Ca = 400.0 + Ta = T_BASE - 5.0 # way below min → clamped to T_base - 1 (anomaly = -1) + Wa = W_BASE.copy() + yld, _, t_oob = get_yields(K, Ca, Ta, Wa, 100.0, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 9.0) # 10 + 1×(−1) = 9 + np.testing.assert_allclose(t_oob, -4.0) # excess = (−5) − (−1) = −4 + + +def test_T_above_max_clamped(): + """Ta = T_agmerra + 10 → T_san = T_agmerra + 6 → T_anomaly = 6.""" + K = _zero_K() + K[2] = 1.0 + Ca = 400.0 + Ta = T_BASE + 10.0 + Wa = W_BASE.copy() + yld, _, t_oob = get_yields(K, Ca, Ta, Wa, 100.0, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 6.0) + np.testing.assert_allclose(t_oob, 4.0) # excess = 10 - 6 = 4 + + +def test_T_in_range_no_clamping(): + K = _zero_K() + K[2] = 1.0 + Ca = 400.0 + Ta = T_BASE + 4.0 # within [-1, +6] + Wa = W_BASE.copy() + yld, _, t_oob = get_yields(K, Ca, Ta, Wa, 100.0, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 4.0) + np.testing.assert_allclose(t_oob, 0.0) + + +def test_W_below_min_clamped(): + """Wa = 0.1×W_base → W_san = 0.5×W_base → W_ratio = 0.5.""" + K = _zero_K() + K[3] = 1.0 # linear W: yield == W_ratio + Ca = 400.0 + Ta = T_BASE.copy() + Wa = 0.1 * W_BASE + yld, w_oob, _ = get_yields(K, Ca, Ta, Wa, 100.0, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 0.5) + np.testing.assert_allclose(w_oob, (0.1 - 0.5) * W_BASE, rtol=1e-10) + + +def test_W_above_max_clamped(): + """Wa = 2×W_base → W_san = 1.3×W_base → W_ratio = 1.3.""" + K = _zero_K() + K[3] = 1.0 + Ca = 400.0 + Ta = T_BASE.copy() + Wa = 2.0 * W_BASE + yld, w_oob, _ = get_yields(K, Ca, Ta, Wa, 100.0, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 1.3, rtol=1e-10) + np.testing.assert_allclose(w_oob, (2.0 - 1.3) * W_BASE, rtol=1e-10) + + +def test_W_at_baseline_ratio_is_one(): + K = _zero_K() + K[3] = 1.0 + Ca = 400.0 + Ta = T_BASE.copy() + Wa = W_BASE.copy() + yld, w_oob, _ = get_yields(K, Ca, Ta, Wa, 100.0, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 1.0) + np.testing.assert_allclose(w_oob, 0.0) + + +def test_N_below_min_clamped_to_10(): + K = _zero_K() + K[4] = 1.0 # linear N: yield == N_san + Ca, Ta, Wa = 400.0, T_BASE.copy(), W_BASE.copy() + yld, _, _ = get_yields(K, Ca, Ta, Wa, 1.0, T_BASE, W_BASE) # Na=1 < 10 + np.testing.assert_allclose(yld, 10.0) + + +def test_N_above_max_clamped_to_200(): + K = _zero_K() + K[4] = 1.0 + Ca, Ta, Wa = 400.0, T_BASE.copy(), W_BASE.copy() + yld, _, _ = get_yields(K, Ca, Ta, Wa, 500.0, T_BASE, W_BASE) # Na=500 > 200 + np.testing.assert_allclose(yld, 200.0) + + +def test_N_in_range_unchanged(): + K = _zero_K() + K[4] = 1.0 + Ca, Ta, Wa = 400.0, T_BASE.copy(), W_BASE.copy() + yld, _, _ = get_yields(K, Ca, Ta, Wa, 75.0, T_BASE, W_BASE) + np.testing.assert_allclose(yld, 75.0) + + +# --------------------------------------------------------------------------- +# Out-of-bounds offset semantics +# --------------------------------------------------------------------------- + + +def test_no_oob_when_in_range(): + K = _zero_K() + Ca, Ta, Wa, Na = _standard_inputs() + _, w_oob, t_oob = get_yields(K, Ca, Ta, Wa, Na, T_BASE, W_BASE) + np.testing.assert_array_equal(t_oob, 0.0) + np.testing.assert_array_equal(w_oob, 0.0) + + +def test_T_oob_negative_below_range(): + K = _zero_K() + excess = -3.0 + Ta = T_BASE + (-1.0 + excess) # 3 °C below lower bound + _, _, t_oob = get_yields(K, 400.0, Ta, W_BASE.copy(), 100.0, T_BASE, W_BASE) + np.testing.assert_allclose(t_oob, excess) + + +def test_T_oob_positive_above_range(): + K = _zero_K() + excess = 4.0 + Ta = T_BASE + (6.0 + excess) # 4 °C above upper bound + _, _, t_oob = get_yields(K, 400.0, Ta, W_BASE.copy(), 100.0, T_BASE, W_BASE) + np.testing.assert_allclose(t_oob, excess) + + +def test_W_oob_is_in_mmyr(): + """W_oob is in mm/yr (absolute, not ratio).""" + K = _zero_K() + Wa = 0.2 * W_BASE # well below 0.5×W_base + _, w_oob, _ = get_yields(K, 400.0, T_BASE.copy(), Wa, 100.0, T_BASE, W_BASE) + expected_w_oob = Wa - 0.5 * W_BASE # should be -0.3 × W_BASE + np.testing.assert_allclose(w_oob, expected_w_oob, rtol=1e-10) + + +# --------------------------------------------------------------------------- +# Spatially varying baseline +# --------------------------------------------------------------------------- + + +def test_T_anomaly_uses_local_baseline(): + """T = Ta - T_agmerra: each cell uses its own baseline temperature.""" + K = np.zeros((35, 2, 2)) # K must match the 2×2 grid shape + K[2] = 1.0 + T_base_varying = np.array([[10.0, 20.0], [5.0, 30.0]]) + W_base_varying = np.full((2, 2), 500.0) + Ta = T_base_varying + 1.0 # +1 °C anomaly everywhere (within valid range) + Wa = W_base_varying.copy() + yld, _, _ = get_yields(K, 400.0, Ta, Wa, 100.0, T_base_varying, W_base_varying) + np.testing.assert_allclose(yld, 1.0) # anomaly = 1 at every cell + + +def test_W_ratio_uses_local_baseline(): + """W = Wa / W_agmerra: each cell uses its own baseline precipitation.""" + K = np.zeros((35, 2, 2)) # K must match the 2×2 grid shape + K[3] = 1.0 + T_base_varying = np.full((2, 2), 15.0) + W_base_varying = np.array([[400.0, 800.0], [200.0, 1200.0]]) + Ta = T_base_varying.copy() + Wa = 1.1 * W_base_varying # ratio = 1.1 everywhere (within [0.5, 1.3]) + yld, _, _ = get_yields(K, 400.0, Ta, Wa, 100.0, T_base_varying, W_base_varying) + np.testing.assert_allclose(yld, 1.1, rtol=1e-10) + + +# --------------------------------------------------------------------------- +# load_coefficients — reads K tensor from a netCDF4 file +# --------------------------------------------------------------------------- + + +def _make_mock_nc(k_data): + """Return a mock netCDF4.Dataset whose K_rf variable returns k_data.""" + mock_var = MagicMock() + mock_var.__getitem__.return_value = k_data + mock_nc = MagicMock() + mock_nc.variables = {"K_rf": mock_var} + return mock_nc + + +def test_returns_array_with_correct_shape(): + """K shape must be (35, 360, 720) as stored in the Zenodo files.""" + k_data = np.zeros((35, 360, 720), dtype=np.float64) + mock_nc = _make_mock_nc(k_data) + with patch("meteor.impacts.ggcm.coefficients.netcdf.Dataset", return_value=mock_nc): + K = load_coefficients("fake.nc4") + assert K.shape == (35, 360, 720) + + +def test_returns_float64_dtype(): + """load_coefficients must cast the result to float64.""" + k_data = np.ones((35, 2, 3), dtype=np.float32) # float32 input + mock_nc = _make_mock_nc(k_data) + with patch("meteor.impacts.ggcm.coefficients.netcdf.Dataset", return_value=mock_nc): + K = load_coefficients("fake.nc4") + assert K.dtype == np.float64 + + +def test_values_are_preserved(): + """Coefficient values read from the file are returned unchanged.""" + rng = np.random.default_rng(0) + k_data = rng.standard_normal((35, 4, 6)) + mock_nc = _make_mock_nc(k_data) + with patch("meteor.impacts.ggcm.coefficients.netcdf.Dataset", return_value=mock_nc): + K = load_coefficients("fake.nc4") + np.testing.assert_allclose(K, k_data) + + +def test_dataset_opened_in_read_mode(): + """The file must be opened with mode='r'.""" + k_data = np.zeros((35, 2, 2)) + mock_nc = _make_mock_nc(k_data) + with patch( + "meteor.impacts.ggcm.coefficients.netcdf.Dataset", return_value=mock_nc + ) as mock_ds: + load_coefficients("path/to/coeff.nc4") + mock_ds.assert_called_once_with("path/to/coeff.nc4", "r") + + +def test_dataset_is_closed_after_read(): + """The netCDF4 dataset must be closed even on success.""" + k_data = np.zeros((35, 2, 2)) + mock_nc = _make_mock_nc(k_data) + with patch("meteor.impacts.ggcm.coefficients.netcdf.Dataset", return_value=mock_nc): + load_coefficients("fake.nc4") + mock_nc.close.assert_called_once() diff --git a/tests/unit/test_ensemble_output.py b/tests/unit/test_ensemble_output.py index b1c40882..510e0a41 100644 --- a/tests/unit/test_ensemble_output.py +++ b/tests/unit/test_ensemble_output.py @@ -529,3 +529,57 @@ def test_to_netcdf_annual_and_monthly_gridded(): if os.path.exists(tmp_path): os.remove(tmp_path) + + +def test_to_netcdf_with_2d_realization_timeseries(): + """to_netcdf handles 2D (realization, time) timeseries arrays.""" + var_tas = VariableOutput("tas") + # 2D: (n_realizations, n_time) + var_tas.timeseries["global"] = xr.DataArray( + np.ones((3, 5)), + dims=["realization", "month"], + ) + + ensemble = EnsembleOutput({"tas": var_tas}) + + with tempfile.NamedTemporaryFile(suffix=".nc", delete=False) as tmp: + tmp_path = tmp.name + + with patch("builtins.print"): + ensemble.to_netcdf(tmp_path, include_impacts=False) + + assert os.path.exists(tmp_path) + loaded = xr.open_dataset(tmp_path) + assert "tas_global" in loaded.data_vars + assert loaded["tas_global"].dims == ("realization", "month") + loaded.close() + + if os.path.exists(tmp_path): + os.remove(tmp_path) + + +def test_to_netcdf_with_non_dict_gridded(): + """to_netcdf handles gridded DataArray (not a dict) via the else path.""" + var_tas = VariableOutput("tas") + # Simple DataArray (not dict) in gridded — triggers the else branch + var_tas.gridded["climatology"] = xr.DataArray( + np.ones((2, 3, 4)), + dims=["realization", "lat", "lon"], + coords={"lat": [0.0, 1.0, 2.0], "lon": [0.0, 1.0, 2.0, 3.0]}, + ) + + ensemble = EnsembleOutput({"tas": var_tas}) + + with tempfile.NamedTemporaryFile(suffix=".nc", delete=False) as tmp: + tmp_path = tmp.name + + with patch("builtins.print"): + ensemble.to_netcdf(tmp_path, include_impacts=False) + + assert os.path.exists(tmp_path) + loaded = xr.open_dataset(tmp_path) + assert "tas_grid_climatology" in loaded.data_vars + loaded.close() + + if os.path.exists(tmp_path): + os.remove(tmp_path) diff --git a/tests/unit/test_meteor_interface.py b/tests/unit/test_meteor_interface.py index de3625d0..51241630 100644 --- a/tests/unit/test_meteor_interface.py +++ b/tests/unit/test_meteor_interface.py @@ -13,7 +13,18 @@ import xarray as xr from meteor.ensemble_output import EnsembleOutput -from meteor.meteor_interface import MeteorInterface, _get_default_config +from meteor.meteor_interface import ( + GenerationInputs, + MeteorInterface, + PatternScalingResult, + _get_default_config, + _stack_realizations, +) +from meteor.precipitation_transform import ( + apply_distribution_transform, + fit_distribution_parameters_3d, +) +from meteor.variable_transforms import VariableTransformConfig def _set_trained(interface, variables): @@ -77,8 +88,10 @@ def test_get_default_config(): assert not generic_config["transform"] -def test_tas_converted_to_anomalies(mock_interface): - """Test that tas data is converted to anomalies from piControl baseline.""" +def test_tas_skips_reference_data_loading(mock_interface): + """tas has no distribution transform, so no CMIP6/piControl reference data + should be loaded during time series generation (the former anomaly-conversion + path only fed transform fitting, which tas does not perform).""" # Create mock piControl data with known mean picontrol_mean = 288.0 # K picontrol_data = xr.Dataset( @@ -151,7 +164,7 @@ def test_tas_converted_to_anomalies(mock_interface): np.zeros(100), dims=["month"], coords={"month": range(100)} ) - # This should trigger the anomaly conversion for tas + # This should NOT trigger any reference-data loading for tas _ = mock_interface._generate_timeseries( variable="tas", scenario="ssp245", @@ -163,16 +176,8 @@ def test_tas_converted_to_anomalies(mock_interface): verbose=False, ) - # Verify that make_meteor_training_data_composite was called for both scenario and piControl - calls = [ - call[0] - for call in mock_interface.data_getter.make_meteor_training_data_composite.call_args_list - ] - - # Should have been called with scenario data - assert any("ssp245" in str(call) or "historical" in str(call) for call in calls) - # Should have been called with piControl data (for tas only) - assert any("piControl" in str(call) for call in calls) + # tas has no transform, so no CMIP6/piControl reference data is loaded. + mock_interface.data_getter.make_meteor_training_data_composite.assert_not_called() def test_pr_not_converted_to_anomalies(mock_interface): @@ -575,7 +580,16 @@ def test_generate_gridded_climatology_no_noise_single_realization(interface_fact coords={"month": np.arange(24), "lat": [0, 1], "lon": [0, 1]}, ) interface._get_or_compute_pattern_scaling = MagicMock( - return_value=(monthly_prediction, monthly_warming) + return_value=PatternScalingResult( + monthly_prediction=monthly_prediction, + monthly_warming=monthly_warming, + em_data=None, + conc_data=None, + full_monthly_warming=monthly_warming, + base_year=2000, + start_month_idx=0, + end_month_idx=24, + ) ) gridded = interface._generate_gridded( @@ -677,3 +691,339 @@ def test_compute_timeseries_scaling(): ) assert scaling_factor.shape == (1, 1, 1) assert np.isclose(scaling_factor.values[0, 0, 0], 1.0) + + +def test_interface_with_tabids_in_data_getter_kwargs(): + """MeteorInterface passes tabids from data_getter_kwargs to Cmip6MeteorDataGetter.""" + with patch("meteor.meteor_interface.Cmip6MeteorDataGetter") as mock_getter_class: + mock_getter_class.return_value = MagicMock() + + MeteorInterface( + model="TestModel", + variables=["tas"], + cache_dir="/tmp", + data_getter_kwargs={"tabids": "Amon"}, + ) + + _, call_kwargs = mock_getter_class.call_args + assert call_kwargs["tabids"] is not None + + +def test_train_with_custom_training_scenario(interface_factory): + """train() with a non-default training_scenario stores it in _training_config.""" + interface, _ = interface_factory(model="TestModel", variables=("tas",)) + + with ( + patch.object(interface, "_train_pattern_scaling"), + patch.object(interface, "_train_noise_model"), + ): + interface.train(training_scenario="ssp370", verbose=False) + + assert interface._training_config["tas"]["training_scenario"] == "ssp370" + + +def test_train_with_variable_configs(interface_factory): + """train() with variable_configs applies per-variable overrides.""" + interface, _ = interface_factory(model="TestModel", variables=("tas",)) + + with ( + patch.object(interface, "_train_pattern_scaling"), + patch.object(interface, "_train_noise_model"), + ): + interface.train(variable_configs={"tas": {"n_modes_noise": 20}}, verbose=False) + + assert interface._training_config["tas"]["n_modes_noise"] == 20 + + +def test_generate_saves_to_file(interface_factory): + """generate_ensemble_outputs() calls ensemble.to_netcdf when save_to is given.""" + interface, _ = interface_factory(model="TestModel", variables=("tas",)) + _set_trained(interface, ["tas"]) + + interface._generate_timeseries = MagicMock( + return_value={"global": xr.DataArray([290.0], dims=["time"])} + ) + + with patch.object(EnsembleOutput, "to_netcdf") as mock_save: + interface.generate_ensemble_outputs( + scenario="ssp245", + start_year=2020, + end_year=2020, + n_realizations=1, + timeseries=["global"], + save_to="/tmp/test_output.nc", + verbose=False, + ) + + mock_save.assert_called_once_with("/tmp/test_output.nc") + + +# ============================================================================= +# Shared generation helpers (introduced by the unified-generation refactor) +# ============================================================================= + + +def test_stack_realizations_single_adds_realization_dim(): + """A single realization is promoted to a length-1 ``realization`` dimension.""" + field = xr.DataArray( + np.ones((3, 2, 2)), + dims=["month", "lat", "lon"], + coords={"month": range(3), "lat": [0, 1], "lon": [0, 1]}, + ) + + stacked = _stack_realizations([field]) + + assert "realization" in stacked.dims + assert stacked.sizes["realization"] == 1 + # The underlying field is unchanged aside from the new leading axis. + assert np.array_equal(stacked.isel(realization=0).values, field.values) + + +def test_stack_realizations_multiple_concatenates(): + """Multiple realizations are concatenated along the ``realization`` dim.""" + fields = [ + xr.DataArray( + np.full((3, 2, 2), float(i)), + dims=["month", "lat", "lon"], + coords={"month": range(3), "lat": [0, 1], "lon": [0, 1]}, + ) + for i in range(4) + ] + + stacked = _stack_realizations(fields) + + assert stacked.sizes["realization"] == 4 + # Each member retains its distinct values. + for i in range(4): + assert np.all(stacked.isel(realization=i).values == float(i)) + + +def test_get_transform_config_handles_dict_and_direct(interface_factory): + """_get_transform_config resolves both fitted (dict) and unfitted configs.""" + interface, _ = interface_factory(model="TestModel", variables=("pr",)) + config = VariableTransformConfig("pr", "gamma", "positivity") + + # Fitted case: stored as a dict with a 'config' entry. + interface.transforms["pr"] = {"config": config, "target_params": {}} + assert interface._get_transform_config("pr") is config + + # Unfitted case: stored as the config object directly. + interface.transforms["pr"] = config + assert interface._get_transform_config("pr") is config + + # Missing case: variable with no transform registered. + assert interface._get_transform_config("tas") is None + + +def test_prepare_generation_slices_full_trajectory_pcs(interface_factory): + """PCs are generated once over the full trajectory then sliced to the window. + + The autoregressive spin-up transient must be parked at the trajectory start, + so PCs are generated over ``full_monthly_warming`` and only afterwards sliced + to ``[start_month_idx:end_month_idx]``. + """ + interface, _ = interface_factory(model="TestModel", variables=("pr",)) + _set_trained(interface, ["pr"]) + + n_months_full = 36 # 3 years from base_year + start_idx, end_idx = 12, 24 # output window = second year + full_warming = np.linspace(0.0, 3.0, n_months_full) + + pattern = PatternScalingResult( + monthly_prediction=xr.DataArray(np.zeros(12), dims=["month"]), + monthly_warming=full_warming[start_idx:end_idx], + em_data=None, + conc_data=None, + full_monthly_warming=full_warming, + base_year=2000, + start_month_idx=start_idx, + end_month_idx=end_idx, + ) + interface._get_or_compute_pattern_scaling = MagicMock(return_value=pattern) + + full_pcs = np.arange(3 * n_months_full * 4).reshape(3, n_months_full, 4) + interface.noise_models["pr"].generate_stochastic_pcs.return_value = full_pcs + + gen_inputs = interface._prepare_generation( + "pr", "ssp245", 2001, 2001, n_realizations=3, verbose=False + ) + + assert isinstance(gen_inputs, GenerationInputs) + # PCs generated over the FULL trajectory (length 36), not the window. + call_args, _ = interface.noise_models["pr"].generate_stochastic_pcs.call_args + assert len(call_args[0]) == n_months_full + # Returned PCs are sliced to the output window. + assert gen_inputs.stochastic_pcs.shape == (3, end_idx - start_idx, 4) + assert np.array_equal(gen_inputs.stochastic_pcs, full_pcs[:, start_idx:end_idx, :]) + + +def test_prepare_generation_normalizes_2d_pcs(interface_factory): + """A 2D (single-realization) PC array is promoted to a leading realization axis.""" + interface, _ = interface_factory(model="TestModel", variables=("pr",)) + _set_trained(interface, ["pr"]) + + pattern = PatternScalingResult( + monthly_prediction=xr.DataArray(np.zeros(12), dims=["month"]), + monthly_warming=np.zeros(12), + em_data=None, + conc_data=None, + full_monthly_warming=np.zeros(24), + base_year=2000, + start_month_idx=0, + end_month_idx=12, + ) + interface._get_or_compute_pattern_scaling = MagicMock(return_value=pattern) + interface.noise_models["pr"].generate_stochastic_pcs.return_value = np.zeros( + (24, 4) + ) + + gen_inputs = interface._prepare_generation( + "pr", "ssp245", 2000, 2000, n_realizations=1, verbose=False + ) + + assert gen_inputs.stochastic_pcs.shape == (1, 12, 4) + + +def test_prepare_generation_no_noise_skips_pcs(interface_factory): + """With include_noise=False no PCs are generated and the field is None.""" + interface, _ = interface_factory(model="TestModel", variables=("pr",)) + _set_trained(interface, ["pr"]) + + pattern = PatternScalingResult( + monthly_prediction=xr.DataArray(np.zeros(12), dims=["month"]), + monthly_warming=np.zeros(12), + em_data=None, + conc_data=None, + full_monthly_warming=np.zeros(24), + base_year=2000, + start_month_idx=0, + end_month_idx=12, + ) + interface._get_or_compute_pattern_scaling = MagicMock(return_value=pattern) + + gen_inputs = interface._prepare_generation( + "pr", "ssp245", 2000, 2000, n_realizations=5, include_noise=False, verbose=False + ) + + assert gen_inputs.stochastic_pcs is None + interface.noise_models["pr"].generate_stochastic_pcs.assert_not_called() + + +def test_generate_gridded_slice_no_noise_reduces_time(interface_factory): + """Without noise the slice is the time-mean of the base pattern, no noise calls.""" + interface, _ = interface_factory(model="TestModel", variables=("tas",)) + noise_model = MagicMock() + + monthly_prediction = xr.DataArray( + np.arange(24 * 2 * 2, dtype=float).reshape(24, 2, 2), + dims=["month", "lat", "lon"], + coords={"month": np.arange(24), "lat": [0, 1], "lon": [0, 1]}, + ) + + result = interface._generate_gridded_slice( + monthly_prediction, + np.zeros(24), + noise_model, + stochastic_pcs=None, + start_idx=0, + end_idx=12, + include_noise=False, + reduce_time=True, + ) + + noise_model.generate_realization.assert_not_called() + assert result.dims == ("realization", "lat", "lon") + assert result.sizes["realization"] == 1 + expected = monthly_prediction.isel(month=slice(0, 12)).mean(dim="month") + assert np.allclose(result.isel(realization=0).values, expected.values) + + +def test_generate_gridded_slice_passes_sliced_pcs(interface_factory): + """With noise the window-sliced PCs and base climatology are forwarded.""" + interface, _ = interface_factory(model="TestModel", variables=("tas",)) + noise_model = MagicMock() + + monthly_prediction = xr.DataArray( + np.zeros((24, 2, 2)), + dims=["month", "lat", "lon"], + coords={"month": np.arange(24), "lat": [0, 1], "lon": [0, 1]}, + ) + noise_model.generate_realization.return_value = [ + xr.DataArray( + np.zeros((12, 2, 2)), + dims=["month", "lat", "lon"], + coords={"month": np.arange(12), "lat": [0, 1], "lon": [0, 1]}, + ) + for _ in range(2) + ] + + stochastic_pcs = np.arange(2 * 24 * 4).reshape(2, 24, 4) + + result = interface._generate_gridded_slice( + monthly_prediction, + np.zeros(24), + noise_model, + stochastic_pcs=stochastic_pcs, + start_idx=12, + end_idx=24, + include_noise=True, + reduce_time=False, + ) + + _, call_kwargs = noise_model.generate_realization.call_args + # PCs are sliced to the requested window before being passed on. + assert np.array_equal(call_kwargs["stochastic_pcs"], stochastic_pcs[:, 12:24, :]) + assert call_kwargs["noise_only"] is True + # Monthly output retains the month axis and both realizations. + assert result.sizes["realization"] == 2 + assert "month" in result.dims + + +def test_apply_gridded_transform_drops_singleton_ens_dim(interface_factory): + """The (lat, lon) baseline must not append a spurious axis to the ensemble. + + The CMIP6 data getter adds a singleton ``ens`` dimension to its fields. When + that baseline is added to the generated ensemble it must be reduced to its + spatial grid first, otherwise xarray broadcasting produces a 5D array that the + per-gridpoint transform rejects. This is a regression test for that bug. + """ + interface, _ = interface_factory(model="TestModel", variables=("pr",)) + + rng = np.random.default_rng(0) + ensemble = xr.DataArray( + rng.normal(0.0, 1e-6, size=(2, 12, 2, 2)), + dims=["realization", "month", "lat", "lon"], + coords={ + "realization": [0, 1], + "month": np.arange(12), + "lat": [0, 1], + "lon": [0, 1], + }, + ) + # Baseline carries a singleton ``ens`` dim as produced by the data getter. + pr_baseline_field = xr.DataArray( + rng.uniform(1e-5, 2e-5, size=(1, 2, 2)), + dims=["ens", "lat", "lon"], + coords={"ens": [1], "lat": [0, 1], "lon": [0, 1]}, + ) + + target_ref = rng.uniform(1e-5, 3e-5, size=(24, 2, 2)) + target_params = fit_distribution_parameters_3d(target_ref, "gamma") + + config = VariableTransformConfig( + "pr", + "gamma", + "positivity", + fit_3d_func=fit_distribution_parameters_3d, + apply_func=apply_distribution_transform, + ) + + result = interface._apply_gridded_transform( + ensemble, config, target_params, pr_baseline_field + ) + + # Dimensions are preserved (no spurious ``ens`` axis) ... + assert result.dims == ("realization", "month", "lat", "lon") + assert result.shape == (2, 12, 2, 2) + # ... and the gamma transform guarantees non-negative precipitation. + assert np.all(result.values >= 0) diff --git a/tests/unit/test_precipitation_transform.py b/tests/unit/test_precipitation_transform.py index ba7ca079..31ba93cd 100644 --- a/tests/unit/test_precipitation_transform.py +++ b/tests/unit/test_precipitation_transform.py @@ -154,3 +154,101 @@ def test_apply_empirical_quantile_mapping(): }, ) transformed = apply_empirical_quantile_mapping(data_xarray, reference) + + +def test_fit_distribution_parameters_1d_lognorm_with_zeros(): + """lognorm fit adds 1e-6 offset when data contains zeros.""" + data = np.array([0.0, 0.5, 1.0, 2.0, 3.0]) # zero triggers offset path + params = fit_distribution_parameters_1d(data, distribution="lognorm") + assert "shape" in params and "scale" in params + assert params["shape"] > 0 + assert params["scale"] > 0 + + +def test_apply_distribution_transform_xarray_input_1d(): + """apply_distribution_transform accepts xarray input and returns xarray.""" + data = xr.DataArray( + np.array([[0.1, 0.5, 1.0, 2.0, 3.0]]), + dims=["n_realisations", "n_time"], + ) + params_gauss = {"mean": 1.2, "std": 0.8} + params_gamma = {"shape": 1.5, "scale": 0.8} + transformed = apply_distribution_transform( + data, params_gauss, params_gamma, target_dist="gamma" + ) + assert isinstance(transformed, xr.DataArray) + assert transformed.shape == data.shape + assert np.all(transformed.values >= 0) + + +def test_apply_distribution_transform_1d_weibull(): + """apply_distribution_transform maps Gaussian → Weibull for 1D scalar params.""" + data = np.array([[0.1, 0.5, 1.0, 2.0, 3.0]]) + params_gauss = {"mean": 1.2, "std": 0.8} + params_weibull = fit_distribution_parameters_1d( + np.array([0.1, 0.5, 1.0, 2.0, 3.0]), distribution="weibull" + ) + transformed = apply_distribution_transform( + data, params_gauss, params_weibull, target_dist="weibull" + ) + assert transformed.shape == data.shape + assert np.all(np.isfinite(transformed)) + + +def test_apply_distribution_transform_1d_lognorm(): + """apply_distribution_transform maps Gaussian → LogNorm for 1D scalar params.""" + data = np.array([[0.1, 0.5, 1.0, 2.0, 3.0]]) + params_gauss = {"mean": 1.2, "std": 0.8} + params_lognorm = fit_distribution_parameters_1d( + np.array([0.1, 0.5, 1.0, 2.0, 3.0]), distribution="lognorm" + ) + transformed = apply_distribution_transform( + data, params_gauss, params_lognorm, target_dist="lognorm" + ) + assert transformed.shape == data.shape + assert np.all(np.isfinite(transformed)) + + +def test_apply_distribution_transform_1d_gengamma(): + """apply_distribution_transform maps Gaussian → GenGamma for 1D scalar params.""" + data = np.array([[0.1, 0.5, 1.0, 2.0, 3.0]]) + params_gauss = {"mean": 1.2, "std": 0.8} + params_gengamma = fit_distribution_parameters_1d( + np.array([0.1, 0.5, 1.0, 2.0, 3.0]), distribution="gengamma" + ) + transformed = apply_distribution_transform( + data, params_gauss, params_gengamma, target_dist="gengamma" + ) + assert transformed.shape == data.shape + assert np.all(np.isfinite(transformed)) + + +def test_apply_distribution_transform_1d_unknown_raises(): + """apply_distribution_transform raises ValueError for unknown 1D target_dist.""" + data = np.array([[0.1, 0.5, 1.0, 2.0, 3.0]]) + params_gauss = {"mean": 1.2, "std": 0.8} + params_gamma = {"shape": 1.5, "scale": 0.8} + with pytest.raises(ValueError, match="Unknown target distribution: bad_dist"): + apply_distribution_transform( + data, params_gauss, params_gamma, target_dist="bad_dist" + ) + + +def test_apply_distribution_transform_1d_wrong_ndim_raises(): + """apply_distribution_transform raises ValueError when 1D data is not 2D array.""" + data = np.array([0.1, 0.5, 1.0, 2.0, 3.0]) # 1D, not (n_real, n_time) + params_gauss = {"mean": 1.2, "std": 0.8} + params_gamma = {"shape": 1.5, "scale": 0.8} + with pytest.raises(ValueError, match="For scalar parameters"): + apply_distribution_transform( + data, params_gauss, params_gamma, target_dist="gamma" + ) + + +def test_apply_empirical_quantile_mapping_xarray_target(): + """apply_empirical_quantile_mapping accepts xarray target_data.""" + data = np.array([[0.1, 0.5, 1.0, 2.0, 3.0]]) + reference = xr.DataArray(np.array([0.2, 0.6, 1.5, 2.5, 4.0]), dims=["time"]) + transformed = apply_empirical_quantile_mapping(data, reference) + assert transformed.shape == data.shape + assert np.all(transformed >= 0)