diff --git a/specs/analyses/cdl_glad_glc_comparison.ipynb b/specs/analyses/cdl_glad_glc_comparison.ipynb new file mode 100644 index 0000000..5594dd6 --- /dev/null +++ b/specs/analyses/cdl_glad_glc_comparison.ipynb @@ -0,0 +1,692 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e98b3864", + "metadata": {}, + "source": [ + "# CDL row crop vs GLAD GLC cropland: agreement, lost pixels, and emissions impact\n", + "\n", + "This notebook quantifies the disagreement between the USDA Cropland Data Layer (CDL) and GLAD GLCLUC v2 cropland classifications, and assesses whether that disagreement creates a bias in the jdLUC methodology's emissions factors.\n", + "\n", + "**Why this matters.** The methodology uses GLAD GLC's cropland mask (pixel value 244) as the canonical 2020 cropland extent. CDL is then layered on top to attribute pixels to specific row crops (corn, soy, wheat). Any CDL row-crop pixel that GLAD GLC does not also classify as cropland is excluded from both the emissions numerator and the production denominator. We need to confirm that the excluded pixels do not introduce a systematic bias in the per-crop emissions factors.\n", + "\n", + "**Result preview.** ~91% of CONUS CDL row crop hectares are confirmed by GLAD GLC. The remaining 9% are concentrated in fragmented agricultural regions (Southeast, Northeast). Decomposing the disagreement on 10 large agricultural states shows that nearly all of the lost area is stable built-up or stable short vegetation — most of which would not have produced LUC emissions even if classified as cropland. Only ~3% of lost pixels show a transition history that would have generated meaningful emissions if counted.\n", + "\n", + "The findings here support **Appendix 1** of `specs/methodology.md`." + ] + }, + { + "cell_type": "markdown", + "id": "8c06b9be", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "Earth Engine is used for all raster math. Results are cached to `analyses/output/` as JSON Lines so the notebook can be re-run without re-querying GEE." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93f0d96e", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import logging\n", + "import os\n", + "from pathlib import Path\n", + "from typing import Any\n", + "\n", + "import ee\n", + "import pandas as pd\n", + "\n", + "from jdluc.utils.constants import (\n", + " GCP_PROJECT,\n", + " GEE_CDL_COLLECTION,\n", + " GEE_TIGER_STATES,\n", + ")\n", + "from jdluc.utils.gee import initialize_gee\n", + "\n", + "logging.basicConfig(level=logging.INFO, format='%(asctime)s %(message)s', datefmt='%H:%M:%S')\n", + "logger = logging.getLogger(__name__)\n", + "\n", + "# GCP_PROJECT comes from utils.constants (env-var overridable via JDLUC_GCP_PROJECT).\n", + "initialize_gee(GCP_PROJECT)\n", + "\n", + "OUTPUT_DIR = Path('output')\n", + "OUTPUT_DIR.mkdir(exist_ok=True)\n", + "\n", + "EEImage = Any\n", + "EEGeometry = Any" + ] + }, + { + "cell_type": "markdown", + "id": "e74e3741", + "metadata": {}, + "source": [ + "### Constants\n", + "\n", + "**GLAD GLCLUC** v2 uses pixel value `244` for cropland; we also reclassify the full value range into nine simplified categories for source/destination breakdowns.\n", + "\n", + "**CDL row crop codes** are the herbaceous crop codes (annual + perennial) excluding hay (codes 36, 37) and fallow (61), since the wider category churns year-to-year and over-counts vs GLC. Section 4 documents the empirical basis for that exclusion." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d87f8132", + "metadata": {}, + "outputs": [], + "source": [ + "GEE_GLAD_GLC_PREFIX = 'projects/glad/GLCLU2020/v2/LCLUC_'\n", + "GLAD_GLC_CROPLAND_VALUE = 244\n", + "\n", + "# CDL herbaceous crop codes (annual + perennial herbaceous, incl. hay/fallow).\n", + "CDL_HERBACEOUS_CROP_CODES = [\n", + " 1, 2, 3, 4, 5, 6, 10, 11, 12, 13, 14,\n", + " 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,\n", + " 36, 37, 38, 39,\n", + " 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 56, 57,\n", + " 61,\n", + " 205, 206, 207, 208, 209, 213, 214, 216, 218, 219, 221, 222, 223,\n", + " 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237,\n", + " 238, 239, 240, 241, 243, 244, 245, 246, 247, 248, 249, 254,\n", + "]\n", + "CDL_HAY_CODES = [36, 37]\n", + "CDL_FALLOW_CODES = [61]\n", + "CDL_ROWCROP_CODES = [\n", + " c for c in CDL_HERBACEOUS_CROP_CODES\n", + " if c not in CDL_HAY_CODES and c not in CDL_FALLOW_CODES\n", + "]\n", + "\n", + "# GLAD GLC simplified categories\n", + "GLAD_CATEGORY_NAMES = {\n", + " 0: 'bare', 1: 'short_veg', 2: 'forest',\n", + " 3: 'wetland_short_veg', 4: 'wetland_forest',\n", + " 5: 'water', 6: 'cropland', 7: 'built_up', 8: 'snow_ice_other',\n", + "}\n", + "\n", + "# CONUS: exclude AK (02), HI (15), and territories\n", + "EXCLUDED_STATEFP = {'02', '15', '60', '66', '69', '72', '78'}\n", + "\n", + "# Two states are too large for one reduceRegion; tile them.\n", + "LARGE_STATES = {'Texas', 'New Mexico', 'Montana'}\n", + "\n", + "# Anchor analysis on CDL 2020 × GLAD GLC 2020 (same-year baseline).\n", + "GLAD_YEAR = 2020\n", + "CDL_YEAR = 2020\n", + "\n", + "# Subset of large agricultural states for the deeper Case A/B/C analyses.\n", + "STATES_FOR_DEEP_DIVE = [\n", + " 'Iowa', 'North Dakota', 'Illinois', 'Montana', 'Georgia',\n", + " 'Kansas', 'Texas', 'Minnesota', 'Indiana', 'Nebraska',\n", + "]" + ] + }, + { + "cell_type": "markdown", + "id": "a1dd2dbe", + "metadata": {}, + "source": [ + "### Helper functions\n", + "\n", + "Image loaders, geometry tiling for large states, and a small caching utility that keeps each state's result on its own line so an interrupted run resumes cleanly." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13a7a41f", + "metadata": {}, + "outputs": [], + "source": [ + "def load_glad_glc_crop_mask(year: int, geometry: EEGeometry) -> EEImage:\n", + " return (\n", + " ee.Image(GEE_GLAD_GLC_PREFIX + str(year))\n", + " .clip(geometry)\n", + " .eq(GLAD_GLC_CROPLAND_VALUE)\n", + " .rename('glad_glc_crop')\n", + " )\n", + "\n", + "\n", + "def load_cdl_rowcrop_mask(year: int, geometry: EEGeometry) -> EEImage:\n", + " cdl = (\n", + " ee.ImageCollection(GEE_CDL_COLLECTION)\n", + " .filter(ee.Filter.calendarRange(year, year, 'year'))\n", + " .first()\n", + " .select('cropland')\n", + " .clip(geometry)\n", + " )\n", + " return cdl.remap(\n", + " CDL_ROWCROP_CODES, [1] * len(CDL_ROWCROP_CODES), defaultValue=0\n", + " ).rename('cdl_rowcrop')\n", + "\n", + "\n", + "def classify_glad_glc(image: EEImage) -> EEImage:\n", + " \"\"\"Reclassify GLAD GLC raw values to the nine simplified categories.\"\"\"\n", + " raw, cat = [0], [0]\n", + " for v in range(1, 25): raw.append(v); cat.append(1) # short veg\n", + " for v in range(25, 49): raw.append(v); cat.append(2) # forest\n", + " for v in range(100, 125): raw.append(v); cat.append(3) # wetland short\n", + " for v in range(125, 149): raw.append(v); cat.append(4) # wetland forest\n", + " for v in range(200, 208): raw.append(v); cat.append(5) # water\n", + " raw += [244, 250, 241]; cat += [6, 7, 8] # crop, built, snow\n", + " return image.remap(raw, cat, defaultValue=8)\n", + "\n", + "\n", + "def tile_geometry(geometry: EEGeometry, n_cols: int = 3, n_rows: int = 3) -> list[EEGeometry]:\n", + " bounds = ee.Geometry(geometry).bounds().getInfo()['coordinates'][0]\n", + " lons = [p[0] for p in bounds]; lats = [p[1] for p in bounds]\n", + " min_lon, max_lon = min(lons), max(lons)\n", + " min_lat, max_lat = min(lats), max(lats)\n", + " d_lon = (max_lon - min_lon) / n_cols\n", + " d_lat = (max_lat - min_lat) / n_rows\n", + " geom_ee = ee.Geometry(geometry)\n", + " tiles = []\n", + " for r in range(n_rows):\n", + " for c in range(n_cols):\n", + " tile_rect = ee.Geometry.Rectangle([\n", + " min_lon + c * d_lon, min_lat + r * d_lat,\n", + " min_lon + (c + 1) * d_lon, min_lat + (r + 1) * d_lat,\n", + " ])\n", + " tiles.append(geom_ee.intersection(tile_rect))\n", + " return tiles\n", + "\n", + "\n", + "def get_conus_states() -> dict[str, EEGeometry]:\n", + " states = ee.FeatureCollection(GEE_TIGER_STATES).filter(\n", + " ee.Filter.inList('STATEFP', list(EXCLUDED_STATEFP)).Not()\n", + " )\n", + " feats = states.getInfo()['features']\n", + " return {f['properties']['NAME']: f['geometry'] for f in feats}\n", + "\n", + "\n", + "def cached_per_state(\n", + " cache_path: Path,\n", + " states: list[str],\n", + " state_geoms: dict[str, EEGeometry],\n", + " compute_fn,\n", + ") -> list[dict[str, Any]]:\n", + " \"\"\"Run compute_fn(state, geometry) for each state, caching to a JSONL file.\"\"\"\n", + " cache_path.parent.mkdir(parents=True, exist_ok=True)\n", + " cached: dict[str, dict[str, Any]] = {}\n", + " if cache_path.exists():\n", + " with cache_path.open() as f:\n", + " for line in f:\n", + " line = line.strip()\n", + " if line:\n", + " r = json.loads(line)\n", + " cached[r['state']] = r\n", + "\n", + " results: list[dict[str, Any]] = []\n", + " with cache_path.open('a') as f:\n", + " for s in states:\n", + " if s in cached:\n", + " results.append(cached[s])\n", + " continue\n", + " logger.info(f'Computing {s} -> {cache_path.name}')\n", + " r = compute_fn(s, state_geoms[s])\n", + " r = {'state': s, **r}\n", + " f.write(json.dumps(r) + '\\n'); f.flush()\n", + " results.append(r)\n", + " results.sort(key=lambda r: r['state'])\n", + " return results" + ] + }, + { + "cell_type": "markdown", + "id": "59ebe389", + "metadata": {}, + "source": [ + "## 1. CONUS confusion matrix: CDL 2020 row crop × GLAD GLC 2020 cropland\n", + "\n", + "We compute the 2×2 confusion matrix per CONUS state, then sum to CONUS totals. **CDL row crop** = `CDL_ROWCROP_CODES` above (excludes hay and fallow). **GLAD GLC cropland** = pixel value 244 in the LCLUC v2 maps." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cd785ded", + "metadata": {}, + "outputs": [], + "source": [ + "# Confusion matrix encoding: cdl_rc * 2 + glc_crop -> 0..3\n", + "COMBO_KEYS_2x2 = {\n", + " 0: 'nonRC_glc_noncrop',\n", + " 1: 'nonRC_glc_crop',\n", + " 2: 'RC_glc_noncrop',\n", + " 3: 'RC_glc_crop',\n", + "}\n", + "\n", + "\n", + "def confusion_2x2_for_geom(geometry: EEGeometry) -> dict[str, float]:\n", + " cdl_mask = load_cdl_rowcrop_mask(CDL_YEAR, geometry)\n", + " glad_mask = load_glad_glc_crop_mask(GLAD_YEAR, geometry)\n", + " pixel_area_ha = ee.Image.pixelArea().divide(10000)\n", + " combo = cdl_mask.multiply(2).add(glad_mask).rename('combo')\n", + " result = pixel_area_ha.addBands(combo).reduceRegion(\n", + " reducer=ee.Reducer.sum().group(groupField=1, groupName='combo'),\n", + " geometry=geometry, scale=30, maxPixels=1e13, bestEffort=True,\n", + " )\n", + " groups = ee.List(result.get('groups')).getInfo()\n", + " areas = {v: 0.0 for v in COMBO_KEYS_2x2.values()}\n", + " for g in groups or []:\n", + " code = int(g['combo'])\n", + " if code in COMBO_KEYS_2x2:\n", + " areas[COMBO_KEYS_2x2[code]] = float(g['sum'])\n", + " return areas\n", + "\n", + "\n", + "def compute_state_confusion(state: str, geometry: EEGeometry) -> dict[str, float]:\n", + " if state in LARGE_STATES:\n", + " totals = {v: 0.0 for v in COMBO_KEYS_2x2.values()}\n", + " for tile in tile_geometry(geometry):\n", + " for k, v in confusion_2x2_for_geom(tile).items():\n", + " totals[k] += v\n", + " return totals\n", + " return confusion_2x2_for_geom(ee.Geometry(geometry))\n", + "\n", + "\n", + "state_geoms = get_conus_states()\n", + "all_states = sorted(state_geoms.keys())\n", + "\n", + "confusion_results = cached_per_state(\n", + " OUTPUT_DIR / 'cdl_rowcrop_glc_confusion.jsonl',\n", + " all_states, state_geoms, compute_state_confusion,\n", + ")\n", + "\n", + "df_conf = pd.DataFrame(confusion_results).set_index('state')\n", + "df_conf['rc_total'] = df_conf['RC_glc_crop'] + df_conf['RC_glc_noncrop']\n", + "df_conf['rc_confirm_pct'] = 100 * df_conf['RC_glc_crop'] / df_conf['rc_total']\n", + "\n", + "conus = df_conf[list(COMBO_KEYS_2x2.values())].sum()\n", + "rc_total = conus['RC_glc_crop'] + conus['RC_glc_noncrop']\n", + "ncrop_total = conus['nonRC_glc_crop'] + conus['nonRC_glc_noncrop']\n", + "glc_crop_total = conus['RC_glc_crop'] + conus['nonRC_glc_crop']\n", + "\n", + "summary = pd.DataFrame(\n", + " [[conus['RC_glc_crop'], conus['RC_glc_noncrop'], rc_total],\n", + " [conus['nonRC_glc_crop'], conus['nonRC_glc_noncrop'], ncrop_total],\n", + " [glc_crop_total, conus['RC_glc_noncrop'] + conus['nonRC_glc_noncrop'],\n", + " rc_total + ncrop_total]],\n", + " columns=['GLAD GLC cropland', 'GLAD GLC non-cropland', 'Total'],\n", + " index=['CDL row crop', 'CDL not row crop', 'Total'],\n", + ")\n", + "print('CONUS CDL 2020 row crop × GLAD GLC 2020 cropland (hectares):')\n", + "print(summary.applymap(lambda x: f'{x:>15,.0f}').to_string())\n", + "print(f'\\nGLC confirmation rate for CDL row crops: '\n", + " f'{100 * conus[\"RC_glc_crop\"] / rc_total:.1f}%')\n", + "print(f'CDL row crops not confirmed by GLC: '\n", + " f'{conus[\"RC_glc_noncrop\"]:,.0f} ha '\n", + " f'({100 * conus[\"RC_glc_noncrop\"] / rc_total:.1f}% of CDL row crop)')" + ] + }, + { + "cell_type": "markdown", + "id": "2ec6e77f", + "metadata": {}, + "source": [ + "## 2. Confirmation rate by region\n", + "\n", + "Disagreement is not uniform across the country. The Corn Belt and Great Plains have very high agreement (large fields are easy to classify); the Southeast and Northeast have substantially lower agreement (smaller, more fragmented fields)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cc41f46c", + "metadata": {}, + "outputs": [], + "source": [ + "REGIONS = {\n", + " 'Corn Belt (IA, IL, IN, NE, OH)': ['Iowa', 'Illinois', 'Indiana', 'Nebraska', 'Ohio'],\n", + " 'Great Plains (ND, SD, KS, MT)': ['North Dakota', 'South Dakota', 'Kansas', 'Montana'],\n", + " 'Southeast (AL, FL, GA, SC)': ['Alabama', 'Florida', 'Georgia', 'South Carolina'],\n", + " 'Northeast (CT, MA, RI, PA)': ['Connecticut', 'Massachusetts', 'Rhode Island', 'Pennsylvania'],\n", + "}\n", + "\n", + "rows = []\n", + "for region, members in REGIONS.items():\n", + " sub = df_conf.loc[df_conf.index.intersection(members)]\n", + " rc = sub['RC_glc_crop'].sum() + sub['RC_glc_noncrop'].sum()\n", + " confirm_pct = 100 * sub['RC_glc_crop'].sum() / rc if rc else 0\n", + " state_pcts = sub['rc_confirm_pct'].sort_values()\n", + " rows.append({\n", + " 'region': region,\n", + " 'rc_total_ha': int(rc),\n", + " 'confirm_pct_aggregate': f'{confirm_pct:.1f}%',\n", + " 'per_state_range': f'{state_pcts.min():.0f}–{state_pcts.max():.0f}%',\n", + " })\n", + "\n", + "print(pd.DataFrame(rows).to_string(index=False))" + ] + }, + { + "cell_type": "markdown", + "id": "e5325fec", + "metadata": {}, + "source": "## 3. Decomposing the lost CDL row crop pixels\n\nTo understand the emissions impact of the 9% disagreement pixels, we decompose the lost pixels into three cases on a 10-state agricultural sample (representative of the bulk of US row crop production):\n\n- **Case A** — GLAD GLC 2020 = cropland. Standard agreement; included in the methodology.\n- **Case B** — GLAD GLC 2020 ≠ cropland, but GLC class changed 2000→2020. GLC says a transition occurred but to a non-crop destination.\n- **Case C** — GLAD GLC 2020 ≠ cropland and GLC class is stable 2000→2020. CDL says row crop, GLC says it has never been crop.\n\nCase A is the everyday agreement. Case B and Case C together are the disagreement. Case C is the larger of the two, but a big chunk of it is built-up infrastructure that the methodology would not have generated emissions for anyway." + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9bc23f7a", + "metadata": {}, + "outputs": [], + "source": [ + "def case_abc_for_geom(geometry: EEGeometry) -> dict[str, Any]:\n", + " cdl_rc = load_cdl_rowcrop_mask(CDL_YEAR, geometry)\n", + " glc_2000_cat = classify_glad_glc(\n", + " ee.Image(GEE_GLAD_GLC_PREFIX + '2000').clip(geometry)\n", + " ).rename('glc2000')\n", + " glc_2020_cat = classify_glad_glc(\n", + " ee.Image(GEE_GLAD_GLC_PREFIX + '2020').clip(geometry)\n", + " ).rename('glc2020')\n", + " glc_2020_is_crop = glc_2020_cat.eq(6)\n", + " glc_changed = glc_2000_cat.neq(glc_2020_cat)\n", + " pixel_area_ha = ee.Image.pixelArea().divide(10000)\n", + " masked = pixel_area_ha.updateMask(cdl_rc)\n", + "\n", + " def _sum(mask: EEImage) -> float:\n", + " r = masked.updateMask(mask).reduceRegion(\n", + " reducer=ee.Reducer.sum(), geometry=geometry,\n", + " scale=30, maxPixels=1e13, bestEffort=True,\n", + " ).getInfo()\n", + " return float(r.get('area', 0) or 0)\n", + "\n", + " case_a = _sum(glc_2020_is_crop)\n", + " case_b_mask = glc_2020_is_crop.Not().And(glc_changed)\n", + " case_c_mask = glc_2020_is_crop.Not().And(glc_changed.Not())\n", + " case_b = _sum(case_b_mask)\n", + " case_c = _sum(case_c_mask)\n", + "\n", + " # Case B by GLC 2000 source x GLC 2020 destination (encoded src*10 + dst)\n", + " combo = glc_2000_cat.multiply(10).add(glc_2020_cat).rename('combo')\n", + " b_groups = (\n", + " masked.updateMask(case_b_mask)\n", + " .addBands(combo.updateMask(case_b_mask))\n", + " .reduceRegion(\n", + " reducer=ee.Reducer.sum().group(groupField=1, groupName='combo'),\n", + " geometry=geometry, scale=30, maxPixels=1e13, bestEffort=True,\n", + " )\n", + " )\n", + " case_b_breakdown: dict[str, float] = {}\n", + " for g in ee.List(b_groups.get('groups')).getInfo() or []:\n", + " c = int(g['combo'])\n", + " src = GLAD_CATEGORY_NAMES.get(c // 10, f'unk_{c // 10}')\n", + " dst = GLAD_CATEGORY_NAMES.get(c % 10, f'unk_{c % 10}')\n", + " case_b_breakdown[f'{src} -> {dst}'] = float(g['sum'])\n", + "\n", + " # Case C by GLC 2020 stable land cover\n", + " c_groups = (\n", + " masked.updateMask(case_c_mask)\n", + " .addBands(glc_2020_cat.updateMask(case_c_mask))\n", + " .reduceRegion(\n", + " reducer=ee.Reducer.sum().group(groupField=1, groupName='glc'),\n", + " geometry=geometry, scale=30, maxPixels=1e13, bestEffort=True,\n", + " )\n", + " )\n", + " case_c_breakdown: dict[str, float] = {}\n", + " for g in ee.List(c_groups.get('groups')).getInfo() or []:\n", + " name = GLAD_CATEGORY_NAMES.get(int(g['glc']), f\"unk_{int(g['glc'])}\")\n", + " case_c_breakdown[name] = float(g['sum'])\n", + "\n", + " return {\n", + " 'case_a': case_a, 'case_b': case_b, 'case_c': case_c,\n", + " 'case_b_breakdown': case_b_breakdown,\n", + " 'case_c_breakdown': case_c_breakdown,\n", + " }\n", + "\n", + "\n", + "def compute_state_abc(state: str, geometry: EEGeometry) -> dict[str, Any]:\n", + " if state in LARGE_STATES:\n", + " agg = {'case_a': 0.0, 'case_b': 0.0, 'case_c': 0.0,\n", + " 'case_b_breakdown': {}, 'case_c_breakdown': {}}\n", + " for tile in tile_geometry(geometry):\n", + " r = case_abc_for_geom(tile)\n", + " for k in ('case_a', 'case_b', 'case_c'):\n", + " agg[k] += r[k]\n", + " for k, v in r['case_b_breakdown'].items():\n", + " agg['case_b_breakdown'][k] = agg['case_b_breakdown'].get(k, 0.0) + v\n", + " for k, v in r['case_c_breakdown'].items():\n", + " agg['case_c_breakdown'][k] = agg['case_c_breakdown'].get(k, 0.0) + v\n", + " return agg\n", + " return case_abc_for_geom(ee.Geometry(geometry))\n", + "\n", + "\n", + "abc_results = cached_per_state(\n", + " OUTPUT_DIR / 'cdl_rowcrop_glc_case_abc.jsonl',\n", + " STATES_FOR_DEEP_DIVE, state_geoms, compute_state_abc,\n", + ")\n", + "\n", + "df_abc = pd.DataFrame([\n", + " {'state': r['state'], 'Case A (ha)': r['case_a'],\n", + " 'Case B (ha)': r['case_b'], 'Case C (ha)': r['case_c']}\n", + " for r in abc_results\n", + "])\n", + "df_abc['Total (ha)'] = df_abc[['Case A (ha)', 'Case B (ha)', 'Case C (ha)']].sum(axis=1)\n", + "for c in ('A', 'B', 'C'):\n", + " df_abc[f'{c}%'] = (100 * df_abc[f'Case {c} (ha)'] / df_abc['Total (ha)']).round(1)\n", + "\n", + "totals = {\n", + " 'state': '10-STATE TOTAL',\n", + " 'Case A (ha)': df_abc['Case A (ha)'].sum(),\n", + " 'Case B (ha)': df_abc['Case B (ha)'].sum(),\n", + " 'Case C (ha)': df_abc['Case C (ha)'].sum(),\n", + "}\n", + "totals['Total (ha)'] = totals['Case A (ha)'] + totals['Case B (ha)'] + totals['Case C (ha)']\n", + "for c in ('A', 'B', 'C'):\n", + " totals[f'{c}%'] = round(100 * totals[f'Case {c} (ha)'] / totals['Total (ha)'], 1)\n", + "df_abc = pd.concat([df_abc, pd.DataFrame([totals])], ignore_index=True)\n", + "\n", + "print(df_abc.to_string(index=False, formatters={\n", + " 'Case A (ha)': lambda x: f'{x:>14,.0f}',\n", + " 'Case B (ha)': lambda x: f'{x:>14,.0f}',\n", + " 'Case C (ha)': lambda x: f'{x:>14,.0f}',\n", + " 'Total (ha)': lambda x: f'{x:>14,.0f}',\n", + "}))" + ] + }, + { + "cell_type": "markdown", + "id": "3279ca8d", + "metadata": {}, + "source": "### 3a. Case B: source → destination breakdown\n\nFor Case B pixels, GLAD GLC saw a transition between 2000 and 2020 — but the destination was not classified as cropland. We aggregate the 10-state Case B totals by GLC 2000 source and GLC 2020 destination class. The dominant category is pixels GLC saw as cropland in 2000 and reclassified to non-cropland by 2020.\n\nGenuine emissions-relevant transitions (forest → non-crop, short vegetation → non-crop, wetland → non-crop) sum to a small fraction of total disagreement." + }, + { + "cell_type": "code", + "execution_count": null, + "id": "12f9f64c", + "metadata": {}, + "outputs": [], + "source": [ + "case_b_combined: dict[str, float] = {}\n", + "for r in abc_results:\n", + " for k, v in r['case_b_breakdown'].items():\n", + " case_b_combined[k] = case_b_combined.get(k, 0.0) + v\n", + "\n", + "total_disagreement = sum(r['case_b'] + r['case_c'] for r in abc_results)\n", + "\n", + "# Aggregate to source-only buckets matching Appendix 1 framing\n", + "# (destination is non-cropland by construction, so we summarize by source)\n", + "SOURCE_BUCKETS = {\n", + " 'cropland': 'Cropland',\n", + " 'short_veg': 'Short veg',\n", + " 'forest': 'Forest',\n", + " 'wetland_short_veg': 'Wetland',\n", + " 'wetland_forest': 'Wetland',\n", + "}\n", + "by_source: dict[str, float] = {}\n", + "for transition, area in case_b_combined.items():\n", + " src = transition.split(' -> ')[0]\n", + " label = SOURCE_BUCKETS.get(src, 'Water/bare/other')\n", + " by_source[label] = by_source.get(label, 0.0) + area\n", + "\n", + "rows = []\n", + "for label in ('Cropland', 'Short veg', 'Forest', 'Wetland', 'Water/bare/other'):\n", + " area = by_source.get(label, 0.0)\n", + " rows.append({\n", + " 'GLC 2000 source -> GLC 2020 destination (non-cropland)': f'{label} -> non-cropland',\n", + " 'Area (ha)': int(area),\n", + " '% of disagreement': f'{100 * area / total_disagreement:.1f}%',\n", + " })\n", + "print(pd.DataFrame(rows).to_string(index=False))\n", + "\n", + "print('\\nTop individual src->dst transitions in Case B:')\n", + "for k in sorted(case_b_combined, key=case_b_combined.get, reverse=True)[:10]:\n", + " print(f' {k:<40} {case_b_combined[k]:>14,.0f} ha')" + ] + }, + { + "cell_type": "markdown", + "id": "c43068bb", + "metadata": {}, + "source": [ + "### 3b. Case C: stable GLC land cover breakdown\n", + "\n", + "For Case C pixels, GLC sees the pixel as the same non-cropland class in 2000 and 2020. CDL says row crop; GLC says it has been something other than cropland for the whole study period. The dominant component (~44%) is **stable built-up** — small structures, farmsteads, grain bins, paved infrastructure. The next biggest is **stable short vegetation** (~30%) — perhaps grassed field margins, hayfields with crop edges, and CRP land that CDL is calling row crop too aggressively." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e1772ca2", + "metadata": {}, + "outputs": [], + "source": [ + "case_c_combined: dict[str, float] = {}\n", + "for r in abc_results:\n", + " for k, v in r['case_c_breakdown'].items():\n", + " case_c_combined[k] = case_c_combined.get(k, 0.0) + v\n", + "\n", + "DEST_BUCKETS = {\n", + " 'built_up': 'Built-up',\n", + " 'short_veg': 'Short vegetation',\n", + " 'forest': 'Forest',\n", + " 'wetland_short_veg': 'Wetland',\n", + " 'wetland_forest': 'Wetland',\n", + "}\n", + "by_dest: dict[str, float] = {}\n", + "for cls, area in case_c_combined.items():\n", + " label = DEST_BUCKETS.get(cls, 'Water/bare/other')\n", + " by_dest[label] = by_dest.get(label, 0.0) + area\n", + "\n", + "rows = []\n", + "for label in ('Built-up', 'Short vegetation', 'Forest', 'Wetland', 'Water/bare/other'):\n", + " area = by_dest.get(label, 0.0)\n", + " rows.append({\n", + " 'GLC 2020 class (stable since 2000)': label,\n", + " 'Area (ha)': int(area),\n", + " '% of disagreement': f'{100 * area / total_disagreement:.1f}%',\n", + " })\n", + "print(pd.DataFrame(rows).to_string(index=False))" + ] + }, + { + "cell_type": "markdown", + "id": "b31214c5", + "metadata": {}, + "source": "## 4. Why row crops only (not the full CDL crop class)\n\nCDL distinguishes row crops, hay/alfalfa, and fallow/idle within its broader \"crop\" universe. An earlier version of this analysis used the full CDL crop class and saw very poor agreement with GLAD over time:\n\n- **Row crops:** ~95% confirmed by GLAD\n- **Hay/alfalfa:** only ~56% confirmed\n- **Fallow/idle:** ~83% confirmed but flickers heavily year-to-year\n\nOver 2011–2019, CDL reported 11.3 M ha of net cropland expansion, but GLAD only 4.2 M ha — a 2.7× gap. Decomposing CDL's expansion shows that **75% of the difference comes from hay/fallow churn**, not row crop change:\n\n| CDL category | 2011 (ha) | 2019 (ha) | Net (ha) | % of CDL expansion |\n|---|---:|---:|---:|---:|\n| Row crop | 102,951,573 | 105,820,139 | +2,868,566 | 25.5% |\n| Hay/alfalfa | 16,512,494 | 21,517,515 | +5,005,021 | 44.5% |\n| Fallow | 10,599,070 | 13,976,681 | +3,377,611 | 30.0% |\n\nRow crop expansion alone is reasonably close to GLAD's signal.\n\nThe full code to reproduce this analysis (including state-level breakdown of hay reclassification in the Southeast and ranching states, and fallow flicker in the Great Plains) is preserved below for completeness; results are cached to `output/cdl_glad_expansion.jsonl`." + }, + { + "cell_type": "code", + "execution_count": null, + "id": "548d8111", + "metadata": {}, + "outputs": [], + "source": [ + "from jdluc.utils.constants import GEE_GLAD_CROPLAND_PREFIX\n", + "\n", + "EXPANSION_START_YEAR = 2011\n", + "EXPANSION_END_YEAR = 2019\n", + "\n", + "# 8-cell encoding: cdl_category * 2 + glad_binary\n", + "EXPANSION_KEYS = {\n", + " 0: 'noncrop_glad_noncrop', 1: 'noncrop_glad_crop',\n", + " 2: 'rowcrop_glad_noncrop', 3: 'rowcrop_glad_crop',\n", + " 4: 'hay_glad_noncrop', 5: 'hay_glad_crop',\n", + " 6: 'fallow_glad_noncrop', 7: 'fallow_glad_crop',\n", + "}\n", + "\n", + "\n", + "def load_cdl_4cat(year: int, geometry: EEGeometry) -> EEImage:\n", + " \"\"\"CDL as 0=non-crop, 1=row crop, 2=hay, 3=fallow.\"\"\"\n", + " cdl = (\n", + " ee.ImageCollection(GEE_CDL_COLLECTION)\n", + " .filter(ee.Filter.calendarRange(year, year, 'year'))\n", + " .first().select('cropland').clip(geometry)\n", + " )\n", + " codes = CDL_ROWCROP_CODES + CDL_HAY_CODES + CDL_FALLOW_CODES\n", + " vals = ([1] * len(CDL_ROWCROP_CODES)\n", + " + [2] * len(CDL_HAY_CODES)\n", + " + [3] * len(CDL_FALLOW_CODES))\n", + " return cdl.remap(codes, vals, defaultValue=0).rename('cdl_cat')\n", + "\n", + "\n", + "def load_glad_binary_crop_mask(year: int, geometry: EEGeometry) -> EEImage:\n", + " \"\"\"GLAD binary cropland mask (Potapov 30m). Different asset from GLC LCLUC.\"\"\"\n", + " return (\n", + " ee.ImageCollection(GEE_GLAD_CROPLAND_PREFIX + str(year))\n", + " .mosaic().clip(geometry).eq(1).rename('glad_crop')\n", + " )\n", + "\n", + "\n", + "def expansion_confusion_for_geom(geometry: EEGeometry, year: int) -> dict[str, float]:\n", + " cdl_cat = load_cdl_4cat(year, geometry)\n", + " glad = load_glad_binary_crop_mask(year, geometry)\n", + " pixel_area_ha = ee.Image.pixelArea().divide(10000)\n", + " combo = cdl_cat.multiply(2).add(glad).rename('combo')\n", + " result = pixel_area_ha.addBands(combo).reduceRegion(\n", + " reducer=ee.Reducer.sum().group(groupField=1, groupName='combo'),\n", + " geometry=geometry, scale=30, maxPixels=1e13, bestEffort=True,\n", + " )\n", + " areas = {v: 0.0 for v in EXPANSION_KEYS.values()}\n", + " for g in ee.List(result.get('groups')).getInfo() or []:\n", + " code = int(g['combo'])\n", + " if code in EXPANSION_KEYS:\n", + " areas[EXPANSION_KEYS[code]] = float(g['sum'])\n", + " return areas\n", + "\n", + "\n", + "def compute_state_expansion(state: str, geometry: EEGeometry) -> dict[str, Any]:\n", + " def _both_years(geom):\n", + " return {\n", + " 'start': expansion_confusion_for_geom(geom, EXPANSION_START_YEAR),\n", + " 'end': expansion_confusion_for_geom(geom, EXPANSION_END_YEAR),\n", + " }\n", + " if state in LARGE_STATES:\n", + " agg_s = {v: 0.0 for v in EXPANSION_KEYS.values()}\n", + " agg_e = dict(agg_s)\n", + " for tile in tile_geometry(geometry):\n", + " r = _both_years(tile)\n", + " for k, v in r['start'].items(): agg_s[k] += v\n", + " for k, v in r['end'].items(): agg_e[k] += v\n", + " return {'start': agg_s, 'end': agg_e}\n", + " return _both_years(ee.Geometry(geometry))\n", + "\n", + "\n", + "# Uncomment to run the historical expansion analysis (~1-2 hours of GEE).\n", + "# expansion_results = cached_per_state(\n", + "# OUTPUT_DIR / 'cdl_glad_expansion.jsonl',\n", + "# all_states, state_geoms, compute_state_expansion,\n", + "# )" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "pygments_lexer": "ipython3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/specs/analyses/peatland_emissions_modeling.ipynb b/specs/analyses/peatland_emissions_modeling.ipynb new file mode 100644 index 0000000..cbc5405 --- /dev/null +++ b/specs/analyses/peatland_emissions_modeling.ipynb @@ -0,0 +1,896 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Peatland GHGP FIT\n", + "\n", + "Fits a time-series decay to Qiu et al. (2021), Swails et al. (2022), and IPCC data points, then parameterizes a GHGP LUC + LM model based on that curve" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.optimize import curve_fit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1a. Fit double exponential to Qiu et al. (2021)\n", + "\n", + "Pixel-measured data points from Figure S11B (boreal/temperate cultivated peatlands, t C ha⁻¹ yr⁻¹). The year-0 spike (~60 t C) is excluded as likely a numerical transient in the model initialization." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DOUBLE EXPONENTIAL + CONSTANT FIT:\n", + " A_fast = 100.5 t CO₂ (half-life = 0.9 yr) ±6.6\n", + " k_fast = 0.7693 yr⁻¹ ±0.0774\n", + " A_slow = 91.1 t CO₂ (half-life = 19.3 yr) ±1.4\n", + " k_slow = 0.03588 yr⁻¹ ±0.00150\n", + " C = 0.94 t CO₂ (0.26 t C) ±1.01\n", + " E(0) = 192.5 t CO₂ ha⁻¹ yr⁻¹ (52.5 t C)\n", + " R² = 0.999434\n", + "\n", + " Year Qiu (tC) Fit (tC) % error\n", + "----------------------------------------\n", + " 1.0 36.86 36.86 0.0%\n", + " 3.0 25.32 25.27 -0.2%\n", + " 6.0 20.37 20.56 0.9%\n", + " 10.1 17.78 17.58 -1.1%\n", + " 15.0 14.42 14.75 2.3%\n", + " 20.0 12.56 12.38 -1.5%\n", + " 25.1 10.62 10.35 -2.5%\n", + " 30.0 8.68 8.72 0.4%\n", + " 35.0 7.42 7.33 -1.2%\n", + " 40.1 6.42 6.14 -4.2%\n", + " 50.1 3.94 4.37 10.9%\n", + " 60.0 2.73 3.14 15.1%\n", + " 70.2 2.27 2.25 -0.8%\n", + " 79.9 1.70 1.67 -2.1%\n", + " 100.0 1.23 0.94 -23.3%\n" + ] + } + ], + "source": [ + "# Qiu et al. pixel-measured data points from Figure S11B\n", + "# Units: t C ha⁻¹ yr⁻¹\n", + "t_data = np.array([1.005, 3.005, 6.003, 10.064, 15.022, 20.000, 25.095,\n", + " 30.019, 35.014, 40.132, 50.095, 59.995, 70.235, 79.932, 99.986])\n", + "E_data_tC = np.array([36.857, 25.317, 20.367, 17.784, 14.422, 12.561, 10.616,\n", + " 8.684, 7.420, 6.415, 3.943, 2.730, 2.273, 1.704, 1.230])\n", + "E_data = E_data_tC * 3.667 # convert to t CO₂ ha⁻¹ yr⁻¹\n", + "\n", + "\n", + "def double_exp_const(t, A_fast, k_fast, A_slow, k_slow, C):\n", + " \"\"\"Two exponential pools (active + slow) plus a constant (passive pool).\"\"\"\n", + " return A_fast * np.exp(-k_fast * t) + A_slow * np.exp(-k_slow * t) + C\n", + "\n", + "\n", + "# Fit: two exponentials + constant\n", + "p0 = [100, 0.7, 80, 0.03, 5]\n", + "bounds = ([0, 0.05, 0, 0.001, 0], [500, 2.0, 200, 0.1, 30])\n", + "popt, pcov = curve_fit(double_exp_const, t_data, E_data, p0=p0, bounds=bounds)\n", + "A_fast, k_fast, A_slow, k_slow, C = popt\n", + "perr = np.sqrt(np.diag(pcov))\n", + "resid = E_data - double_exp_const(t_data, *popt)\n", + "r2 = 1 - np.sum(resid**2) / np.sum((E_data - E_data.mean())**2)\n", + "\n", + "print(f\"DOUBLE EXPONENTIAL + CONSTANT FIT:\")\n", + "print(f\" A_fast = {A_fast:.1f} t CO₂ (half-life = {np.log(2)/k_fast:.1f} yr) ±{perr[0]:.1f}\")\n", + "print(f\" k_fast = {k_fast:.4f} yr⁻¹ ±{perr[1]:.4f}\")\n", + "print(f\" A_slow = {A_slow:.1f} t CO₂ (half-life = {np.log(2)/k_slow:.1f} yr) ±{perr[2]:.1f}\")\n", + "print(f\" k_slow = {k_slow:.5f} yr⁻¹ ±{perr[3]:.5f}\")\n", + "print(f\" C = {C:.2f} t CO₂ ({C/3.667:.2f} t C) ±{perr[4]:.2f}\")\n", + "print(f\" E(0) = {A_fast + A_slow + C:.1f} t CO₂ ha⁻¹ yr⁻¹ ({(A_fast + A_slow + C)/3.667:.1f} t C)\")\n", + "print(f\" R² = {r2:.6f}\")\n", + "\n", + "# Residuals table\n", + "print(f\"\\n{'Year':>6} {'Qiu (tC)':>10} {'Fit (tC)':>10} {'% error':>10}\")\n", + "print(\"-\" * 40)\n", + "for t, E_tC in zip(t_data, E_data_tC):\n", + " E_fit_tC = double_exp_const(t, *popt) / 3.667\n", + " print(f\"{t:6.1f} {E_tC:10.2f} {E_fit_tC:10.2f} {(E_fit_tC - E_tC)/E_tC*100:9.1f}%\")\n", + "\n", + "model_func = double_exp_const" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot fit vs data (t CO₂)\n", + "t_smooth = np.linspace(0.5, 110, 500)\n", + "E_fit = double_exp_const(t_smooth, *popt)\n", + "E_fast_curve = A_fast * np.exp(-k_fast * t_smooth)\n", + "E_slow_curve = A_slow * np.exp(-k_slow * t_smooth)\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 6))\n", + "ax.scatter(t_data, E_data, color='black', s=60, zorder=5, label='Qiu et al. (2021) fig S11')\n", + "ax.plot(t_smooth, E_fit, 'b-', linewidth=2, label=f'Double exp + constant (R²={r2:.4f})')\n", + "ax.plot(t_smooth, E_fast_curve, 'r--', alpha=0.5, label=f'Fast pool (half-life {np.log(2)/k_fast:.1f} yr)')\n", + "ax.plot(t_smooth, E_slow_curve, 'g--', alpha=0.5, label=f'Slow pool (half-life {np.log(2)/k_slow:.1f} yr)')\n", + "ax.axhline(y=C, color='gray', linestyle=':', alpha=0.5, label=f'Passive pool constant ({C:.1f} t CO₂ = {C/3.667:.1f} t C)')\n", + "ax.set_xlabel('Years since drainage', fontsize=12)\n", + "ax.set_ylabel('CO₂ emissions (t CO₂ ha⁻¹ yr⁻¹)', fontsize=12)\n", + "ax.set_title('Double Exponential + Constant Fit to Qiu et al. (2021) Fig. S11', fontsize=13)\n", + "ax.legend(fontsize=10)\n", + "ax.set_xlim(0, 110)\n", + "ax.set_ylim(0, 160)\n", + "ax.grid(True, alpha=0.3)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Overlay plot matching Qiu et al. Fig S11B axes exactly (t C, calendar years)\n", + "fig, ax = plt.subplots(figsize=(10, 5))\n", + "ax.plot(1900 + t_smooth, E_fit / 3.667, 'b-', linewidth=2, label='Double exponential fit')\n", + "ax.scatter(1900 + t_data, E_data_tC, color='red', s=40, zorder=5, label='Pixel-measured data points')\n", + "ax.set_xlabel('Year (conversion in 1900)', fontsize=12)\n", + "ax.set_ylabel('Emission rates\\n(tC ha⁻¹ yr⁻¹)', fontsize=12)\n", + "ax.set_title('Our fit overlaid on Qiu et al. Fig S11B axes', fontsize=13)\n", + "ax.set_xlim(1900, 2010)\n", + "ax.set_ylim(0, 45)\n", + "ax.set_xticks([1900, 1920, 1940, 1960, 1980, 2000])\n", + "ax.legend(fontsize=10)\n", + "ax.grid(True, alpha=0.3)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1b. Fit double exponential to Swails et al. (2022)\n", + "\n", + "Swails et al. used the DNDC model to simulate tropical oil palm peatland emissions over 30 years. Data extracted from the main figure (Mg C ha⁻¹ yr⁻¹). Note this is **net** of vegetation C inputs, so values are lower than the Qiu gross decomposition curve." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SWAILS DOUBLE EXPONENTIAL + CONSTANT FIT:\n", + " A_fast = 36.3 t CO₂ (half-life = 0.8 yr) ±5.5\n", + " k_fast = 0.8819 yr⁻¹ ±0.3076\n", + " A_slow = 41.8 t CO₂ (half-life = 5.4 yr) ±4.9\n", + " k_slow = 0.12794 yr⁻¹ ±0.02145\n", + " C = 4.93 t CO₂ (1.34 t C) ±1.04\n", + " E(0) = 83.1 t CO₂ ha⁻¹ yr⁻¹ (22.7 t C)\n", + " R² = 0.998682\n", + "\n", + " Year Swails (tC) Fit (tC) % error\n", + "------------------------------------------\n", + " 1.0 15.53 15.52 -0.1%\n", + " 2.0 11.72 11.76 0.4%\n", + " 3.0 9.83 9.83 -0.1%\n", + " 5.0 7.63 7.48 -2.0%\n", + " 7.0 5.93 5.99 1.0%\n", + " 10.0 4.28 4.51 5.4%\n", + " 15.1 3.04 3.00 -1.1%\n", + " 20.1 2.48 2.22 -10.3%\n", + " 25.1 1.98 1.80 -8.7%\n", + " 30.1 1.29 1.59 23.3%\n" + ] + } + ], + "source": [ + "# Swails et al. (2022) data from main figure\n", + "# Units: Mg C ha⁻¹ yr⁻¹ (= t C ha⁻¹ yr⁻¹)\n", + "t_swails = np.array([0.992, 2.042, 2.992, 5.002, 7.047, 10.029, 15.065, 20.054, 25.091, 30.070])\n", + "E_swails_tC = np.array([15.529, 11.717, 9.834, 7.628, 5.933, 4.276, 3.036, 2.475, 1.976, 1.288])\n", + "E_swails = E_swails_tC * 3.667 # convert to t CO₂ ha⁻¹ yr⁻¹\n", + "\n", + "# Fit double exponential + constant\n", + "p0_sw = [40, 0.5, 20, 0.05, 3]\n", + "bounds_sw = ([0, 0.05, 0, 0.001, 0], [200, 2.0, 100, 0.5, 20])\n", + "popt_sw, pcov_sw = curve_fit(double_exp_const, t_swails, E_swails, p0=p0_sw, bounds=bounds_sw)\n", + "A_f_sw, k_f_sw, A_s_sw, k_s_sw, C_sw = popt_sw\n", + "perr_sw = np.sqrt(np.diag(pcov_sw))\n", + "resid_sw = E_swails - double_exp_const(t_swails, *popt_sw)\n", + "r2_sw = 1 - np.sum(resid_sw**2) / np.sum((E_swails - E_swails.mean())**2)\n", + "\n", + "print(f\"SWAILS DOUBLE EXPONENTIAL + CONSTANT FIT:\")\n", + "print(f\" A_fast = {A_f_sw:.1f} t CO₂ (half-life = {np.log(2)/k_f_sw:.1f} yr) ±{perr_sw[0]:.1f}\")\n", + "print(f\" k_fast = {k_f_sw:.4f} yr⁻¹ ±{perr_sw[1]:.4f}\")\n", + "print(f\" A_slow = {A_s_sw:.1f} t CO₂ (half-life = {np.log(2)/k_s_sw:.1f} yr) ±{perr_sw[2]:.1f}\")\n", + "print(f\" k_slow = {k_s_sw:.5f} yr⁻¹ ±{perr_sw[3]:.5f}\")\n", + "print(f\" C = {C_sw:.2f} t CO₂ ({C_sw/3.667:.2f} t C) ±{perr_sw[4]:.2f}\")\n", + "print(f\" E(0) = {A_f_sw + A_s_sw + C_sw:.1f} t CO₂ ha⁻¹ yr⁻¹ ({(A_f_sw + A_s_sw + C_sw)/3.667:.1f} t C)\")\n", + "print(f\" R² = {r2_sw:.6f}\")\n", + "\n", + "print(f\"\\n{'Year':>6} {'Swails (tC)':>12} {'Fit (tC)':>10} {'% error':>10}\")\n", + "print(\"-\" * 42)\n", + "for t, E_tC in zip(t_swails, E_swails_tC):\n", + " E_fit_tC = double_exp_const(t, *popt_sw) / 3.667\n", + " print(f\"{t:6.1f} {E_tC:12.2f} {E_fit_tC:10.2f} {(E_fit_tC - E_tC)/E_tC*100:9.1f}%\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot fit vs data (t CO₂) — matching Section 1a style\n", + "t_smooth = np.linspace(0.5, 110, 500)\n", + "E_fit_sw = double_exp_const(t_smooth, *popt_sw)\n", + "E_fast_sw = A_f_sw * np.exp(-k_f_sw * t_smooth)\n", + "E_slow_sw = A_s_sw * np.exp(-k_s_sw * t_smooth)\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 6))\n", + "ax.scatter(t_swails, E_swails, color='black', s=60, zorder=5, label='Swails et al. (2022) main fig')\n", + "ax.plot(t_smooth, E_fit_sw, 'b-', linewidth=2, label=f'Double exp + constant (R²={r2_sw:.4f})')\n", + "ax.plot(t_smooth, E_fast_sw, 'r--', alpha=0.5, label=f'Fast pool (half-life {np.log(2)/k_f_sw:.1f} yr)')\n", + "ax.plot(t_smooth, E_slow_sw, 'g--', alpha=0.5, label=f'Slow pool (half-life {np.log(2)/k_s_sw:.1f} yr)')\n", + "ax.axhline(y=C_sw, color='gray', linestyle=':', alpha=0.5, label=f'Passive pool constant ({C_sw:.1f} t CO₂ = {C_sw/3.667:.1f} t C)')\n", + "ax.set_xlabel('Years since drainage', fontsize=12)\n", + "ax.set_ylabel('CO₂ emissions (t CO₂ ha⁻¹ yr⁻¹)', fontsize=12)\n", + "ax.set_title('Double Exponential + Constant Fit to Swails et al. (2022)', fontsize=13)\n", + "ax.legend(fontsize=10)\n", + "ax.set_xlim(0, 110)\n", + "ax.set_ylim(0, 160)\n", + "ax.grid(True, alpha=0.3)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "## 2. Fit reference CO₂ curve based on the two papers + IPCC EFs" + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Swails scale factor: 2.43x\n", + " Raw Swails at year 10: 16.6\n", + " Scaled Swails at year 10: 40.3\n", + "\n", + "BLENDED REFERENCE CURVE FIT:\n", + " A_fast = 95.7 t CO₂ (half-life = 0.7 yr)\n", + " k_fast = 1.0214 yr⁻¹\n", + " A_slow = 83.4 t CO₂ (half-life = 5.4 yr)\n", + " k_slow = 0.12905 yr⁻¹\n", + " C = 29.0 t CO₂ (fixed: IPCC floor)\n", + " E(0) = 208.1 t CO₂\n", + " R² = 0.999938\n", + "\n", + " Year Qiu Scaled Avg Blended\n", + "------------------------------------------\n", + " 1 135.4 138.1 136.7 136.7\n", + " 3 92.7 87.6 90.1 90.1\n", + " 5 79.2 66.7 73.0 73.3\n", + " 7 72.3 53.7 63.0 62.8\n", + " 10 64.6 40.3 52.5 51.9\n", + " 15 54.1 26.9 40.5 41.0\n", + " 20 45.4 19.9 32.6 35.3\n", + " 25 38.1 16.1 27.1 32.3\n", + " 30 32.0 14.2 23.1 30.7\n", + " 40 22.6 12.6 17.6 29.5\n", + " 50 16.1 12.2 14.1 29.1\n", + " 75 7.1 12.0 9.6 29.0\n", + " 100 3.5 12.0 7.7 29.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Build a blended reference curve by fitting a new double_exp_const to synthetic targets\n", + "\n", + "# IPCC CO₂ floor: temperate/boreal cropland value\n", + "# (pasture values are lower, but recent evidence undermines the case for lower\n", + "# emissions on grassland, so we use the cropland value as steady state)\n", + "IPCC_FLOOR = 29.0 # t CO₂ ha⁻¹ yr⁻¹\n", + "\n", + "# Scale Swails to match IPCC oil palm CO₂ at calibration age.\n", + "# The raw Swails curve measures net emissions (after vegetation carbon offsets),\n", + "# which systematically underestimates peat decomposition. Scaling to match the\n", + "# IPCC oil palm empirical value corrects for this while preserving the model's\n", + "# decay shape.\n", + "IPCC_OIL_PALM_CO2 = 40.3\n", + "SWAILS_CALIB_YR = 10 # IPCC oil palm sites have median age under 10 yr (Swails et al.)\n", + "swails_scale = IPCC_OIL_PALM_CO2 / double_exp_const(SWAILS_CALIB_YR, *popt_sw)\n", + "\n", + "def scaled_swails(t):\n", + " return double_exp_const(t, *popt_sw) * swails_scale\n", + "\n", + "print(f\"Swails scale factor: {swails_scale:.2f}x\")\n", + "print(f\" Raw Swails at year {SWAILS_CALIB_YR}: {double_exp_const(SWAILS_CALIB_YR, *popt_sw):.1f}\")\n", + "print(f\" Scaled Swails at year {SWAILS_CALIB_YR}: {scaled_swails(SWAILS_CALIB_YR):.1f}\")\n", + "\n", + "# Synthetic target points:\n", + "# Early years: average of Qiu and scaled Swails (model-driven)\n", + "t_early = np.array([1, 3, 5, 7, 10, 15])\n", + "E_early = np.array([(double_exp_const(t, *popt) + scaled_swails(t)) / 2\n", + " for t in t_early])\n", + "\n", + "# Late years: IPCC empirical floor\n", + "t_late = np.array([50, 60, 75, 100])\n", + "E_late = np.full_like(t_late, IPCC_FLOOR, dtype=float)\n", + "\n", + "# Combine and fit\n", + "t_targets = np.concatenate([t_early, t_late])\n", + "E_targets = np.concatenate([E_early, E_late])\n", + "\n", + "def double_exp_fixed_C(t, A_fast, k_fast, A_slow, k_slow):\n", + " return A_fast * np.exp(-k_fast * t) + A_slow * np.exp(-k_slow * t) + IPCC_FLOOR\n", + "\n", + "p0_blend = [60, 0.5, 30, 0.04]\n", + "bounds_blend = ([0, 0.05, 0, 0.001], [300, 2.0, 200, 0.5])\n", + "popt_blend, pcov_blend = curve_fit(double_exp_fixed_C, t_targets, E_targets,\n", + " p0=p0_blend, bounds=bounds_blend)\n", + "A_f_b, k_f_b, A_s_b, k_s_b = popt_blend\n", + "\n", + "def blended_ref(t):\n", + " return A_f_b * np.exp(-k_f_b * t) + A_s_b * np.exp(-k_s_b * t) + IPCC_FLOOR\n", + "\n", + "# Fit quality\n", + "E_fit_targets = blended_ref(t_targets)\n", + "resid = E_fit_targets - E_targets\n", + "r2 = 1 - np.sum(resid**2) / np.sum((E_targets - E_targets.mean())**2)\n", + "\n", + "print(f\"\\nBLENDED REFERENCE CURVE FIT:\")\n", + "print(f\" A_fast = {A_f_b:.1f} t CO₂ (half-life = {np.log(2)/k_f_b:.1f} yr)\")\n", + "print(f\" k_fast = {k_f_b:.4f} yr⁻¹\")\n", + "print(f\" A_slow = {A_s_b:.1f} t CO₂ (half-life = {np.log(2)/k_s_b:.1f} yr)\")\n", + "print(f\" k_slow = {k_s_b:.5f} yr⁻¹\")\n", + "print(f\" C = {IPCC_FLOOR:.1f} t CO₂ (fixed: IPCC floor)\")\n", + "print(f\" E(0) = {A_f_b + A_s_b + IPCC_FLOOR:.1f} t CO₂\")\n", + "print(f\" R² = {r2:.6f}\")\n", + "\n", + "print(f\"\\n{'Year':>5} {'Qiu':>8} {'Scaled':>8} {'Avg':>8} {'Blended':>8}\")\n", + "print(\"-\" * 42)\n", + "for t in [1, 3, 5, 7, 10, 15, 20, 25, 30, 40, 50, 75, 100]:\n", + " eq = double_exp_const(t, *popt)\n", + " ess = scaled_swails(t)\n", + " eb = blended_ref(t)\n", + " print(f\"{t:5d} {eq:8.1f} {ess:8.1f} {(eq+ess)/2:8.1f} {eb:8.1f}\")\n", + "\n", + "# Plot\n", + "t_comp = np.linspace(0.5, 110, 500)\n", + "E_qiu_fit = double_exp_const(t_comp, *popt)\n", + "E_swails_fit = double_exp_const(t_comp, *popt_sw)\n", + "E_swails_scaled = scaled_swails(t_comp)\n", + "E_blended = blended_ref(t_comp)\n", + "\n", + "fig, ax = plt.subplots(figsize=(12, 7))\n", + "\n", + "ax.plot(t_comp, E_qiu_fit, 'b-', linewidth=1.5, alpha=0.4, label='Qiu et al. (boreal/temperate, gross)')\n", + "ax.plot(t_comp, E_swails_fit, 'r-', linewidth=1.5, alpha=0.2, label='Swails et al. (raw, net)')\n", + "ax.plot(t_comp, E_swails_scaled, 'r--', linewidth=1.5, alpha=0.4,\n", + " label=f'Swails et al. (\\u00d7{swails_scale:.1f}, matched to IPCC oil palm)')\n", + "ax.plot(t_comp, E_blended, 'k-', linewidth=2.5, label='Blended reference curve')\n", + "\n", + "# Data points (faded)\n", + "ax.scatter(t_data, E_data, color='blue', s=30, zorder=4, alpha=0.3)\n", + "ax.scatter(t_swails, E_swails, color='red', s=30, zorder=4, alpha=0.2)\n", + "\n", + "# IPCC CO₂ values at calibration site age ranges\n", + "ipcc_co2_lines = [\n", + " ('Tropical acacia (73.3)', 73.3, 5, 10, '#984ea3'),\n", + " ('Tropical cropland (51.3)', 51.3, 8, 15, '#ff7f00'),\n", + " ('Tropical oil palm (40.3)', 40.3, 5, 18, '#e41a1c'),\n", + " ('Bor/Temp cropland (29.0)', 29.0, 25, 100, '#377eb8'),\n", + " ('Temperate pasture (22.4)', 22.4, 50, 100, '#4daf4a'),\n", + " ('Boreal pasture (20.9)', 20.9, 35, 100, '#f781bf'),\n", + "]\n", + "\n", + "for label, val, t_min, t_max, color in ipcc_co2_lines:\n", + " ax.plot([t_min, t_max], [val, val], color=color, linestyle='-', linewidth=3, alpha=0.8)\n", + " ax.text(t_max + 1, val, label, fontsize=8, color=color, va='center')\n", + "\n", + "ax.set_xlabel('Years since drainage', fontsize=12)\n", + "ax.set_ylabel('CO₂ emissions (t CO₂ ha⁻¹ yr⁻¹)', fontsize=12)\n", + "ax.set_title('Blended Reference Curve with IPCC CO₂ Values (at calibration site ages)', fontsize=13)\n", + "ax.legend(fontsize=9, loc='upper right')\n", + "ax.set_xlim(0, 100)\n", + "ax.set_ylim(0, 150)\n", + "ax.grid(True, alpha=0.3)\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Adding non-CO₂ emissions\n", + "\n", + "Next we add non-CO₂ pathways — dissolved organic carbon (DOC), ditch CH₄, and soil N₂O. We construct a time-varying\n", + "non-CO₂ curve that blends smoothly from the tropical acacia value (5.3 t CO₂-eq ha⁻¹ yr⁻¹, calibrated on very young sites, ~5-10 yr) to the temperate cropland value (8.3 t CO₂-eq ha⁻¹ yr⁻¹, calibrated on older sites, ~25-50+ yr). \n", + "\n", + "We use a logistic blend:\n", + "```\n", + "non_CO₂(t) = E_early + (E_late - E_early) / (1 + exp(-k × (t - t_mid)))\n", + "```\n", + "with E_early = 5.3 (acacia), E_late = 8.3 (temperate cropland), t_mid = 25, and k = 0.2, giving near-constant values for years 1-10 and 40+, with a smooth transition in between." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Non-CO₂ blend values:\n", + " Year 1: 5.32 t CO₂-eq ha⁻¹ yr⁻¹\n", + " Year 5: 5.35 t CO₂-eq ha⁻¹ yr⁻¹\n", + " Year 10: 5.44 t CO₂-eq ha⁻¹ yr⁻¹\n", + " Year 15: 5.66 t CO₂-eq ha⁻¹ yr⁻¹\n", + " Year 20: 6.11 t CO₂-eq ha⁻¹ yr⁻¹\n", + " Year 25: 6.80 t CO₂-eq ha⁻¹ yr⁻¹\n", + " Year 30: 7.49 t CO₂-eq ha⁻¹ yr⁻¹\n", + " Year 40: 8.16 t CO₂-eq ha⁻¹ yr⁻¹\n", + " Year 50: 8.28 t CO₂-eq ha⁻¹ yr⁻¹\n", + " Year 75: 8.30 t CO₂-eq ha⁻¹ yr⁻¹\n", + " Year 100: 8.30 t CO₂-eq ha⁻¹ yr⁻¹\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# IPCC non-CO₂ values by land use (from Tables 2.3-2.5)\n", + "ipcc_non_co2 = {\n", + " 'Tropical oil palm': 4.7,\n", + " 'Tropical cropland': 6.5,\n", + " 'Tropical acacia': 5.3,\n", + " 'Temperate cropland': 8.3,\n", + " 'Temperate pasture': 6.6,\n", + " 'Boreal cropland': 7.6,\n", + " 'Boreal pasture': 6.1,\n", + "}\n", + "\n", + "# Anchor values: acacia (young sites) → temperate cropland (older sites)\n", + "NON_CO2_EARLY = ipcc_non_co2['Tropical acacia'] # 5.3\n", + "NON_CO2_LATE = ipcc_non_co2['Temperate cropland'] # 8.3\n", + "\n", + "# Logistic blend: ~constant at early value for t<10, ~constant at late value for t>40\n", + "def non_co2_blend(t):\n", + " \"\"\"Time-varying non-CO₂ emissions (t CO₂-eq ha⁻¹ yr⁻¹).\"\"\"\n", + " t = np.asarray(t, dtype=float)\n", + " k = 0.2\n", + " t_mid = 25.0\n", + " w = 1.0 / (1.0 + np.exp(-k * (t - t_mid)))\n", + " return NON_CO2_EARLY + (NON_CO2_LATE - NON_CO2_EARLY) * w\n", + "\n", + "# Show anchor check\n", + "print(f\"Non-CO₂ blend values:\")\n", + "for yr in [1, 5, 10, 15, 20, 25, 30, 40, 50, 75, 100]:\n", + " print(f\" Year {yr:3d}: {non_co2_blend(yr):.2f} t CO₂-eq ha⁻¹ yr⁻¹\")\n", + "\n", + "# Plot: all-GHG reference curve (CO₂ + time-varying non-CO₂)\n", + "t_plot3 = np.linspace(0.5, 110, 500)\n", + "E_co2 = blended_ref(t_plot3)\n", + "E_non_co2 = non_co2_blend(t_plot3)\n", + "E_all_ghg = E_co2 + E_non_co2\n", + "\n", + "fig, ax = plt.subplots(figsize=(12, 7))\n", + "\n", + "# Stacked area showing CO₂ and non-CO₂ contributions\n", + "ax.fill_between(t_plot3, 0, E_co2, alpha=0.15, color='blue', label='CO₂ from peat oxidation')\n", + "ax.fill_between(t_plot3, E_co2, E_all_ghg, alpha=0.15, color='orange', label='Non-CO₂ (DOC + CH₄ + N₂O)')\n", + "ax.plot(t_plot3, E_co2, 'b-', linewidth=1.5, alpha=0.6)\n", + "ax.plot(t_plot3, E_all_ghg, 'k-', linewidth=2.5, label='All-GHG reference curve')\n", + "\n", + "# IPCC total values at calibration site age ranges\n", + "ipcc_total_lines = [\n", + " ('Tropical acacia (78.6)', 78.6, 5, 10, '#984ea3'),\n", + " ('Tropical cropland (57.9)', 57.9, 8, 15, '#ff7f00'),\n", + " ('Tropical oil palm (45.0)', 45.0, 5, 18, '#e41a1c'),\n", + " ('Bor/Temp cropland (37.3)', 37.3, 25, 100, '#377eb8'),\n", + " ('Temperate pasture (29.0)', 29.0, 50, 100, '#4daf4a'),\n", + " ('Boreal pasture (27.0)', 27.0, 35, 100, '#f781bf'),\n", + "]\n", + "\n", + "for label, val, t_min, t_max, color in ipcc_total_lines:\n", + " ax.plot([t_min, t_max], [val, val], color=color, linestyle='-', linewidth=3, alpha=0.8)\n", + " ax.text(t_max + 1, val, label, fontsize=8, color=color, va='center')\n", + "\n", + "ax.set_xlabel('Years since drainage', fontsize=12)\n", + "ax.set_ylabel('Emissions (t CO₂-eq ha⁻¹ yr⁻¹)', fontsize=12)\n", + "ax.set_title('All-GHG Reference Curve: CO₂ + Time-Varying Non-CO₂', fontsize=13)\n", + "ax.legend(fontsize=10, loc='upper right')\n", + "ax.set_xlim(0, 100)\n", + "ax.set_ylim(0, 150)\n", + "ax.grid(True, alpha=0.3)\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": "## 4. Fit GHGP parameters (P_LUC and E_LM)\n\nFinally, we fit two GHGP parameters based on the full reference curve. The parameters (applied to all climate zones and land uses) are:\n- **P_LUC**: total excess CO₂ above E_LM integrated over 20 years\n- **E_LM**: reference curve CO₂ floor + long-run non-CO₂ from the blend" + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Universal GHGP parameters:\n", + " E_LM = 37.3 t CO₂-eq ha⁻¹ yr⁻¹ (= IPCC CO₂ floor 29.0 + long-run non-CO₂ 8.3)\n", + " P_LUC = 621 t CO₂ ha⁻¹ (least-squares fit to reference curve, years 1-20)\n", + " Non-CO₂ early (acacia) = 5.3 t CO₂-eq ha⁻¹ yr⁻¹\n", + " Non-CO₂ late (temp. cropland) = 8.3 t CO₂-eq ha⁻¹ yr⁻¹\n", + " IPCC CO₂ floor = 29.0 t CO₂ ha⁻¹ yr⁻¹\n", + "\n", + " RMSE over years 1-20: 13.7 t CO₂-eq ha⁻¹ yr⁻¹\n", + "\n", + " Year Ref curve GHGP model Residual\n", + "----------------------------------------\n", + " 1 142.1 96.4 -45.6\n", + " 2 111.1 93.5 -17.7\n", + " 3 95.4 90.5 -4.9\n", + " 4 85.7 87.6 1.9\n", + " 5 78.7 84.6 6.0\n", + " 6 73.0 81.7 8.7\n", + " 7 68.2 78.7 10.5\n", + " 8 64.1 75.7 11.6\n", + " 9 60.5 72.8 12.3\n", + " 10 57.4 69.8 12.4\n", + " 11 54.6 66.9 12.2\n", + " 12 52.2 63.9 11.7\n", + " 13 50.1 61.0 10.8\n", + " 14 48.3 58.0 9.7\n", + " 15 46.7 55.0 8.4\n", + " 16 45.3 52.1 6.8\n", + " 17 44.1 49.1 5.0\n", + " 18 43.1 46.2 3.1\n", + " 19 42.2 43.2 1.0\n", + " 20 41.4 40.3 -1.2\n", + "\n", + "Implied ages on blended reference curve:\n", + " Tropical oil palm CO₂= 40.3 → year 15.5\n", + " Tropical cropland CO₂= 51.3 → year 10.2\n", + " Tropical acacia CO₂= 73.3 → year 5.0\n", + " Temperate cropland CO₂= 29.0 → outside range\n", + " Temperate pasture CO₂= 22.4 → outside range\n", + " Boreal cropland CO₂= 29.0 → outside range\n", + " Boreal pasture CO₂= 20.9 → outside range\n", + "\n", + "Year 1 total: 96.4 t CO₂-eq ha⁻¹ yr⁻¹\n", + "Year 20 total: 40.3 t CO₂-eq ha⁻¹ yr⁻¹\n", + "Year 21+: 37.3 t CO₂-eq ha⁻¹ yr⁻¹\n" + ] + } + ], + "source": [ + "# IPCC Tier 1 values (CO₂ from Tables 2.1/2.2, non-CO₂ from Tables 2.3-2.5)\n", + "ipcc = {\n", + " 'Tropical oil palm': {'co2': 40.3, 'non_co2': 4.7, 'total': 45.0},\n", + " 'Tropical cropland': {'co2': 51.3, 'non_co2': 6.5, 'total': 57.9},\n", + " 'Tropical acacia': {'co2': 73.3, 'non_co2': 5.3, 'total': 78.6},\n", + " 'Temperate cropland': {'co2': 29.0, 'non_co2': 8.3, 'total': 37.3},\n", + " 'Temperate pasture': {'co2': 22.4, 'non_co2': 6.6, 'total': 29.0},\n", + " 'Boreal cropland': {'co2': 29.0, 'non_co2': 7.6, 'total': 36.6},\n", + " 'Boreal pasture': {'co2': 20.9, 'non_co2': 6.1, 'total': 27.0},\n", + "}\n", + "\n", + "# E_LM: CO₂ floor + long-run non-CO₂ (blend asymptote = temperate cropland non-CO₂)\n", + "E_LM = IPCC_FLOOR + NON_CO2_LATE\n", + "\n", + "# P_LUC: best fit to blended reference curve over years 1-20, given fixed E_LM\n", + "# GHGP model: E(t) = P_LUC * (21-t)/210 + E_LM for t=1..20\n", + "t_fit = np.arange(1, 21)\n", + "E_ref_fit = blended_ref(t_fit) + non_co2_blend(t_fit) # reference curve (all GHGs)\n", + "weights = (21 - t_fit) / 210 # linear ramp weights\n", + "\n", + "# Least-squares solution: P_LUC = Σ[(E_ref - E_LM) * w] / Σ[w²]\n", + "P_LUC = np.sum((E_ref_fit - E_LM) * weights) / np.sum(weights**2)\n", + "\n", + "print(f\"Universal GHGP parameters:\")\n", + "print(f\" E_LM = {E_LM:.1f} t CO₂-eq ha⁻¹ yr⁻¹ (= IPCC CO₂ floor {IPCC_FLOOR:.1f} + long-run non-CO₂ {NON_CO2_LATE})\")\n", + "print(f\" P_LUC = {P_LUC:.0f} t CO₂ ha⁻¹ (least-squares fit to reference curve, years 1-20)\")\n", + "print(f\" Non-CO₂ early (acacia) = {NON_CO2_EARLY} t CO₂-eq ha⁻¹ yr⁻¹\")\n", + "print(f\" Non-CO₂ late (temp. cropland) = {NON_CO2_LATE} t CO₂-eq ha⁻¹ yr⁻¹\")\n", + "print(f\" IPCC CO₂ floor = {IPCC_FLOOR:.1f} t CO₂ ha⁻¹ yr⁻¹\")\n", + "\n", + "# Show fit quality over years 1-20\n", + "E_ghgp_fit = P_LUC * weights + E_LM\n", + "residuals = E_ghgp_fit - E_ref_fit\n", + "rmse = np.sqrt(np.mean(residuals**2))\n", + "print(f\"\\n RMSE over years 1-20: {rmse:.1f} t CO₂-eq ha⁻¹ yr⁻¹\")\n", + "\n", + "print(f\"\\n{'Year':>5} {'Ref curve':>10} {'GHGP model':>12} {'Residual':>10}\")\n", + "print(\"-\" * 40)\n", + "for t, e_ref, e_ghgp in zip(t_fit, E_ref_fit, E_ghgp_fit):\n", + " print(f\"{t:5d} {e_ref:10.1f} {e_ghgp:12.1f} {e_ghgp - e_ref:10.1f}\")\n", + "\n", + "# Implied ages on blended curve for each IPCC CO₂ value\n", + "from scipy.optimize import brentq\n", + "print(f\"\\nImplied ages on blended reference curve:\")\n", + "for name, vals in ipcc.items():\n", + " try:\n", + " t_impl = brentq(lambda t: float(blended_ref(np.array([t]))[0]) - vals['co2'], 0.1, 200)\n", + " vals['implied_age'] = t_impl\n", + " print(f\" {name:<25} CO₂={vals['co2']:5.1f} → year {t_impl:.1f}\")\n", + " except:\n", + " vals['implied_age'] = None\n", + " print(f\" {name:<25} CO₂={vals['co2']:5.1f} → outside range\")\n", + "\n", + "# Summary\n", + "LUC_yr1 = P_LUC * 20 / 210\n", + "LUC_yr20 = P_LUC * 1 / 210\n", + "print(f\"\\nYear 1 total: {LUC_yr1 + E_LM:.1f} t CO₂-eq ha⁻¹ yr⁻¹\")\n", + "print(f\"Year 20 total: {LUC_yr20 + E_LM:.1f} t CO₂-eq ha⁻¹ yr⁻¹\")\n", + "print(f\"Year 21+: {E_LM:.1f} t CO₂-eq ha⁻¹ yr⁻¹\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Annual emissions: blended reference curve + GHGP model + IPCC lines (all-GHG, single chart)\n", + "t_comp = np.linspace(0.5, 110, 500)\n", + "E_ref_total = blended_ref(t_comp) + non_co2_blend(t_comp)\n", + "\n", + "# GHGP model on integer years (discrete annual model)\n", + "t_ghgp = np.arange(1, 101)\n", + "E_ghgp_annual = np.array([\n", + " (P_LUC * (21 - t) / 210 + E_LM) if t <= 20 else E_LM\n", + " for t in t_ghgp\n", + "])\n", + "\n", + "fig, ax = plt.subplots(figsize=(12, 7))\n", + "\n", + "ax.plot(t_comp, E_ref_total, 'b-', linewidth=2, label='All-GHG reference curve (CO₂ + blended non-CO₂)')\n", + "ax.plot(t_ghgp, E_ghgp_annual, 'r-', linewidth=2.5, label='GHGP model')\n", + "\n", + "# IPCC total values at calibration site age ranges\n", + "ipcc_total_lines = [\n", + " ('Tropical acacia (78.6)', 78.6, 5, 10, '#984ea3'),\n", + " ('Tropical cropland (57.9)', 57.9, 8, 15, '#ff7f00'),\n", + " ('Tropical oil palm (45.0)', 45.0, 5, 18, '#e41a1c'),\n", + " ('Bor/Temp cropland (37.3)', 37.3, 25, 100, '#377eb8'),\n", + " ('Temperate pasture (29.0)', 29.0, 50, 100, '#4daf4a'),\n", + " ('Boreal pasture (27.0)', 27.0, 35, 100, '#f781bf'),\n", + "]\n", + "\n", + "for label, val, t_min, t_max, color in ipcc_total_lines:\n", + " ax.plot([t_min, t_max], [val, val], color=color, linestyle='-', linewidth=3, alpha=0.8)\n", + " ax.text(t_max + 1, val, label, fontsize=8, color=color, va='center')\n", + "\n", + "ax.set_xlabel('Years since drainage', fontsize=12)\n", + "ax.set_ylabel('Emissions (t CO₂-eq ha⁻¹ yr⁻¹)', fontsize=12)\n", + "ax.set_title('Annual Emissions: GHGP Model vs All-GHG Reference Curve vs IPCC Tier 1', fontsize=13)\n", + "ax.legend(fontsize=10, loc='upper right')\n", + "ax.set_xlim(0, 100)\n", + "ax.set_ylim(0, 150)\n", + "ax.grid(True, alpha=0.3)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Cumulative emissions comparison (GHGP/Reference ratio):\n", + " Yr 10 Yr 20 Yr 40 Yr 50 Yr 100\n", + " ----------------------------------------------------------------------\n", + " GHGP / Reference 0.99 1.05 1.02 1.01 1.01\n", + " GHGP / Tropical oil palm 1.85 1.52 1.17 1.10 0.97\n", + " GHGP / Tropical cropland 1.44 1.18 0.91 0.86 0.75\n", + " GHGP / Tropical acacia 1.06 0.87 0.67 0.63 0.55\n", + " GHGP / Temperate cropland 2.23 1.83 1.42 1.33 1.17\n", + " GHGP / Temperate pasture 2.87 2.36 1.82 1.71 1.50\n", + " GHGP / Boreal cropland 2.27 1.87 1.44 1.36 1.19\n", + " GHGP / Boreal pasture 3.08 2.53 1.96 1.84 1.61\n" + ] + } + ], + "source": [ + "# Cumulative emissions: all land uses (universal GHGP model vs per-zone IPCC rates)\n", + "land_uses = list(ipcc.keys())\n", + "t_plot = np.arange(1, 101)\n", + "\n", + "E_ghgp = np.array([\n", + " (P_LUC * (21 - t) / 210 + E_LM) if t <= 20 else E_LM\n", + " for t in t_plot\n", + "])\n", + "\n", + "# Universal reference curve (same for all zones)\n", + "E_ref = blended_ref(t_plot) + non_co2_blend(t_plot)\n", + "\n", + "fig, axes = plt.subplots(3, 3, figsize=(18, 14))\n", + "axes_flat = axes.flatten()\n", + "\n", + "for i, name in enumerate(land_uses):\n", + " ax = axes_flat[i]\n", + " vals = ipcc[name]\n", + "\n", + " E_ipcc = np.full_like(t_plot, vals['total'], dtype=float)\n", + "\n", + " ax.plot(t_plot, np.cumsum(E_ref), 'b-', linewidth=2, label='Reference curve')\n", + " ax.plot(t_plot, np.cumsum(E_ghgp), 'r-', linewidth=2, label='GHGP model')\n", + " ax.plot(t_plot, np.cumsum(E_ipcc), 'k--', linewidth=1.5, alpha=0.5, label='IPCC flat rate')\n", + " ax.set_title(name, fontsize=11, fontweight='bold')\n", + " ax.set_xlim(0, 100)\n", + " ax.grid(True, alpha=0.3)\n", + " if i >= 6:\n", + " ax.set_xlabel('Years since drainage')\n", + " if i % 3 == 0:\n", + " ax.set_ylabel('Cumulative t CO₂-eq ha⁻¹')\n", + "\n", + "for j in range(len(land_uses), len(axes_flat)):\n", + " axes_flat[j].axis('off')\n", + "axes_flat[len(land_uses)].legend(\n", + " *axes_flat[0].get_legend_handles_labels(),\n", + " loc='center', fontsize=12, frameon=False\n", + ")\n", + "\n", + "fig.suptitle('Cumulative Emissions: Universal GHGP Model vs Reference Curve vs IPCC Flat Rate', fontsize=14, y=1.01)\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Summary table\n", + "print(f\"\\nCumulative emissions comparison (GHGP/Reference ratio):\")\n", + "cum_ref = np.cumsum(E_ref)\n", + "cum_ghgp = np.cumsum(E_ghgp)\n", + "print(f\" {'':25}\", end=\"\")\n", + "for yr in [10, 20, 40, 50, 100]:\n", + " print(f\" {'Yr '+str(yr):>8}\", end=\"\")\n", + "print()\n", + "print(f\" {'-'*70}\")\n", + "print(f\" {'GHGP / Reference':<25}\", end=\"\")\n", + "for yr in [10, 20, 40, 50, 100]:\n", + " ratio = cum_ghgp[yr-1] / cum_ref[yr-1]\n", + " print(f\" {ratio:8.2f}\", end=\"\")\n", + "print()\n", + "for name in land_uses:\n", + " vals = ipcc[name]\n", + " E_ipcc = np.full_like(t_plot, vals['total'], dtype=float)\n", + " cum_ipcc = np.cumsum(E_ipcc)\n", + " print(f\" {'GHGP / ' + name:<25}\", end=\"\")\n", + " for yr in [10, 20, 40, 50, 100]:\n", + " ratio = cum_ghgp[yr-1] / cum_ipcc[yr-1]\n", + " print(f\" {ratio:8.2f}\", end=\"\")\n", + " print()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.13" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file