Notebook_4b_comparison_of_emissions_against_gridded_data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "822831cb-627a-4391-a100-4bd56dcd2f98",
   "metadata": {},
   "source": [
    "## Comparison of reservoir emissions in Myanmar calculated explicitly with GeoCARET and ReEmission, and the estimates obtained by extrapolating and binning measured emissions using latitude and climate zone parameterizations\n",
    "\n",
    "### Author:\n",
    "##### Tomasz Janus, University of Manchester, tomasz.janus@manchester.ac.uk; tomasz.k.janus@gmail.com\n",
    "##### Date: 30-10-24, Modified: 23-11-24\n",
    "\n",
    "### Data Sources:\n",
    "We use two sets of data representing gridded areal CO$_2$ and CH$_4$ emission estimates:\n",
    "1) The dataset created by Harrison et al. 2021 [[1](https://doi.org/10.1029/2020GB006888)]\n",
    "2) The dataset prepared by Soued et al. 2022 [[2](https://doi.org/10.1038/s41561-022-01004-2)]. This dataset shows emission factors vs. climatic zones. It was shared as a table in Supplementary Information and is an extension of emission factors proposed in the 2019 refinement to the 2006 IPCC emission guidelines, that includes additional degassing and ebullition CH$_4$ emission pathways.\n",
    "\n",
    "### Notes on Data Preprocessing and Algorithms\n",
    "\n",
    "#### Estimation of reservoir emissions from gridded data\n",
    "\n",
    "We calculated the net anthropogenic contribution of reservoirs to emissions from the gridded estimates for CO$_2$ and CH$_4$ emissions respectively using equation 1 from Almeida et al. 2019 [[3](https://doi.org/10.1038/s41467-019-12179-5)], presented below:\n",
    "\n",
    "**Eq. 1** : ${\\mathrm{TE}}_{{\\mathrm{reservoir}}} = A_{{\\mathrm{reservoir}}} \\times \\left( {{\\mathrm{net}}_{{\\mathrm{CO}}_{2}} \\times F_{{\\mathrm{CO}}_{\\mathrm{2}}} + {\\mathrm{net}}_{{\\mathrm{CH}}_{4}} \\times F_{{\\mathrm{CH}}_{\\mathrm{4}}} \\times {\\mathrm{GWP}}_{{\\mathrm{CH}}_{4}}} \\right) \\times \\left( {1 + R_{{\\mathrm{downstream}}}} \\right)$\n",
    "\n",
    "where $A_{{\\mathrm{reservoir}}}$ is the reservoir area and $F_{{\\mathrm{CO}}_{\\mathrm{2}}}$ and $F_{{\\mathrm{CH}}_{\\mathrm{4}}}$ are the areal CO$_2$ and CH$_4$ emissions (fluxes), respectively. ${\\mathrm{GWP}}_{{\\mathrm{CH}}_{4}}$ is a conversion factor for the global warming potential of CH$_4$ relative to CO$_2$ over the corresponding time horizon (e.g. 20 or 100 years). We have assumed the time horizon of 100 years. The parameters $\\mathrm{net}_{\\mathrm{CO}_2}$ , $\\mathrm{net}_{\\mathrm{CH}_4}$ and $R_\\mathrm{downstream}$ are introduced by Almeida et al. 2019 [[3](https://doi.org/10.1038/s41467-019-12179-5)] to account only for the true net (anthropogenic) change in GHG emissions associated with reservoir creation from the gross emissions data that account for both the anthropogenic and non-anthropogenic emissions. These coefficients model the discount factors for CO$_2$ and CH$_4$ emissions that determine the fraction of net anthropogenic emissions in the total emissions of CO$_2$ and CH$_4$, respectively, and the ratio of downstream emissions to reservoir-surface emissions. We adopted the original values presented in Almeida et al. 2019 [[3](https://doi.org/10.1038/s41467-019-12179-5)], i.e. $\\mathrm{net}_{\\mathrm{CO}_2} = 0.25$, $\\mathrm{net}_{\\mathrm{CH}_4} = 0.90$, and $R_\\mathrm{downstream} = 0.17$. Additionally, we fitted new values using linear regression to obtain the best fit between emission predictions from G-res (facilitated via the ReEmission software) and the factors per climatic zone of Soued et al. \n",
    "\n",
    "#### IPCC Guidelines\n",
    "\n",
    "IPCC provides main guidance on reservoir GHG emissions in the Chapter 7, Volume 4 of the 2019 Refinement for a more complete inventory of greenhouse gas emissions from managed lands, ([Lovelock et al. 2019](https://www.ipcc-nggip.iges.or.jp/public/2019rf/pdf/4_Volume4/19R_V4_Ch07_Wetlands.pdf))\n",
    "\n",
    "### Purpose of the Notebook\n",
    "The purpose of this notebook is to calculate and visualise differences in estimates of emissions of individual reservoirs as well as total country-wide emissions from reservoirs from the two approaches: (a) direct calculation using G-res emission model for each individual reservoir, and (b) using interpolated values from a limited number of known emissions from reservoirs in different locations across the world.\n",
    "\n",
    "### References:\n",
    "* [1] Harrison, J. A., Prairie, Y. T., Mercier-Blais, S., & Soued, C. (2021). Year-2020 global distribution and pathways of reservoir methane and carbon dioxide emissions according to the greenhouse gas from reservoirs (G-res) model. Global Biogeochemical Cycles, 35, e2020GB006888. https://doi.org/10.1029/2020GB006888 \n",
    "* [2] Soued, C., Harrison, J.A., Mercier-Blais, S. et al. Reservoir CO2 and CH4 emissions and their climate impact over the period 1900–2060. Nat. Geosci. 15, 700–705 (2022). https://doi.org/10.1038/s41561-022-01004-2\n",
    "* [3] Almeida, R.M., Shi, Q., Gomes-Selman, J.M. et al. Reducing greenhouse gas emissions of Amazon hydropower with strategic dam planning. Nat Commun 10, 4281 (2019). https://doi.org/10.1038/s41467-019-12179-5\n",
    "* [4] Carlino, A., Schmitt, R., Clark, A. et al. Rethinking energy planning to mitigate the impacts of African hydropower. Nat Sustain 7, 879–890 (2024). https://doi.org/10.1038/s41893-024-01367-x\n",
    "* [5] Bridget R. Deemer, John A. Harrison, Siyue Li, Jake J. Beaulieu, Tonya DelSontro, Nathan Barros, José F. Bezerra-Neto, Stephen M. Powers, Marco A. dos Santos, J. Arie Vonk, Greenhouse Gas Emissions from Reservoir Water Surfaces: A New Global Synthesis, BioScience, Volume 66, Issue 11, 1 November 2016, Pages 949–964, https://doi.org/10.1093/biosci/biw117\n",
    "* [6] Catherine Ellen Lovelock, Christopher Evans, Nathan Barros, Yves Prairie, Jukka Alm, David Bastviken, Jake J. Beaulieu, Michelle Garneau, Atle Harby, John Harrison, David Pare, Hanne Lerche Raadal, Bradford Sherman, Chengyi Zhang, Stephen Michael Ogle, 2019 Refinement to the 2006 IPCC Guidelines for National Greenhouse Gas Inventories, Volume 4: Agriculture, Forestry and Other Land Use, Chapter 7 Wetlands, https://www.ipcc-nggip.iges.or.jp/public/2019rf/pdf/4_Volume4/19R_V4_Ch07_Wetlands.pdf\n",
    "* [7] Carly Hansen, Rachel Pilla, Paul Matson, Bailey Skinner, Natalie Griffiths, & Henriette Jager (2023). Variability in modelled reservoir greenhouse gas emissions: comparison of select US hydropower reservoirs against global estimates. Environmental Research Communications, 4(12), 121008. https://iopscience.iop.org/article/10.1088/2515-7620/acae24#ercacae24s6\n",
    "* [8] Bridget R. Deemer, John A. Harrison, Siyue Li, Jake J. Beaulieu, Tonya DelSontro, Nathan Barros, José F. Bezerra-Neto, Stephen M. Powers, Marco A. dos Santos, J. Arie Vonk, Greenhouse Gas Emissions from Reservoir Water Surfaces: A New Global Synthesis, BioScience, Volume 66, Issue 11, 1 November 2016, Pages 949–964, https://doi.org/10.1093/biosci/biw117\n",
    "* [9]  Tangi, M., Schmitt, R., Almeida, R., Bossi, S., Flecker, A., Sala, F., & Castelletti, A. (2024). Robust hydropower planning balances energy generation, carbon emissions and sediment connectivity in the Mekong River Basin. Earth's Future, 12, e2023EF003647. https://doi.org/10.1029/2023EF003647 \n",
    "\n",
    "### Notes on adoption of GHG fluxes in most recent planning studies\n",
    "\n",
    "1. Almeida et al. 2019 [[3](https://doi.org/10.1038/s41467-019-12179-5)] used the gross flux data from one of the earlier global reservoir emission synthesis by Deemer et al. [[5](https://doi.org/10.1093/biosci/biw117)].\n",
    "2. Carlino et al. 2024 [[4](https://doi.org/10.1038/s41893-024-01367-x)] analyzed the gridded estimates from Harrison et al. 2021 [[1](https://doi.org/10.1029/2020GB006888)] that are parameterized vs. latitude and the parameterization of Soued et al. 2022 [[2](https://doi.org/10.1038/s41561-022-01004-2)] who parameterized the emissions vs. climatic zone. They processed both datasets using Eq. 1 adopted after Almeida et al. 2019 [[3](https://doi.org/10.1038/s41467-019-12179-5)]. Nevetheless, since only a few points in the dataset of [[1](https://doi.org/10.1029/2020GB006888)] were available for Africa (which was the geographical context of their study), and most of the estimates at these latitudes were from Southeast Asia or Latin America, the authors based their results solely on the greenhouse gas emission estimations of Soued et al. (2022) [[2](https://doi.org/10.1038/s41561-022-01004-2)].\n",
    "\n",
    "### Notes on selected cited studies\n",
    "\n",
    "#### * Harrison et al.\n",
    "The data with the estimated CO$_2$ and CH$_4$ emission fluxes per given latitude has been shared in this [Zenodo link](https://zenodo.org/records/4632428/files/G-res_Output_x_Deg_Latitude_20210423.xlsx?download=1). The authors also present data globally on a 1degx1deg grid, albeit it has not been clearly explained what data each dataset contains. All three datasets in `.txt` and `.xlsx` formats are contained in this [Zenodo link](https://zenodo.org/records/4632428) and the 1$^o$ x 1$^o$ .\n",
    "\n",
    "\n",
    "#### * Soued et al.\n",
    "\n",
    "#### * Hansen et al.\n",
    "The authors argue that hydropower reservoirs, based on an example from the U.S.A. span a wide range of climate regions and have diverse design and operational characteristics compared to those most heavily represented in model literature (i.e., large, tropical reservoirs). It is therefore not clear whether estimates based on measurements and modeling of other subsets of reservoirs describe those diverse types of hydropower reservoirs. The authors then go on to compare the emission estimates from extrapolations from other measured subsets of reservoirs against direct modelling using G-res. The authors observed that the net GHG reservoir footprint calculated with G-res was less variable and towards the lower end of the range observed from modeling larger global reservoirs, with a range of 138 to 1,052 g CO2 eq m−2 y−1, while the global study reported a range of 115 to 145,472 g CO2 eq m−2 y−1. The authods concluded that due to high variation in emissions normalized with respect to area and generation, we need to be cautious when using area or generation in predicting or communicating emissions footprints for reservoirs relative to those of other energy sources, e.g. in hydropower planning studies. The authors compared their estimates against the published data from [Deemer et al. 2016](https://doi.org/10.1093/biosci/biw117).and the 1$o$ x 1$^o$ gridded estimates of total GHG emissions across all emission pathways [Harrison et al. 2021](https://doi.org/10.1029/2020GB006888). The authors concluded with a good overview of limitations of G-res, particularly with respect to dynamically changing inputs, e.g. due to climate change conditions - see the notes in [Hansen_notes_on_limitations.txt](Hansen_notes_on_limitations.txt)\n",
    "\n",
    "#### * Tangi et al. \n",
    "\n",
    "Tangi et al formulated a robust optimization problem for hydropower planning using GHG emisisons as a novel objective. The authors employed a two-step optimal planning with three objectives : HP generation, sediment transport, and GHG emissions using a multiobjective evolutionary algorithm (MOEA) for obtaining non-dominated (Pareto-optimal) portfolios of dams. The approach is two step: (1) Initial optimization using central estimates of all three objectives producing Pareto-optimal sequences of dams and (2) Portfolio robustness step via screening of solutions to include only robust solutions. \n",
    "\n",
    "#### * Carlino et al.\n",
    "\n",
    "\n",
    "\n",
    "### Notes on limitations of our approach (for the manuscript)\n",
    "\n",
    "1. We cannot model cascading systems because our approach does not explicitly account for reductions or inputs to GHG emission processes that might be occurring in upstream reservoirs (Prairie et al 2017)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e397b53a-f439-4f40-b02d-9a5684eda273",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Package imports\n",
    "from typing import Tuple, List, Dict, Callable\n",
    "import pathlib\n",
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from geopy.distance import geodesic\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.font_manager as font_manager\n",
    "import matplotlib\n",
    "import seaborn as sns\n",
    "sns.set(style='ticks', context='talk')\n",
    "\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.base import clone\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn.utils import resample\n",
    "from sklearn.metrics import r2_score\n",
    "\n",
    "matplotlib.rcParams['pdf.fonttype'] = 3\n",
    "matplotlib.rcParams['ps.fonttype'] = 42\n",
    "\n",
    "import warnings\n",
    "warnings. filterwarnings('ignore', category=UserWarning)\n",
    "\n",
    "# Dataset imports\n",
    "harrison_fluxes = pathlib.Path('inputs/gridded_emissions_datasets/harrison2021/G-res_Output_x_Deg_Latitude_20210423.xlsx')\n",
    "climate_zones_soued = pathlib.Path('inputs/gridded_emissions_datasets/soued2022/1976-2000_ASCII.txt')\n",
    "soued_emission_factors = pathlib.Path('inputs/gridded_emissions_datasets/soued2022/soued2022.csv')\n",
    "reemission_file = pathlib.Path('outputs/reemission/outputs_MIN_LOW_PRIM.xlsx')\n",
    "\n",
    "# Define and create the folder for storing the output figures\n",
    "fig_folder = pathlib.Path(\"figures/emission_comparison\")\n",
    "os.makedirs(fig_folder, exist_ok=True)\n",
    "# Define and create the folder for storing the output files (tabular data)\n",
    "outfile_folder = pathlib.Path(\"outputs/emissions_comparison\")\n",
    "os.makedirs(outfile_folder, exist_ok=True)\n",
    "save_figure_global: bool = True\n",
    "\n",
    "# Parameters from Eq. 1 - used to disentangle anthropogenic and natural reservoir emissions\n",
    "R_downstream = 0.17\n",
    "net_CO2 = 0.25\n",
    "net_CH4 = 0.90\n",
    "# Mapping between Koppen-Geiger climate classifications (detailed) and Climatic Zones (coarse)\n",
    "kopgei_to_climate_cfg = {\n",
    "    ('Af','Am','As','Aw'): 'Tropical wet moist',\n",
    "    ('BWh','BSh'): 'Tropical dry montane',\n",
    "    ('Cfa','Cfb','Cfc','Dfa'): 'Warm temperate moist',\n",
    "    ('Csa','Csb','Csc','Cwa','Cwb','Cwc'): 'Warm temperate dry',\n",
    "    ('BWk','BSk','Dfb','Dsa','Dsb','Dwa','Dwb'): 'Cool temperate moist dry',\n",
    "    ('EF','ET','Dwc','Dwd','Dfc','Dfd','Dsc','Dsd') : 'Polar moist boreal dry moist'\n",
    "}\n",
    "\n",
    "# Custom functions\n",
    "\n",
    "# A function decorator that skips execution of a function. Used to switch execution of functions off without removing code\n",
    "def skip_execution(reason=\"Function skipped\"):\n",
    "    def decorator(func):\n",
    "        def wrapper(*args, **kwargs):\n",
    "            print(f\"{func.__name__} skipped: {reason}\")\n",
    "            # Optionally, you could return None or a custom value if needed\n",
    "            return None\n",
    "        return wrapper\n",
    "    return decorator\n",
    "\n",
    "def load_climate_zone_soued(filename: str = climate_zones_soued) -> pd.DataFrame:\n",
    "    \"\"\"\n",
    "    The code loads text data with geodesic coordinates and Koppen-Geiger climate classification codes\n",
    "    Note: Borrowed from Carlino et al. \n",
    "    \"\"\"\n",
    "    kopgei = pd.read_csv(climate_zones_soued, header=1)\n",
    "    count = 0\n",
    "    for col in kopgei.columns[0].split():\n",
    "        kopgei[col] = [x.split()[count] for x in kopgei[kopgei.columns[0]].values]\n",
    "        if count < 2:\n",
    "            kopgei[col] = pd.to_numeric(kopgei[col])\n",
    "        count += 1\n",
    "    kopgei = kopgei.drop([kopgei.columns[0]], axis=1)\n",
    "    return kopgei\n",
    "\n",
    "def expand_kopgei_climate_mapping(kopgei_climate_map: Dict[Tuple[str, ...], str]) -> Dict[str, str]:\n",
    "    \"\"\" \"\"\"\n",
    "    return {item: value for key_tuple, value in kopgei_climate_map.items() for item in key_tuple}\n",
    "\n",
    "def find_nearest_kopgei_classification(df: pd.DataFrame, lat: float, lon: float, eps: float = 0.25) -> str:\n",
    "    \"\"\"Finds the Koppen Geiger classification based on latitude and longitude of a point\"\"\"\n",
    "    # Find rows of data near the location (fast pre-screening)\n",
    "    df_trimmed = df.loc[\n",
    "        (abs(df['Lat'].values - lat) <= eps) & \\\n",
    "        (abs(df['Lon'].values - lon) <= eps)]\n",
    "    # Calculate geodesic distance for each point in the dataframe (slow on large dataframes)\n",
    "    distances = df_trimmed.apply(lambda row: geodesic((lat, lon), (row['Lat'], row['Lon'])).kilometers, axis=1)\n",
    "    # Find the index of the minimum distance\n",
    "    nearest_index = distances.idxmin()\n",
    "    # Return the classification of the closest point\n",
    "    return df.loc[nearest_index, 'Cls']\n",
    "\n",
    "def add_emission_factors(em_factors: pd.DataFrame, koppen_geiger: str): \n",
    "    czone = kopgei_to_czone[koppen_geiger]\n",
    "    data_dict = em_factors[em_factors['Climate']==czone].iloc[0].to_dict()\n",
    "    return data_dict\n",
    "\n",
    "# Error functions\n",
    "def _abs_err(x_1, x_2) -> float | np.float64:\n",
    "    return np.abs(x_1-x_2)\n",
    "\n",
    "def _rel_err(x_1, x_2) -> float | np.float64:\n",
    "    return (x_2 - x_1) / x_1\n",
    "\n",
    "def _rel_err2(y_true, y_pred) -> float | np.float64:\n",
    "    return (y_true-y_pred) / y_true\n",
    "\n",
    "def _rel_abs_err(x_1, x_2) -> float | np.float64:\n",
    "    return _abs_err(x_1, x_2) / x_1\n",
    "\n",
    "# x1 is true value\n",
    "# x2 is prediction\n",
    "\n",
    "# Mean Absolute Error (MAE)\n",
    "def mae(x_1, x_2) -> float | np.float64:\n",
    "    return _abs_err(x_1, x_2).mean()\n",
    "\n",
    "# Root Mean Squared Error (RMSE)\n",
    "def rmse(x_1, x_2) -> float | np.float64:\n",
    "    return np.sqrt((_abs_err(x_1, x_2)**2).mean())\n",
    "\n",
    "# Mean Absolute Percentage Error\n",
    "def mape(x_1, x_2) -> float | np.float64:\n",
    "    return _rel_abs_err(x_1, x_2).mean() * 100\n",
    "\n",
    "# Relative Mean Absolute Error\n",
    "def rmae(x_1, x_2) -> float | np.float64:\n",
    "    return _rel_abs_err(x_1, x_2).mean()\n",
    "    \n",
    "# Relative Root Mean Squared Error (RRMSE)\n",
    "def rrmse(x_1, x_2) -> float | np.float64:\n",
    "    return np.sqrt((_rel_abs_err(x_1, x_2) ** 2).mean())\n",
    "\n",
    "# Symmetric Mean Absolute Percentage Error (SMAPE)\n",
    "def smape(x_1, x_2) -> float | np.float64:\n",
    "    return (_abs_err(x_1, x_2) / ((np.abs(x_1) + np.abs(x_2)) / 2)).mean() * 100\n",
    "\n",
    "def r_squared(x_1, x_2) -> np.float64:\n",
    "    \"\"\"x_1 = y_true, x_2 = y_pred\"\"\"\n",
    "    # Convert inputs to numpy arrays for calculation\n",
    "    x_1 = np.array(x_1)\n",
    "    x_2 = np.array(x_2)\n",
    "    # Calculate mean of full model outputs\n",
    "    x_1_mean = np.mean(x_1)\n",
    "    # Calculate SSE (Sum of Squared Errors) and SST (Total Sum of Squares)\n",
    "    sse = np.sum((x_1 - x_2) ** 2)\n",
    "    sst = np.sum((x_1 -x_1_mean) ** 2)\n",
    "    # Calculate R-squared\n",
    "    r2 = 1 - (sse / sst)\n",
    "    return r2\n",
    "\n",
    "def report_errors(x_1, x_2) -> None:\n",
    "    print(f\"Mean Absolute Error (MAE): {mae(x_1, x_2)}\")\n",
    "    print(f\"Coefficient of determination (R-squared): {r_squared(x_1, x_2)}\")\n",
    "    print(f\"Mean Absolute Percentage Error (MAPE): {mape(x_1, x_2)}\")\n",
    "    print(f\"Root Mean Squared Error (RMSE): {rmse(x_1, x_2)}\")\n",
    "    print(f\"Relative Mean Absolute Error (RMAE): {rmae(x_1, x_2)}\")\n",
    "    print(f\"Relative Root Mean Squared Error (RRMSE): {rrmse(x_1, x_2)}\")\n",
    "    print(f\"Symmetric Mean Absolute Percentage Error (SMAPE): {smape(x_1, x_2)}\")\n",
    "    \n",
    "# Compare total emissions\n",
    "def total_emission(row, em_column: str, area_column: str, conv_coefficient: float = 1.0) -> None:\n",
    "    \"\"\"Calculate total emissions. Given that emission intensities are in gCO2e/m2/year and areas in km2, the\n",
    "    calculated total emission at `conv_coefficient = 1.0` is in the unit of tonnesCO2e/year.\"\"\"\n",
    "    return row[em_column] * row[area_column] * conv_coefficient"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "437daf66-fe33-4cc7-9c7b-26eb36bfb947",
   "metadata": {},
   "source": [
    "## Preprocess the gridded emission datasets"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ac57fe8-0815-4a76-84a3-f6c61ff9da55",
   "metadata": {},
   "source": [
    "### * Parameterization on the basis of latitude by Harrison et al. (2021)\n",
    "- **NOTE:** We are not using those as they the data is for a single point in time (year 2020) whilst we are looking for average emissions over the lifetime of a reservoir (e.g. 100 years)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "343e1a2f-56b9-4594-aec0-8454d939b3dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read GHG fluxes from Harrison et al. (2021)\n",
    "GHGFluxes = (pd.read_excel(harrison_fluxes).\n",
    "                assign(\n",
    "                    CO2_net=lambda x: x['avg.CO2.diff.g.m2.y.CO2.eq.x.lat'] * net_CO2 * (1 + R_downstream),\n",
    "                    CH4_net=lambda x: x['avg.CH4.tot.g.m2.y.CO2.eq.x.lat'] * net_CH4 * (1 + R_downstream),\n",
    "                    tot_em_net=lambda x: x['CO2_net'] + x['CH4_net']).\n",
    "                 drop([\n",
    "                     'sum.CH4.tot.Mg.CO2.eq.x.lat', 'sum.CH4.deg.Mg.CO2.eq.x.lat', \n",
    "                     'sum.CH4.eb.Mg.CO2.eq.x.lat', 'sum.CH4.diff.Mg.CO2.eq.x.lat', \n",
    "                     'sum.CO2.diff.Mg.CO2.eq.x.lat', 'sum.C.gas.tot.Mg.CO2.eq.x.lat'],\n",
    "                     axis=1)\n",
    "            )\n",
    "GHGFluxes.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd29a4b9-c63c-4b5c-ac9d-3a235e105538",
   "metadata": {},
   "source": [
    "### * Parameterization on the basis of climatic zones by Soued et al. (2022)\n",
    "* **NOTE**: Related to the refined emission factors from the 2019 IPCC Guidelines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4df6f41-17d9-41a2-b603-3b97bf2ba654",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate areal emissions from climate zone parameterization included in Soued et al. 2022; \n",
    "# The code was adapted from Carlino et al.\n",
    "# Read Koppen-Geiger climate zone classification codes per location\n",
    "kopgei = load_climate_zone_soued(filename = climate_zones_soued)\n",
    "# Get a list of all Koppen-Geiger classifications\n",
    "kopgeizone = kopgei['Cls'].unique().tolist()\n",
    "# Load emission factors per climatic zones\n",
    "soued2022 = pd.read_csv(soued_emission_factors).dropna()\n",
    "czone = soued2022['Climate'].tolist()\n",
    "# Create a mapping betwee Koppen-Geiger codes and coarser climate zone classifications used for \n",
    "kopgei_to_czone = expand_kopgei_climate_mapping(kopgei_to_climate_cfg)\n",
    "soued2022.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05ea02ae-d4a8-4e10-8aac-2732711c8fee",
   "metadata": {},
   "source": [
    "## Load and process emission outputs calculated with ReEmission\n",
    "\n",
    "* **NOTE:** `res_area` and `catch_area` are given in km$^2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "258f036b-6b88-4231-83d8-071792f8be11",
   "metadata": {},
   "outputs": [],
   "source": [
    "input_columns_to_keep = [\n",
    "    'Name', 'coordinates_0', 'coordinates_1', 'id', 'type', 'catch_area', \n",
    "    'res_area', 'res_volume']\n",
    "reemission_inputs = pd.read_excel(reemission_file, sheet_name=\"inputs\", usecols=input_columns_to_keep)\n",
    "output_columns_to_keep = ['Name', 'co2_diffusion', 'ch4_diffusion', 'ch4_ebullition', 'ch4_degassing', 'co2_net', 'ch4_net']\n",
    "reemission_outputs = pd.read_excel(reemission_file, sheet_name=\"outputs\", usecols=output_columns_to_keep)\n",
    "# Join both dataframes on Name\n",
    "reemission_df = pd.merge(reemission_inputs, reemission_outputs, on='Name', how='inner')\n",
    "# Double check that we have not lost any rows\n",
    "assert len(reemission_df) == len(reemission_inputs) == len(reemission_outputs)\n",
    "# Add climate classification value for each row\n",
    "reemission_df['Cls'] = reemission_df.apply(\n",
    "    lambda row: find_nearest_kopgei_classification(\n",
    "        df = kopgei, lat=row['coordinates_0'], lon=row['coordinates_1']), axis=1)\n",
    "# Apply the function to create a DataFrame from the list returned by add_blank\n",
    "soued_em = reemission_df.apply(\n",
    "    lambda row: add_emission_factors(soued2022, row['Cls']), axis='columns', result_type='expand')\n",
    "reemission_df = pd.concat([reemission_df, soued_em], axis=1).\\\n",
    "    rename(columns={\n",
    "        'CO2 diffusive 20 yrs integrated [gCO2eq/ (m2 yr)]': 'co2_diffusion_soued',\n",
    "        'CH4 diffusive 20 yrs integrated [gCO2eq/ (m2 yr)]': 'ch4_diffusion_soued',\n",
    "        'CH4 ebullition [gCO2eq/ (m2 yr)]': 'ch4_ebullition_soued',\n",
    "        'CH4 degassing [gCO2eq/ (m2 yr)]': 'ch4_degassing_soued'})\n",
    "reemission_df.describe().drop('count')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce297213",
   "metadata": {},
   "source": [
    "## Perform a linear regression to find the values of emission factors with the best fit to data (outputs from ReEmission)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "882b4b04",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find out if the data is balanced with respect to the climate categorical variables\n",
    "climate_counts = reemission_df['Climate'].value_counts().to_dict()\n",
    "print(climate_counts)\n",
    "# The data looks imbalanced with respect to climate categories and therefore we shall employ\n",
    "# a weighted linear regressions with weights inversely proportional to the value counts for each\n",
    "# category\n",
    "# Prepare the data for solving the linear regression problem\n",
    "coeff = 1e-3 # Unit conversion\n",
    "regression_df = (reemission_df.copy().\n",
    "    assign(co2_diffusion_total=lambda x: total_emission(x, 'co2_diffusion', 'res_area', coeff)).\n",
    "    assign(ch4_diffusion_total=lambda x: total_emission(x, 'ch4_diffusion', 'res_area', coeff)).\n",
    "    assign(ch4_ebullition_total=lambda x: total_emission(x, 'ch4_ebullition', 'res_area', coeff)).\n",
    "    assign(ch4_degassing_total=lambda x: total_emission(x, 'ch4_degassing', 'res_area', coeff))\n",
    ")\n",
    "\n",
    "def get_regression_data(\n",
    "        df: pd.DataFrame, \n",
    "        output_column: str, \n",
    "        area_col: str = 'res_area') -> Tuple[pd.DataFrame, pd.Series, pd.Series]:\n",
    "    \"\"\"Returns input-output data for fitting a linear regression model\"\"\"\n",
    "    encoder = OneHotEncoder()  # Drop one category to avoid multicollinearity\n",
    "    climate_encoded = encoder.fit_transform(df[['Climate']]).toarray()\n",
    "    encoded_climate_df = pd.DataFrame(\n",
    "        climate_encoded, \n",
    "        columns=encoder.get_feature_names_out(['Climate']))\n",
    "    X = encoded_climate_df\n",
    "    #X = pd.concat([encoded_climate_df, df[area_col]], axis=1)\n",
    "    y = df[output_column] / df[area_col]\n",
    "    # Calculate sample weights based on inverse frequency of each category\n",
    "    climate_counts = df['Climate'].value_counts()\n",
    "    weights = df['Climate'].map(lambda x: 1 / climate_counts[x])\n",
    "    return X, y, weights\n",
    "    \n",
    "def find_emission_factors(\n",
    "        X: pd.DataFrame, \n",
    "        y: pd.Series, \n",
    "        weights: pd.Series, \n",
    "        coeff: float = 1e-3):\n",
    "    \"\"\"Finds emission coefficients using weighted linear regression between climate zone and emission\n",
    "    predictions calculated with G-res.\n",
    "    \"\"\"\n",
    "    # Initialize the model\n",
    "    model = LinearRegression(fit_intercept=False)\n",
    "    # Fit the model on the original data to get the initial coefficients\n",
    "    model.fit(X, y, sample_weight=weights)\n",
    "    base_coefficients = model.coef_ / coeff\n",
    "    coeff_dict = dict(zip(X.columns, base_coefficients))\n",
    "    return model, coeff_dict\n",
    "\n",
    "def find_confidence_intervals(\n",
    "        X: pd.DataFrame,\n",
    "        y: pd.Series,\n",
    "        model,\n",
    "        weights: pd.Series = None,\n",
    "        coeff: float = 1e-3,\n",
    "        n_bootstraps: int = 1_000, \n",
    "        confidence_level: float = 0.95) -> pd.Series:\n",
    "    \"\"\" \"\"\"\n",
    "    # Store bootstrap coefficients\n",
    "    bootstrap_coefficients = []\n",
    "    # Perform bootstrapping\n",
    "    for i in range(n_bootstraps):\n",
    "        model_cf = clone(model)\n",
    "        # Resample data with replacement\n",
    "        if weights:\n",
    "            X_resampled, y_resampled, weights_resampled = resample(X, y, weights)\n",
    "            # Fit model on the resampled data\n",
    "            model_cf.fit(X_resampled, y_resampled, sample_weight=weights_resampled)\n",
    "        else:\n",
    "            X_resampled, y_resampled = resample(X, y)\n",
    "            model_cf.fit(X_resampled, y_resampled)\n",
    "        base_coefficients = model_cf.coef_ / coeff\n",
    "        # Store the coefficients\n",
    "        bootstrap_coefficients.append(base_coefficients)\n",
    "        \n",
    "    # Convert bootstrap coefficients to a DataFrame\n",
    "    bootstrap_coefficients = np.array(bootstrap_coefficients)\n",
    "    bootstrap_df = pd.DataFrame(bootstrap_coefficients, columns=X.columns)\n",
    "    # Calculate the confidence intervals for each coefficient\n",
    "    ci_lower = bootstrap_df.quantile((1 - confidence_level) / 2)\n",
    "    ci_upper = bootstrap_df.quantile(1 - (1 - confidence_level) / 2)\n",
    "    deltas = (ci_upper - ci_lower) / 2\n",
    "    return deltas"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "307640ef",
   "metadata": {},
   "source": [
    "## Run regressions for all emission pathways"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cdb75ff6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run regressions for all emission pathways\n",
    "use_weights: bool = False\n",
    "verbose: bool = False\n",
    "exec_options = {\n",
    "    \"CO2 diffusion\": \"co2_diffusion_total\",\n",
    "    \"CH4 diffusion\": \"ch4_diffusion_total\",\n",
    "    \"CH4 ebullition\": \"ch4_ebullition_total\",\n",
    "    \"CH4 degassing\": \"ch4_degassing_total\"\n",
    "}\n",
    "coefficients_dict = {}\n",
    "ci_deltas_dict = {}\n",
    "r2_scores_dict = {}\n",
    "for pathway_name, pathway_column in exec_options.items():\n",
    "    X, y, weights = get_regression_data(regression_df, pathway_column)\n",
    "    if not use_weights:\n",
    "        weights = pd.Series(1, index=regression_df.index)\n",
    "        weights /= len(weights)\n",
    "    model, coeffs = find_emission_factors(X, y, weights)\n",
    "    if verbose:\n",
    "        print(coeffs)\n",
    "    coefficients_dict[pathway_name] = coeffs\n",
    "    if use_weights:\n",
    "        deltas = find_confidence_intervals(X, y, model, weights)\n",
    "        r2 = r2_score(y, model.predict(X), sample_weight=weights)\n",
    "    else:\n",
    "        deltas = find_confidence_intervals(X, y, model)\n",
    "        r2 = r2_score(y, model.predict(X))\n",
    "    r2_scores_dict[pathway_name] = r2\n",
    "    ci_deltas_dict[pathway_name] = deltas\n",
    "    \n",
    "coeffs_df_fitted = pd.DataFrame(coefficients_dict)\\\n",
    "    .reset_index().rename(columns={\"index\": \"Climate\"})\\\n",
    "    .rename(columns = {\n",
    "        \"CO2 diffusion\": \"co2_diffusion_fitted\",\n",
    "        \"CH4 diffusion\": \"ch4_diffusion_fitted\",\n",
    "        \"CH4 ebullition\": \"ch4_ebullition_fitted\",\n",
    "        \"CH4 degassing\": \"ch4_degassing_fitted\"\n",
    "    })\n",
    "coeffs_df_fitted[\"Climate\"] = coeffs_df_fitted[\"Climate\"].apply(lambda x: x.replace(\"Climate_\", \"\"))\n",
    "coeffs_df_fitted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd180007",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame(r2_scores_dict, index=[\"R2 fitted\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "88bcd38a",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame(ci_deltas_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df894ebb",
   "metadata": {},
   "source": [
    "### Add columns with the fitted emission factors (EFs) to the `reemission_df` dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7f3ffbf",
   "metadata": {},
   "outputs": [],
   "source": [
    "fitted_em = reemission_df.apply(\n",
    "    lambda row: add_emission_factors(coeffs_df_fitted, row['Cls']), axis='columns', result_type='expand')\n",
    "reemission_df = pd.concat([reemission_df, fitted_em], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b46b206",
   "metadata": {},
   "outputs": [],
   "source": [
    "reemission_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "881315a4-5e8d-4cf8-81f4-a8306451a926",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compare emission intensities\n",
    "report = (reemission_df.\n",
    "              describe().\n",
    "              loc[\n",
    "                  :, \n",
    "                  ['co2_diffusion', 'co2_diffusion_soued', 'co2_diffusion_fitted',\n",
    "                   'ch4_diffusion', 'ch4_diffusion_soued', 'ch4_diffusion_fitted',\n",
    "                   'ch4_ebullition', 'ch4_ebullition_soued', 'ch4_ebullition_fitted', \n",
    "                   'ch4_degassing', 'ch4_degassing_soued', 'ch4_degassing_fitted']\n",
    "              ].\n",
    "              T.drop_duplicates().T.\n",
    "              drop('count')\n",
    "         )\n",
    "report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55f1c017",
   "metadata": {},
   "outputs": [],
   "source": [
    "def remove_duplicated_columns(df: pd.DataFrame) -> pd.DataFrame:\n",
    "    return df.loc[:,~df.columns.duplicated()].copy()\n",
    "reemission_df = remove_duplicated_columns(reemission_df)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e8910b9",
   "metadata": {},
   "source": [
    "### Calculate total emissions from Emission Factors (EFs) - both Soued's and the fitted ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4fd04b4d-9e97-4318-95f8-4d1cf7306345",
   "metadata": {},
   "outputs": [],
   "source": [
    "coeff = 1e-3\n",
    "emissions_total = (reemission_df.\n",
    "    assign(co2=lambda x: x['co2_diffusion']).\n",
    "    assign(co2_soued=lambda x: x['co2_diffusion_soued']).\n",
    "    assign(co2_fitted=lambda x: x['co2_diffusion_fitted']).               \n",
    "    assign(ch4=lambda x: x['ch4_diffusion'] + x['ch4_ebullition'] + x['ch4_degassing']).\n",
    "    assign(ch4_soued=lambda x: x['ch4_diffusion_soued'] + x['ch4_ebullition_soued'] + x['ch4_degassing_soued']).\n",
    "    assign(ch4_fitted=lambda x: x['ch4_diffusion_fitted'] + x['ch4_ebullition_fitted'] + x['ch4_degassing_fitted']).               \n",
    "    assign(co2_net_total=lambda x: total_emission(x, 'co2_net', 'res_area', coeff)).\n",
    "    assign(ch4_net_total=lambda x: total_emission(x, 'ch4_net', 'res_area', coeff)).\n",
    "    assign(co2_diffusion_total=lambda x: total_emission(x, 'co2_diffusion', 'res_area', coeff)).\n",
    "    assign(co2_diffusion_total_soued=lambda x: total_emission(x, 'co2_diffusion_soued', 'res_area', coeff)).\n",
    "    assign(co2_diffusion_total_fitted=lambda x: total_emission(x, 'co2_diffusion_fitted', 'res_area', coeff)).               \n",
    "    assign(ch4_diffusion_total=lambda x: total_emission(x, 'ch4_diffusion', 'res_area', coeff)).\n",
    "    assign(ch4_diffusion_total_soued=lambda x: total_emission(x, 'ch4_diffusion_soued', 'res_area', coeff)).\n",
    "    assign(ch4_diffusion_total_fitted=lambda x: total_emission(x, 'ch4_diffusion_fitted', 'res_area', coeff)).\n",
    "    assign(ch4_ebullition_total=lambda x: total_emission(x, 'ch4_ebullition', 'res_area', coeff)).\n",
    "    assign(ch4_ebullition_total_soued=lambda x: total_emission(x, 'ch4_ebullition_soued', 'res_area', coeff)).\n",
    "    assign(ch4_ebullition_total_fitted=lambda x: total_emission(x, 'ch4_ebullition_fitted', 'res_area', coeff)).               \n",
    "    assign(ch4_degassing_total=lambda x: total_emission(x, 'ch4_degassing', 'res_area', coeff)).\n",
    "    assign(ch4_degassing_total_soued=lambda x: total_emission(x, 'ch4_degassing_soued', 'res_area', coeff)).\n",
    "    assign(ch4_degassing_total_fitted=lambda x: total_emission(x, 'ch4_degassing_fitted', 'res_area', coeff)).               \n",
    "    assign(co2_total = lambda x: x['co2_diffusion_total']).\n",
    "    assign(co2_total_soued = lambda x: x['co2_diffusion_total_soued']).\n",
    "    assign(co2_total_fitted = lambda x: x['co2_diffusion_total_fitted']).               \n",
    "    assign(ch4_total = lambda x : x['ch4_diffusion_total'] + x['ch4_ebullition_total'] + x['ch4_degassing_total']).\n",
    "    assign(ch4_total_soued = lambda x : x['ch4_diffusion_total_soued'] + x['ch4_ebullition_total_soued'] + x['ch4_degassing_total_soued']).\n",
    "    assign(ch4_total_fitted = lambda x : x['ch4_diffusion_total_fitted'] + x['ch4_ebullition_total_fitted'] + x['ch4_degassing_total_fitted']).            \n",
    "    #T.drop([\n",
    "    #    'co2_diffusion', 'co2_net', 'ch4_diffusion', 'ch4_net', 'ch4_ebullition', 'ch4_degassing',\n",
    "    #    'co2_diffusion_soued', 'ch4_diffusion_soued', 'ch4_ebullition_soued', 'ch4_degassing_soued']).T.\n",
    "    loc[:, [\n",
    "            'co2_diffusion', 'co2_net', 'ch4_diffusion', 'ch4_net', 'ch4_ebullition', 'ch4_degassing',\n",
    "            'co2_diffusion_soued', 'ch4_diffusion_soued', 'ch4_ebullition_soued', 'ch4_degassing_soued',\n",
    "            'co2_diffusion_fitted', 'ch4_diffusion_fitted', 'ch4_ebullition_fitted', 'ch4_degassing_fitted',\n",
    "            'co2', 'co2_soued', 'co2_fitted', 'ch4', 'ch4_soued', 'ch4_fitted',\n",
    "            'co2_diffusion_total', 'co2_diffusion_total_soued', 'co2_diffusion_total_fitted',\n",
    "            'ch4_diffusion_total', 'ch4_diffusion_total_soued', 'ch4_diffusion_total_fitted',\n",
    "            'ch4_ebullition_total', 'ch4_ebullition_total_soued', 'ch4_ebullition_total_fitted',\n",
    "            'ch4_degassing_total', 'ch4_degassing_total_soued', 'ch4_degassing_total_fitted',\n",
    "            'co2_total', 'co2_total_soued', 'co2_total_fitted',\n",
    "            'ch4_total', 'ch4_total_soued', 'ch4_total_fitted', \n",
    "            'co2_net_total', 'ch4_net_total',\n",
    "            'type', 'res_area', 'res_volume', 'Climate']]\n",
    ")\n",
    "emissions_total = emissions_total.astype(\n",
    "    {col: 'float' for col in emissions_total.columns if col not in ('type', 'Climate')})\n",
    "emissions_total['type'] = emissions_total['type'].astype('category')\n",
    "emissions_total['Climate'] = emissions_total['Climate'].astype('category')\n",
    "emissions_total = emissions_total.loc[:, ~emissions_total.columns.duplicated()]\n",
    "emissions_total.describe().drop('count')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7f9830a",
   "metadata": {},
   "source": [
    "### Calculate basic statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f4bcd6c-e5d2-4837-a78f-d086cb3aaec5",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame(emissions_total[[\n",
    "            'co2_diffusion_total', 'co2_diffusion_total_soued', 'co2_diffusion_total_fitted', \n",
    "            'ch4_diffusion_total', 'ch4_diffusion_total_soued', 'ch4_diffusion_total_fitted', \n",
    "            'ch4_ebullition_total', 'ch4_ebullition_total_soued', 'ch4_ebullition_total_fitted',\n",
    "            'ch4_degassing_total', 'ch4_degassing_total_soued', 'ch4_degassing_total_fitted',\n",
    "            'co2_total', 'co2_total_soued', 'co2_total_fitted',\n",
    "            'ch4_total', 'ch4_total_soued', 'ch4_total_fitted', \n",
    "            'co2_net_total', 'ch4_net_total']].sum()).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b69a50d4-8f50-446b-8cd6-b9af48b01f08",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame(emissions_total[[\n",
    "    'co2_diffusion', 'co2_diffusion_soued', 'co2_diffusion_fitted', \n",
    "    'ch4_diffusion', 'ch4_diffusion_soued', 'ch4_diffusion_fitted',\n",
    "    'ch4_ebullition', 'ch4_ebullition_soued', 'ch4_ebullition_fitted',\n",
    "    'ch4_degassing', 'ch4_degassing_soued', 'ch4_degassing_fitted']].mean()).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "549d9bdf",
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame(emissions_total[[\n",
    "    'co2_diffusion', 'co2_diffusion_soued', 'co2_diffusion_fitted', \n",
    "    'ch4_diffusion', 'ch4_diffusion_soued', 'ch4_diffusion_fitted',\n",
    "    'ch4_ebullition', 'ch4_ebullition_soued', 'ch4_ebullition_fitted',\n",
    "    'ch4_degassing', 'ch4_degassing_soued', 'ch4_degassing_fitted', 'Climate']].groupby(\"Climate\").mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d473f99c-e20f-4ebe-8c94-cb57778a1cab",
   "metadata": {},
   "source": [
    "## Make comparison plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1c9c64d-a50a-44ed-b84d-cd2fd524299d",
   "metadata": {},
   "outputs": [],
   "source": [
    "pairs = [\n",
    "    ('co2_diffusion_total', 'co2_diffusion_total_soued'), \n",
    "    ('ch4_diffusion_total', 'ch4_diffusion_total_soued'), \n",
    "    ('co2_total', 'co2_total_soued'), \n",
    "    ('ch4_ebullition_total', 'ch4_ebullition_total_soued'), \n",
    "    ('ch4_degassing_total', 'ch4_degassing_total_soued'), \n",
    "    ('ch4_total', 'ch4_total_soued')\n",
    "]\n",
    "axis_labels = {\n",
    "    'co2_diffusion_total' : 'CO$_2$ diffusion (model), ktCO$_{2e}$/yr',\n",
    "    'co2_diffusion_total_soued': 'CO$_2$ diffusion (EF), ktCO$_{2e}$/yr',\n",
    "    'ch4_diffusion_total': 'CH$_4$ diffusion (model), ktCO$_{2e}$/yr',\n",
    "    'ch4_diffusion_total_soued': 'CH$_4$ diffusion (EF), ktCO$_{2e}$/yr',\n",
    "    'ch4_ebullition_total': 'CH$_4$ ebullition (model), ktCO$_{2e}$/yr',\n",
    "    'ch4_ebullition_total_soued': 'CH$_4$ ebullition (EF), ktCO$_{2e}$/yr',\n",
    "    'ch4_degassing_total': 'CH$_4$ degassing (model), ktCO$_{2e}$/yr',\n",
    "    'ch4_degassing_total_soued': 'CH$_4$ degassing (EF), ktCO$_{2e}$/yr',\n",
    "    'co2_total': 'CO$_2$ emission (model), ktCO$_{2e}$/yr',\n",
    "    'co2_total_soued': 'CO$_2$ emission (EF), ktCO$_{2e}$/yr',\n",
    "    'ch4_total': 'CH$_4$ emission (model), ktCO$_{2e}$/yr',\n",
    "    'ch4_total_soued': 'CH$_4$ emission (EF), ktCO$_{2e}$/yr'}\n",
    "suptitle = \"Comparison of Emissions: Explicit Calculations vs. Emission Factor-Based Estimates\"\n",
    "exec_message = \"This plot is replaced with a 4 x 2 grid plot with top row using established EFs \" + \\\n",
    "    \"and EFs calculated via regression using G-res calculated emissions\"\n",
    "@skip_execution(exec_message)\n",
    "def make_pair_plots_total_emissions(\n",
    "        df: pd.DataFrame, \n",
    "        pairs, axis_labels, suptitle,\n",
    "        filename: str,\n",
    "        dxdy1: float = 0.0, dxdy2: float = 300, \n",
    "        save_fig: bool = save_figure_global) -> None:\n",
    "    # Define the pairs of columns to plot\n",
    "    sns.set_theme(style=\"ticks\")\n",
    "    sns.set_context(\"paper\", font_scale=1.6) \n",
    "    label_fontsize = 15\n",
    "    tick_fontsize = 15\n",
    "\n",
    "    # Create the grid for subplots\n",
    "    fig, axes = plt.subplots(nrows=2, ncols=3, figsize=(15, 10))\n",
    "    axes = axes.flatten()\n",
    "    # Generate q-q plots for each pair\n",
    "    for idx, (col_x, col_y) in enumerate(pairs):\n",
    "        ax = axes[idx]\n",
    "        legend_status='auto'\n",
    "        sns.scatterplot(\n",
    "            x=col_x, y=col_y, style = 'type', hue='type', size='res_area', ax=ax, data=df,\n",
    "            markers=['o', 's', '^'], alpha=0.4, sizes=(50, 500),\n",
    "            **{'edgecolor':'black'})\n",
    "        ax.set_xscale('log')\n",
    "        ax.set_yscale('log')\n",
    "        max_val = max(df[[col_x, col_y]].max())\n",
    "        min_val = min(df[[col_x, col_y]].min())\n",
    "        ax.plot([min_val, max_val], [min_val, max_val], 'k--', lw=3, alpha = 0.6)\n",
    "        # Customize each subplot\n",
    "        ax.set_xlabel(axis_labels[col_x])\n",
    "        ax.set_ylabel(axis_labels[col_y])\n",
    "        #ax.set_xticklabels(ax.get_xticks(), size = tick_fontsize)\n",
    "        #ax.set_yticklabels(ax.get_yticks(), size = tick_fontsize)\n",
    "        ax.set_ylim([min_val-dxdy1, max_val+dxdy2])\n",
    "        ax.set_xlim([min_val-dxdy1, max_val+dxdy2])\n",
    "\n",
    "    handles, labels = ax.get_legend_handles_labels()\n",
    "    for handle in handles:\n",
    "        if handle._label in ('hydroelectric', 'multipurpose', 'irrigation'):\n",
    "            pass\n",
    "            #handle.set_markersize(handle.get_markersize() * 2)\n",
    "            \n",
    "    fig.legend(\n",
    "        handles, [label.replace('type', 'Reservoir Type').replace('res_area', 'Area, km$^2$') for label in labels],\n",
    "        loc='right', bbox_to_anchor=(1.085, 0.5), \n",
    "        scatterpoints=1, frameon=False)\n",
    "\n",
    "    # Iterate again and remove legend from each subplot\n",
    "    for idx, _ in enumerate(pairs):\n",
    "        ax = axes[idx]\n",
    "        ax.legend().remove()\n",
    "    plt.tight_layout(rect=[0, 0, 0.95, 0.95])  # Adjust layout to make space for the legend\n",
    "    fig.suptitle(\n",
    "        suptitle, \n",
    "        fontsize=18, fontweight='bold')\n",
    "    if save_fig:\n",
    "        fig.savefig(fig_folder / f'{filename}.pdf', bbox_inches='tight')\n",
    "        fig.savefig(fig_folder / f'{filename}.svg', bbox_inches='tight')\n",
    "    plt.show()\n",
    "make_pair_plots_total_emissions(\n",
    "    emissions_total, \n",
    "    pairs, \n",
    "    axis_labels, \n",
    "    suptitle, \n",
    "    filename=\"emission_pathways_comparison\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf327156",
   "metadata": {},
   "outputs": [],
   "source": [
    "pairs_fitted = [\n",
    "    ('co2_diffusion_total', 'co2_diffusion_total_fitted'), \n",
    "    ('ch4_diffusion_total', 'ch4_diffusion_total_fitted'), \n",
    "    ('co2_total', 'co2_total_fitted'), \n",
    "    ('ch4_ebullition_total', 'ch4_ebullition_total_fitted'), \n",
    "    ('ch4_degassing_total', 'ch4_degassing_total_fitted'), \n",
    "    ('ch4_total', 'ch4_total_fitted')\n",
    "]\n",
    "axis_labels_fitted = {\n",
    "    'co2_diffusion_total' : 'CO$_2$ diffusion (model), ktCO$_{2e}$/yr',\n",
    "    'co2_diffusion_total_fitted': 'CO$_2$ diffusion (EF), ktCO$_{2e}$/yr',\n",
    "    'ch4_diffusion_total': 'CH$_4$ diffusion (model), ktCO$_{2e}$/yr',\n",
    "    'ch4_diffusion_total_fitted': 'CH$_4$ diffusion (EF), ktCO$_{2e}$/yr',\n",
    "    'ch4_ebullition_total': 'CH$_4$ ebullition (model), ktCO$_{2e}$/yr',\n",
    "    'ch4_ebullition_total_fitted': 'CH$_4$ ebullition (EF), ktCO$_{2e}$/yr',\n",
    "    'ch4_degassing_total': 'CH$_4$ degassing (model), ktCO$_{2e}$/yr',\n",
    "    'ch4_degassing_total_fitted': 'CH$_4$ degassing (EF), ktCO$_{2e}$/yr',\n",
    "    'co2_total': 'CO$_2$ emission (model), ktCO$_{2e}$/yr',\n",
    "    'co2_total_fitted': 'CO$_2$ emission (EF), ktCO$_{2e}$/yr',\n",
    "    'ch4_total': 'CH$_4$ emission (model), ktCO$_{2e}$/yr',\n",
    "    'ch4_total_fitted': 'CH$_4$ emission (EF), ktCO$_{2e}$/yr'}\n",
    "suptitle_fitted = \"Comparison of Emissions: Explicit Calculations vs. Emission Factor-Based Estimates with fitted coefficients\"\n",
    "make_pair_plots_total_emissions(\n",
    "    emissions_total, \n",
    "    pairs_fitted, \n",
    "    axis_labels_fitted, \n",
    "    suptitle_fitted, \n",
    "    filename=\"emission_pathways_comparison_fitted\")"
   ]
  },
  {
   "cell_type": "raw",
   "id": "4441039b",
   "metadata": {},
   "source": [
    "print(\"Columns in emissions_total dataframe\")\n",
    "print(\"------------------------------------\")\n",
    "print(\"\\n\".join(emissions_total.columns))\n",
    "print(\"------------------------------------\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08cc83e6-0691-4dd7-bbf1-790660d0f423",
   "metadata": {},
   "outputs": [],
   "source": [
    "@skip_execution(\"These plots are not used in the publication.\")\n",
    "def make_pair_plots_emission_fluxes(\n",
    "        df: pd.DataFrame, dxdy1: float = 0.0, dxdy2: float = 300,\n",
    "        save_fig: bool = save_figure_global) -> None:\n",
    "    # Define the pairs of columns to plot\n",
    "    sns.set_theme(style=\"ticks\")\n",
    "    sns.set_context(\"paper\", font_scale=1.6) \n",
    "    label_fontsize = 15\n",
    "    tick_fontsize = 15\n",
    "    pairs = [\n",
    "        ('co2_diffusion', 'co2_diffusion_soued'), \n",
    "        ('ch4_diffusion', 'ch4_diffusion_soued'), \n",
    "        ('co2', 'co2_soued'), \n",
    "        \n",
    "        ('ch4_ebullition', 'ch4_ebullition_soued'), \n",
    "        ('ch4_degassing', 'ch4_degassing_soued'), \n",
    "        ('ch4', 'ch4_soued')\n",
    "    ]\n",
    "    axis_labels = {\n",
    "        'co2_diffusion' : 'CO$_2$ diffusion flux (model), gCO$_{2e}$m$^2$/yr',\n",
    "        'co2_diffusion_soued': 'CO$_2$ diffusion flux (EF), gCO$_{2e}$m$^2$/yr',\n",
    "        'ch4_diffusion': 'CH$_4$ diffusio fluxn (model), gCO$_{2e}$m$^2$/yr',\n",
    "        'ch4_diffusion_soued': 'CH$_4$ diffusion flux (EF), gCO$_{2e}$m$^2$/yr',\n",
    "        'ch4_ebullition': 'CH$_4$ ebullition flux (model), gCO$_{2e}$m$^2$/yr',\n",
    "        'ch4_ebullition_soued': 'CH$_4$ ebullition flux (EF), gCO$_{2e}$m$^2$/yr',\n",
    "        'ch4_degassing': 'CH$_4$ degassing flux (model), gCO$_{2e}$m$^2$/yr',\n",
    "        'ch4_degassing_soued': 'CH$_4$ degassing flux (EF), gCO$_{2e}$m$^2$/yr',\n",
    "        'co2': 'CO$_2$ emission flux (model), gCO$_{2e}$m$^2$/yr',\n",
    "        'co2_soued': 'CO$_2$ emission flux (EF), gCO$_{2e}$m$^2$/yr',\n",
    "        'ch4': 'CH$_4$ emission flux (model), gCO$_{2e}$m$^2$/yr',\n",
    "        'ch4_soued': 'CH$_4$ emission flux (EF), gCO$_{2e}$m$^2$/yr'}\n",
    "    # Create the grid for subplots\n",
    "    fig, axes = plt.subplots(nrows=2, ncols=3, figsize=(15, 10))\n",
    "    axes = axes.flatten()\n",
    "    # Generate q-q plots for each pair\n",
    "    for idx, (col_x, col_y) in enumerate(pairs):\n",
    "        ax = axes[idx]\n",
    "        legend_status='auto'\n",
    "        sns.scatterplot(\n",
    "            x=col_x, y=col_y, style = 'type', hue='type', size='res_area', ax=ax, data=df,\n",
    "            markers=['o', 's', '^'], alpha=0.5, sizes=(50, 500),\n",
    "            **{'edgecolor':'black'})\n",
    "        #ax.set_xscale('log')\n",
    "        #ax.set_yscale('log')\n",
    "        max_val = max(df[[col_x, col_y]].max())\n",
    "        min_val = min(df[[col_x, col_y]].min())\n",
    "        ax.plot([min_val, max_val], [min_val, max_val], 'k--', lw=3, alpha = 0.6)\n",
    "        # Customize each subplot\n",
    "        ax.set_xlabel(axis_labels[col_x])\n",
    "        ax.set_ylabel(axis_labels[col_y])\n",
    "        #ax.set_xticklabels(ax.get_xticks(), size = tick_fontsize)\n",
    "        #ax.set_yticklabels(ax.get_yticks(), size = tick_fontsize)\n",
    "        ax.set_ylim([min_val-dxdy1, max_val+dxdy2])\n",
    "        ax.set_xlim([min_val-dxdy1, max_val+dxdy2])\n",
    "\n",
    "    handles, labels = ax.get_legend_handles_labels()\n",
    "    for handle in handles:\n",
    "        if handle._label in ('hydroelectric', 'multipurpose', 'irrigation'):\n",
    "            handle.set_markersize(handle.get_markersize() * 2)\n",
    "            \n",
    "    fig.legend(\n",
    "        handles, [label.replace('type', 'Type').replace('res_area', 'Area, km$^2$') for label in labels],\n",
    "        loc='right', bbox_to_anchor=(1.085, 0.48), \n",
    "        scatterpoints=1, frameon=False)\n",
    "\n",
    "    # Iterate again and remove legend from each subplot\n",
    "    for idx, _ in enumerate(pairs):\n",
    "        ax = axes[idx]\n",
    "        ax.legend().remove()\n",
    "    \n",
    "    plt.tight_layout(rect=[0, 0, 0.95, 0.85])  # Adjust layout to make space for the legend\n",
    "    if save_fig:\n",
    "        fig.savefig(fig_folder / 'emission_flux_pathways_comparison.svg', bbox_inches='tight')\n",
    "        fig.savefig(fig_folder / 'emission_flux_pathways_comparison.pdf', bbox_inches='tight')\n",
    "    plt.show()\n",
    "make_pair_plots_emission_fluxes(df=emissions_total)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06c5fe08",
   "metadata": {},
   "source": [
    "### Make the publication figure and save to `png`, `svg` and `pdf` files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d51df1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make EF vs G-res comparison figure for the paper\n",
    "pairs_publication = [\n",
    "    ('co2_diffusion_total', 'co2_diffusion_total_soued'), \n",
    "    ('ch4_diffusion_total', 'ch4_diffusion_total_soued'), \n",
    "    ('ch4_ebullition_total', 'ch4_ebullition_total_soued'), \n",
    "    ('ch4_degassing_total', 'ch4_degassing_total_soued'), \n",
    "    ('co2_diffusion_total', 'co2_diffusion_total_fitted'), \n",
    "    ('ch4_diffusion_total', 'ch4_diffusion_total_fitted'),  \n",
    "    ('ch4_ebullition_total', 'ch4_ebullition_total_fitted'), \n",
    "    ('ch4_degassing_total', 'ch4_degassing_total_fitted')\n",
    "]\n",
    "axis_labels_publication = {\n",
    "    'co2_diffusion_total' : 'CO$_2$ diffusion (model), ktCO$_{2e}$/yr',\n",
    "    'co2_diffusion_total_fitted': 'CO$_2$ diffusion (EF - fitted), ktCO$_{2e}$/yr',\n",
    "    'ch4_diffusion_total': 'CH$_4$ diffusion (model), ktCO$_{2e}$/yr',\n",
    "    'ch4_diffusion_total_fitted': 'CH$_4$ diffusion (EF - fitted), ktCO$_{2e}$/yr',\n",
    "    'ch4_ebullition_total': 'CH$_4$ ebullition (model), ktCO$_{2e}$/yr',\n",
    "    'ch4_ebullition_total_fitted': 'CH$_4$ ebullition (EF - fitted), ktCO$_{2e}$/yr',\n",
    "    'ch4_degassing_total': 'CH$_4$ degassing (model), ktCO$_{2e}$/yr',\n",
    "    'ch4_degassing_total_fitted': 'CH$_4$ degassing (EF - fitted), ktCO$_{2e}$/yr',\n",
    "    'co2_diffusion_total_soued': 'CO$_2$ diffusion (EF), ktCO$_{2e}$/yr',\n",
    "    'ch4_diffusion_total_soued': 'CH$_4$ diffusion (EF), ktCO$_{2e}$/yr',\n",
    "    'ch4_ebullition_total_soued': 'CH$_4$ ebullition (EF), ktCO$_{2e}$/yr',\n",
    "    'ch4_degassing_total_soued': 'CH$_4$ degassing (EF), ktCO$_{2e}$/yr'}\n",
    "suptitle_publication = \"Comparison of Total Emissions in ktCO$_{2e}$/yr: Explicit Calculations vs. Emission Factor-Based Estimates\"\n",
    "\n",
    "def make_pair_plots_total_emissions_publication(\n",
    "        df: pd.DataFrame, \n",
    "        pairs, axis_labels, suptitle,\n",
    "        filename: str,\n",
    "        dxdy1: float = 0.0, dxdy2: float = 300, \n",
    "        save_fig: bool = save_figure_global) -> None:\n",
    "    # Define the pairs of columns to plot\n",
    "    sns.set_theme(style=\"ticks\")\n",
    "    sns.set_context(\"paper\", font_scale=1.6) \n",
    "    label_fontsize = 12\n",
    "    tick_fontsize = None\n",
    "\n",
    "    # Create the grid for subplots\n",
    "    fig, axes = plt.subplots(nrows=2, ncols=4, figsize=(15, 7))\n",
    "    axes = axes.flatten()\n",
    "    # Generate q-q plots for each pair\n",
    "    for idx, (col_x, col_y) in enumerate(pairs):\n",
    "        ax = axes[idx]\n",
    "        legend_status='auto'\n",
    "        sns.scatterplot(\n",
    "            x=col_x, y=col_y, style = 'type', hue='type', size='res_area', ax=ax, data=df,\n",
    "            markers=['o', 's', '^'], alpha=0.4, sizes=(50, 500),\n",
    "            **{'edgecolor':'black'})\n",
    "        ax.set_xscale('log')\n",
    "        ax.set_yscale('log')\n",
    "        max_val = max(df[[col_x, col_y]].max())\n",
    "        min_val = min(df[[col_x, col_y]].min())\n",
    "        ax.plot([min_val, max_val], [min_val, max_val], 'k--', lw=3, alpha = 0.6)\n",
    "        # Customize each subplot\n",
    "        ax.set_xlabel(axis_labels[col_x], fontsize=label_fontsize)\n",
    "        ax.set_ylabel(axis_labels[col_y], fontsize = label_fontsize)\n",
    "        if tick_fontsize:\n",
    "            ax.set_xticklabels(ax.get_xticks(), size = tick_fontsize)\n",
    "            ax.set_yticklabels(ax.get_yticks(), size = tick_fontsize)\n",
    "        ax.set_ylim([min_val-dxdy1, max_val+dxdy2])\n",
    "        ax.set_xlim([min_val-dxdy1, max_val+dxdy2])\n",
    "\n",
    "    handles, labels = ax.get_legend_handles_labels()\n",
    "    for handle in handles:\n",
    "        if handle._label in ('hydroelectric', 'multipurpose', 'irrigation'):\n",
    "            pass\n",
    "            #handle.set_markersize(handle.get_markersize() * 2)\n",
    "            \n",
    "    fig.legend(\n",
    "        handles, [label.replace('type', 'Reservoir Type').replace('res_area', 'Area, km$^2$') for label in labels],\n",
    "        loc='right', bbox_to_anchor=(1.085, 0.5), \n",
    "        scatterpoints=1, frameon=False)\n",
    "\n",
    "    # Iterate again and remove legend from each subplot\n",
    "    for idx, _ in enumerate(pairs):\n",
    "        ax = axes[idx]\n",
    "        ax.legend().remove()\n",
    "    plt.tight_layout(rect=[0, 0, 0.95, 0.95])  # Adjust layout to make space for the legend\n",
    "    fig.suptitle(\n",
    "        suptitle, \n",
    "        fontsize=18, fontweight='bold')\n",
    "    if save_fig:\n",
    "        fig.savefig(fig_folder / f'{filename}.pdf', bbox_inches='tight')\n",
    "        fig.savefig(fig_folder / f'{filename}.svg', bbox_inches='tight')\n",
    "        fig.savefig(fig_folder / f'{filename}.png', bbox_inches='tight', dpi=1200)\n",
    "    plt.show()\n",
    "make_pair_plots_total_emissions_publication(\n",
    "    emissions_total, \n",
    "    pairs_publication, \n",
    "    axis_labels_publication, \n",
    "    suptitle_publication, \n",
    "    filename=\"emission_pathways_comparison_publication\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb77b5c3",
   "metadata": {},
   "source": [
    "### Calculate R$^2$ scores of all the above regressions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91ce059f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# R2 metrics from the fitted EFs using linear regression\n",
    "score_type = \"flux\"\n",
    "\n",
    "metric_exec_dict_total = {\n",
    "    \"Soued\": {\n",
    "        \"CO2 diffusion\": ('co2_diffusion_total', 'co2_diffusion_total_soued'),\n",
    "        \"CH4 diffusion\": ('ch4_diffusion_total', 'ch4_diffusion_total_soued'),\n",
    "        \"CH4 ebullition\": ('ch4_ebullition_total', 'ch4_ebullition_total_soued'),\n",
    "        \"CH4 degassing\": ('ch4_degassing_total', 'ch4_degassing_total_soued')\n",
    "    },\n",
    "    \"Fitted\": {\n",
    "        \"CO2 diffusion\": ('co2_diffusion_total', 'co2_diffusion_total_fitted'),\n",
    "        \"CH4 diffusion\": ('ch4_diffusion_total', 'ch4_diffusion_total_fitted'),\n",
    "        \"CH4 ebullition\": ('ch4_ebullition_total', 'ch4_ebullition_total_fitted'),\n",
    "        \"CH4 degassing\": ('ch4_degassing_total', 'ch4_degassing_total_fitted')        \n",
    "    }\n",
    "}\n",
    "metric_exec_dict_flux = {\n",
    "    \"Soued\": {\n",
    "        \"CO2 diffusion\": ('co2_diffusion', 'co2_diffusion_soued'),\n",
    "        \"CH4 diffusion\": ('ch4_diffusion', 'ch4_diffusion_soued'),\n",
    "        \"CH4 ebullition\": ('ch4_ebullition', 'ch4_ebullition_soued'),\n",
    "        \"CH4 degassing\": ('ch4_degassing', 'ch4_degassing_soued')\n",
    "    },\n",
    "    \"Fitted\": {\n",
    "        \"CO2 diffusion\": ('co2_diffusion', 'co2_diffusion_fitted'),\n",
    "        \"CH4 diffusion\": ('ch4_diffusion', 'ch4_diffusion_fitted'),\n",
    "        \"CH4 ebullition\": ('ch4_ebullition', 'ch4_ebullition_fitted'),\n",
    "        \"CH4 degassing\": ('ch4_degassing', 'ch4_degassing_fitted')        \n",
    "    }\n",
    "}\n",
    "\n",
    "def calculate_r2_scores(df: pd.DataFrame, metric_exec_dict) -> pd.DataFrame:\n",
    "    \"\"\" \"\"\"\n",
    "    r2_score_dict = {}\n",
    "    for ef_option, pathway in metric_exec_dict.items():\n",
    "        r2_score_dict[ef_option] = {}\n",
    "        for pathway_name, mapping in pathway.items():\n",
    "            r2_score_dict[ef_option][pathway_name] = r2_score(\n",
    "                y_true=df[mapping[0]], y_pred = df[mapping[1]])\n",
    "    return pd.DataFrame(r2_score_dict)\n",
    "\n",
    "def calculate_mae_scores(df: pd.DataFrame, metric_exec_dict) -> pd.DataFrame:\n",
    "    \"\"\" \"\"\"\n",
    "    mape_score_dict = {}\n",
    "    for ef_option, pathway in metric_exec_dict.items():\n",
    "        mape_score_dict[ef_option] = {}\n",
    "        for pathway_name, mapping in pathway.items():\n",
    "            mape_score_dict[ef_option][pathway_name] = mae(df[mapping[0]], df[mapping[1]])\n",
    "    return pd.DataFrame(mape_score_dict)\n",
    "\n",
    "# # Strategies: r_squared, rrmse, rmae, mape, rmse, mae\n",
    "\n",
    "def calculate_score(df: pd.DataFrame, score: Callable, metric_exec_dict: Dict) -> pd.DataFrame:\n",
    "    \"\"\" \"\"\"\n",
    "    score_dict = {}\n",
    "    for ef_option, pathway in metric_exec_dict.items():\n",
    "        score_dict[ef_option] = {}\n",
    "        for pathway_name, mapping in pathway.items():\n",
    "            score_dict[ef_option][pathway_name] = score(df[mapping[0]], df[mapping[1]])\n",
    "    return pd.DataFrame(score_dict)    \n",
    "\n",
    "    \n",
    "r2s_flux = calculate_score(emissions_total, r2_score, metric_exec_dict_flux)\n",
    "r2s_flux"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82d3c596",
   "metadata": {},
   "outputs": [],
   "source": [
    "r2s_total = calculate_score(emissions_total, r2_score, metric_exec_dict_total)\n",
    "r2s_total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c0d7aae",
   "metadata": {},
   "outputs": [],
   "source": [
    "maes_flux = calculate_score(emissions_total, mae, metric_exec_dict_flux)\n",
    "maes_flux"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64df4aa1",
   "metadata": {},
   "outputs": [],
   "source": [
    "maes_total = calculate_score(emissions_total, mae, metric_exec_dict_total)\n",
    "maes_total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf7f321a",
   "metadata": {},
   "outputs": [],
   "source": [
    "rmses_total = calculate_score(emissions_total, rmse, metric_exec_dict_total)\n",
    "rmses_total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3eff6420",
   "metadata": {},
   "outputs": [],
   "source": [
    "rmses_flux = calculate_score(emissions_total, rmse, metric_exec_dict_flux)\n",
    "rmses_flux"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2a4dc21",
   "metadata": {},
   "source": [
    "### Create a $\\LaTeX$ table with fit quality metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fff5383d",
   "metadata": {},
   "outputs": [],
   "source": [
    "flux_metrics_df = pd.concat([r2s_flux, maes_flux, rmses_flux], axis=1)\n",
    "flux_metrics_df.columns = pd.MultiIndex.from_tuples(\n",
    "    [(\"R2\", col) for col in r2s_flux.columns] + [(\"MAE\", col) for col in maes_flux.columns] +\n",
    "    [(\"RMSE\", col) for col in rmses_flux.columns],\n",
    "    names=[\"Metric\", \"Option\"]\n",
    ")\n",
    "metrics_latex_table = flux_metrics_df.to_latex(\n",
    "    index=True, \n",
    "    float_format=\"%4.3f\",\n",
    "    caption=\"Levels of fit between emissions calculated with emission factors and the G-res method\", \n",
    "    label=\"tab:emission_factors\")\n",
    "print(metrics_latex_table)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16c7e59f-f8b7-4dcd-8c97-ba5a7a17967a",
   "metadata": {},
   "source": [
    "## Calculate and compare net emissions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc2d9625-03b4-4e4b-adc4-e11097e40d51",
   "metadata": {},
   "outputs": [],
   "source": [
    "net_emisions = (emissions_total.\n",
    "     assign(\n",
    "         em_net_total = lambda x: x['co2_net_total'] + x['ch4_net_total'],\n",
    "         co2_net_total_soued=lambda x: x['co2_total_soued'] * net_CO2 * (1 + R_downstream),\n",
    "         ch4_net_total_soued=lambda x: x['ch4_total_soued'] * net_CH4 * (1 + R_downstream),\n",
    "         em_net_total_soued=lambda x: x['co2_net_total_soued'] + x['ch4_net_total_soued'],\n",
    "         co2_net_total_fitted=lambda x: x['co2_total_fitted'] * net_CO2 * (1 + R_downstream),\n",
    "         ch4_net_total_fitted=lambda x: x['ch4_total_fitted'] * net_CH4 * (1 + R_downstream),\n",
    "         em_net_total_fitted=lambda x: x['co2_net_total_fitted'] + x['ch4_net_total_fitted']\n",
    "     )\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae424bbf-a084-4519-9353-b1bddbf1dcfa",
   "metadata": {},
   "outputs": [],
   "source": [
    "pairs_soued = [\n",
    "    ('co2_net_total', 'co2_net_total_soued'), \n",
    "    ('ch4_net_total', 'ch4_net_total_soued'), \n",
    "    ('em_net_total', 'em_net_total_soued')\n",
    "]\n",
    "axis_labels_soued = {\n",
    "    'co2_net_total' : 'Net total CO$_2$ emission (model), ktCO$_{2e}$/yr',\n",
    "    'co2_net_total_soued': 'Net total CO$_2$ emission (EF), ktCO$_{2e}$/yr',\n",
    "    'ch4_net_total': 'Net total CH$_4$ emission (model), ktCO$_{2e}$/yr',\n",
    "    'ch4_net_total_soued': 'Net total CH$_4$ emission (EF), ktCO$_{2e}$/yr',\n",
    "    'em_net_total': 'Net total emission (model), ktCO$_{2e}$/yr',\n",
    "    'em_net_total_soued': 'Net total emission (EF), ktCO$_{2e}$/yr'}\n",
    "pairs_fitted = [\n",
    "    ('co2_net_total', 'co2_net_total_fitted'), \n",
    "    ('ch4_net_total', 'ch4_net_total_fitted'), \n",
    "    ('em_net_total', 'em_net_total_fitted')\n",
    "]\n",
    "axis_labels_fitted = {\n",
    "    'co2_net_total' : 'Net total CO$_2$ emission (model), ktCO$_{2e}$/yr',\n",
    "    'co2_net_total_fitted': 'Net total CO$_2$ emission (EF-fitted), ktCO$_{2e}$/yr',\n",
    "    'ch4_net_total': 'Net total CH$_4$ emission (model), ktCO$_{2e}$/yr',\n",
    "    'ch4_net_total_fitted': 'Net total CH$_4$ emission (EF-fitted), ktCO$_{2e}$/yr',\n",
    "    'em_net_total': 'Net total emission (model), ktCO$_{2e}$/yr',\n",
    "    'em_net_total_fitted': 'Net total emission (EF-fitted), ktCO$_{2e}$/yr'}\n",
    "\n",
    "def make_pair_plots_total_emissions(\n",
    "        df: pd.DataFrame, \n",
    "        pairs, axis_labels,\n",
    "        file_suffix: str,\n",
    "        dxdy1: float = 0.0, dxdy2: float = 300,\n",
    "        save_fig: bool = save_figure_global) -> None:\n",
    "    # Define the pairs of columns to plot\n",
    "    sns.set_theme(style=\"ticks\")\n",
    "    sns.set_context(\"paper\", font_scale=1.4) \n",
    "    label_fontsize = 10\n",
    "    tick_fontsize = 15\n",
    "\n",
    "    # Create the grid for subplots\n",
    "    fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(15, 5.0))\n",
    "    axes = axes.flatten()\n",
    "    # Generate q-q plots for each pair\n",
    "    for idx, (col_x, col_y) in enumerate(pairs):\n",
    "        ax = axes[idx]\n",
    "        legend_status='auto'\n",
    "        sns.scatterplot(\n",
    "            x=col_x, y=col_y, style = 'type', hue='type', size='res_area', ax=ax, data=df,\n",
    "            markers=['o', 's', '^'], alpha=0.5, sizes=(50, 500),\n",
    "            **{'edgecolor':'black'})\n",
    "        ax.set_xscale('log')\n",
    "        ax.set_yscale('log')\n",
    "        max_val = max(df[[col_x, col_y]].max())\n",
    "        min_val = min(df[[col_x, col_y]].min())\n",
    "        ax.plot([min_val, max_val], [min_val, max_val], 'k--', lw=3, alpha = 0.6)\n",
    "        # Customize each subplot\n",
    "        ax.set_xlabel(axis_labels[col_x])\n",
    "        ax.set_ylabel(axis_labels[col_y])\n",
    "        #ax.set_xticklabels(ax.get_xticks(), size = tick_fontsize)\n",
    "        #ax.set_yticklabels(ax.get_yticks(), size = tick_fontsize)\n",
    "        ax.set_ylim([min_val-dxdy1, max_val+dxdy2])\n",
    "        ax.set_xlim([min_val-dxdy1, max_val+dxdy2])\n",
    "\n",
    "    handles, labels = ax.get_legend_handles_labels()\n",
    "    for handle in handles:\n",
    "        if handle._label in ('hydroelectric', 'multipurpose', 'irrigation'):\n",
    "            pass\n",
    "            #handle.set_markersize(handle.get_markersize() * 2)\n",
    "            \n",
    "    fig.legend(\n",
    "        handles, [label.replace('type', 'Type').replace('res_area', 'Area, km$^2$') for label in labels],\n",
    "        loc='right', bbox_to_anchor=(1.085, 0.48), \n",
    "        scatterpoints=1, frameon=False)\n",
    "\n",
    "    # Iterate again and remove legend from each subplot\n",
    "    for idx, _ in enumerate(pairs):\n",
    "        ax = axes[idx]\n",
    "        ax.legend().remove()\n",
    "    \n",
    "    plt.tight_layout(rect=[0, 0, 0.95, 0.90])  # Adjust layout to make space for the legend\n",
    "    fig.suptitle(\n",
    "        \"Comparison of Net Anthropogenic Emissions: Explicit Calculations vs. Emission Factor Estimates\", \n",
    "        fontsize=18, fontweight='bold')\n",
    "    if save_fig:\n",
    "        fig.savefig(fig_folder / f'total emisssions_comparison_{file_suffix}.svg', bbox_inches='tight')\n",
    "        fig.savefig(fig_folder / f'total emisssions_comparison_{file_suffix}.pdf', bbox_inches='tight')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98b415a5",
   "metadata": {},
   "source": [
    "### Plot net emission fits using the default anthropogenic (net) contribution coefficients from Soued et al."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a66f55de",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualise net emissions fits based on Soued's Emission Factors\n",
    "make_pair_plots_total_emissions(\n",
    "    df=net_emisions, \n",
    "    pairs = pairs_soued, \n",
    "    axis_labels = axis_labels_soued,\n",
    "    file_suffix=\"Soued\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b781789",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualise net emissions fits based on Fitted Emission Factors (see previous analysis)\n",
    "make_pair_plots_total_emissions(\n",
    "    df=net_emisions, \n",
    "    pairs = pairs_fitted, \n",
    "    axis_labels = axis_labels_fitted,\n",
    "    file_suffix=\"Fitted\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e3b14b8-7fed-4825-b67f-8987515c018c",
   "metadata": {},
   "source": [
    "## Calculate and plot errors between emission pathways and total emissions predicted from the model and using the emission factors (EF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bdc76b56-76f0-41f1-a545-187d43ae63f5",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "emissions_total.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9fa05f0b-1c46-465a-b68f-612d66a3eefc",
   "metadata": {},
   "outputs": [],
   "source": [
    "comparison_pairs_soued = [\n",
    "        ('co2_diffusion', 'co2_diffusion_soued'), \n",
    "        ('ch4_diffusion', 'ch4_diffusion_soued'),  \n",
    "        ('ch4_ebullition', 'ch4_ebullition_soued'), \n",
    "        ('ch4_degassing', 'ch4_degassing_soued'),  \n",
    "        ('co2', 'co2_soued'),\n",
    "        ('ch4', 'ch4_soued')]\n",
    "\n",
    "comparison_pairs_fitted = [\n",
    "        ('co2_diffusion', 'co2_diffusion_fitted'), \n",
    "        ('ch4_diffusion', 'ch4_diffusion_fitted'),  \n",
    "        ('ch4_ebullition', 'ch4_ebullition_fitted'), \n",
    "        ('ch4_degassing', 'ch4_degassing_fitted'),  \n",
    "        ('co2', 'co2_fitted'),\n",
    "        ('ch4', 'ch4_fitted')]\n",
    "\n",
    "def create_hist_df(\n",
    "        df: pd.DataFrame, \n",
    "        comparison_pairs,\n",
    "        err_type: str) -> pd.DataFrame:\n",
    "    emissions_long = pd.DataFrame({\n",
    "        'g-res': pd.concat([df[model_value] for model_value, _ in comparison_pairs]),\n",
    "        'ef': pd.concat([df[ef_value] for _, ef_value in comparison_pairs]),\n",
    "        'type': pd.concat([df['type'] for _ in comparison_pairs]),\n",
    "        'category': ['co2_diffusion'] * len(df) + \n",
    "                    ['ch4_diffusion'] * len(df) + \n",
    "                    ['ch4_ebullition'] * len(df) + \n",
    "                    ['ch4_degassing'] * len(df) + \n",
    "                    ['co2'] * len(df) + \n",
    "                    ['ch4'] * len(df),\n",
    "        'err_type': [err_type] * len(df) * 6\n",
    "    })\n",
    "    # Calculate errors\n",
    "    emissions_long['rel_err'] = \\\n",
    "        _rel_err(emissions_long['g-res'], emissions_long['ef'])\n",
    "    emissions_long['rel_err_perc'] = \\\n",
    "        _rel_err(emissions_long['g-res'], emissions_long['ef']) * 100\n",
    "    return emissions_long\n",
    "\n",
    "emisions_long_soued = create_hist_df(\n",
    "    df=emissions_total, \n",
    "    comparison_pairs = comparison_pairs_soued,\n",
    "    err_type=\"Original\")\n",
    "emisions_long_fitted = create_hist_df(\n",
    "    df=emissions_total, \n",
    "    comparison_pairs = comparison_pairs_fitted,\n",
    "    err_type=\"Fitted\")\n",
    "emisions_long = pd.concat([emisions_long_soued, emisions_long_fitted])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5629e3bf-05e9-482d-9266-76a625c1a6e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "emisions_long['rel_err'].describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9cd08231",
   "metadata": {},
   "outputs": [],
   "source": [
    "emisions_long['rel_err_perc'].describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9515ba84-10be-4214-a1b0-ef0cfb133f4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "@skip_execution(\"This plot is replaced with a multifacet plot for each reservoir type.\")\n",
    "def make_box_plot_mape_all_dams(save_fig: bool = save_figure_global) -> None:\n",
    "    # Visualise the errors on a box plot\n",
    "    sns.set_theme(style=\"ticks\")\n",
    "    sns.set_context(\"paper\", font_scale=1.6)\n",
    "    # Initialize the figure with a logarithmic x axis\n",
    "    f, ax = plt.subplots(figsize=(7, 6))\n",
    "    sns.boxplot(\n",
    "        emissions_long, y=\"mape\", x=\"category\", hue=\"category\",\n",
    "        whis=[0, 100], width=.6, palette=\"vlag\"\n",
    "    )\n",
    "    sns.stripplot(emissions_long, y=\"mape\", x=\"category\", size=4, color=\".3\", alpha=0.6, edgecolor='black')\n",
    "    # Tweak the visual presentation\n",
    "    ax.xaxis.grid(False)\n",
    "    ax.set(ylabel='Mean Absolute Percentage Error (MAPE)', xlabel=\"\")\n",
    "    ax.spines['left'].set_linewidth(0.7)\n",
    "    ax.spines['bottom'].set_linewidth(0.7)\n",
    "    \n",
    "    # Adjust labels\n",
    "    new_labels = [\n",
    "        \"CO$_2$ diffusion\", \"CH$_4$ diffusion\", \"CH$_4$ ebullition\", \n",
    "        \"CH$_4$ degassing\", \"CO$_2$ total\", \"CH$_4$ total\"]\n",
    "    ax.set_xticklabels(new_labels, rotation=45, ha=\"right\")\n",
    "    sns.despine(trim=True, left=False)\n",
    "    if save_fig:\n",
    "        f.savefig(fig_folder / 'mape_all_dams.svg', bbox_inches='tight')\n",
    "        f.savefig(fig_folder / 'mape_all_dams.pdf', bbox_inches='tight')\n",
    "    plt.show()\n",
    "make_box_plot_mape_all_dams()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1debe74e-99f3-455c-a69b-790acd517dfe",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_box_plot_mape_multifaceted(\n",
    "        df: pd.DataFrame = emissions_long, \n",
    "        y_val: str = \"rel_err_perc\",\n",
    "        suptitle: bool = False,\n",
    "        save_fig: bool = save_figure_global) -> None:\n",
    "    # Visualise the errors on a box plot\n",
    "    titles = {\n",
    "        \"hydroelectric\": \"Hydroelectric Reservoirs\",\n",
    "        \"irrigation\": \"Irrigation Reservoirs\",\n",
    "        \"multipurpose\": \"Multipurpose Reservoirs\"\n",
    "    }\n",
    "    sns.set_theme(style=\"ticks\")\n",
    "    sns.set_context(\"paper\", font_scale=1.8)\n",
    "    # Initialize the figure with a logarithmic x axis\n",
    "    g = sns.FacetGrid(df, col=\"type\", height=6, aspect=1)\n",
    "    g.map_dataframe(\n",
    "        sns.boxplot, y=y_val, x=\"category\", fliersize=0, hue=\"err_type\",\n",
    "        width=0.8, palette=\"vlag\", linewidth=0.5\n",
    "    )\n",
    "    g.map_dataframe(\n",
    "        sns.stripplot, y=y_val, x=\"category\", size=3, color=\"lightgray\", alpha=0.2, \n",
    "        edgecolor='black', dodge=True, linewidth=0.5, marker=\"o\", hue=\"err_type\",\n",
    "        legend=False, palette=None\n",
    "    )\n",
    "    # Adjust labels\n",
    "    new_labels = [\n",
    "        \"CO$_2$ diffusion\", \"CH$_4$ diffusion\", \"CH$_4$ ebullition\", \n",
    "        \"CH$_4$ degassing\", \"CO$_2$ total\", \"CH$_4$ total\"]\n",
    "    for ax in g.axes.flat:\n",
    "        ax.xaxis.grid(False)\n",
    "        ax.set_xlabel(\"\")\n",
    "        ax.set_ylabel(\"Relative Gross Emission Error, \\%\")\n",
    "        ax.set_ylim((-250,1_250))\n",
    "        ax.spines['left'].set_linewidth(0.7)\n",
    "        ax.spines['bottom'].set_linewidth(0.7)\n",
    "        ax.set_xticklabels(new_labels, rotation=45, ha=\"right\")\n",
    "    for ax, title in zip(g.axes.flat, g.col_names):\n",
    "        ax.set_title(titles[title], fontsize=14, fontweight=\"bold\", pad=25)  # Use the custom title dictionary\n",
    "    plt.tight_layout(rect=[0, 0, 1, 0.93])  # Adjust layout to make space for the legend\n",
    "    if suptitle:\n",
    "        g.fig.suptitle(\n",
    "            \"Relative Errors in Reservoir Emission Predictions: Explicit Calculations vs. Emission Factor Estimates\", \n",
    "            fontsize=18, fontweight='bold')\n",
    "    g.add_legend(title=\"Emission Factors\")\n",
    "        \n",
    "    g.despine(trim=True, left=False)\n",
    "    if save_fig:\n",
    "        g.fig.savefig(fig_folder / 'mape_all_dams_faceted.svg', bbox_inches='tight')\n",
    "        g.fig.savefig(fig_folder / 'mape_all_dams_faceted.pdf', bbox_inches='tight')\n",
    "    plt.show()\n",
    "    \n",
    "make_box_plot_mape_multifaceted(emisions_long)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0334d5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "emissions_long"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "566b8ea8",
   "metadata": {},
   "outputs": [],
   "source": [
    "emissions_long.query(\"type == 'hydroelectric' & category == 'ch4_ebullition'\").describe(\n",
    "    percentiles=[.9, .95, .997])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03be4ed8-449c-4348-a3ea-aef608caa34d",
   "metadata": {},
   "source": [
    "## Calculate and plot errors between net emissions from the model and the emission factors (EF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f883983b-3cf4-4209-8116-b7bd3da91608",
   "metadata": {},
   "outputs": [],
   "source": [
    "report_errors(net_emisions['co2_net_total'], net_emisions['co2_net_total_soued'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04ca183e-a19a-452e-b823-74492d03ee6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "report_errors(net_emisions['ch4_net_total'], net_emisions['ch4_net_total_soued'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "629670d0-70cc-4d6a-8011-39a2cf0be61a",
   "metadata": {},
   "outputs": [],
   "source": [
    "report_errors(net_emisions['em_net_total'], net_emisions['em_net_total_soued'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02e5e5c4-5fc0-4f89-b50f-1d9f4e6495d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "net_emisions['em_net_mape'] = \\\n",
    "    _rel_err2(\n",
    "        y_true = net_emisions['em_net_total'], \n",
    "        y_pred = net_emisions['em_net_total_soued']) * 100 * -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d4b57ea-d401-427b-9beb-6b676206b405",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_mape_histogram(save_fig: bool = save_figure_global) -> None:\n",
    "    \"\"\" \"\"\"\n",
    "    hydro = net_emisions[\"em_net_mape\"].where(net_emisions['type']=='hydroelectric').dropna()\n",
    "    irr = net_emisions[\"em_net_mape\"].where(net_emisions['type']=='irrigation').dropna()\n",
    "    multi = net_emisions[\"em_net_mape\"].where(net_emisions['type']=='multipurpose').dropna()\n",
    "    label_fontsize = 15\n",
    "    tick_fontsize = 14\n",
    "    plt.style.use('seaborn-v0_8-ticks')\n",
    "    f, ax = plt.subplots(figsize=(7, 5.5))\n",
    "    ax.tick_params(axis='both', which='major', labelsize=tick_fontsize)\n",
    "    min_val = net_emisions['em_net_mape'].min()\n",
    "    max_val = net_emisions['em_net_mape'].max()\n",
    "    bins = np.linspace(int(min_val), int(max_val), 18)\n",
    "    plt.xlabel('Mean Absolute Percentage Error (MAPE)', fontsize=label_fontsize)\n",
    "    plt.ylabel('Frequency', fontsize=label_fontsize)\n",
    "    plt.hist(\n",
    "        [hydro, irr, multi], \n",
    "        label=['hydro', 'irrigation', 'multipurpose'], \n",
    "        histtype='bar', bins=bins, edgecolor='black', alpha=0.7)\n",
    "    plt.legend(loc='upper right', frameon=False, fontsize=14)\n",
    "    # Remove ticks from top and right side\n",
    "    ax.tick_params(top=False, right=False)\n",
    "    f.tight_layout(rect=[0, 0, 1, 0.90])  # Adjust layout to make space for the legend\n",
    "    f.suptitle(\n",
    "        \"Relative Errors in Net Anthropogenic Emissions:\\nExplicit Calculations vs. Emission Factor Estimates\",\n",
    "        fontweight='bold')\n",
    "    # Decrease the width of the plot border\n",
    "    for spine in ax.spines.values():\n",
    "        spine.set_linewidth(0.6)\n",
    "    if save_fig:\n",
    "        f.savefig(fig_folder / 'mape_all_dams_histogram.svg', bbox_inches='tight')\n",
    "        f.savefig(fig_folder / 'mape_all_dams_histogram.pdf', bbox_inches='tight')\n",
    "    plt.show()\n",
    "make_mape_histogram()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06997483-3ca1-456c-9fad-595dde6ee549",
   "metadata": {},
   "source": [
    "### Run Linear Regression to calibrate net$_{CO_2}$ and net$_{CH_4}$ parameters that are used to estimate net anthropogenic emissions from total emissions\n",
    "\n",
    "* **NOTE**: Differences between explicitly calculated emissions and emission factors originate from two sources:\n",
    "* 1. Emission factors are binned into categories and are therefore constant over an area of interest e.g. latitude band or climatic zone, whilst in reality, emissions vary continuously in response to many continuously changing emission drivers.\n",
    "  2. Disentanglement of anthropogenic emissions from total, e.g. measured emissions is a function of complex relationships such as pre-impoundment emissions, levels of landuse, impacts of nutrients originating from human activities, whilst in case of applying simple emission factors, a single regression is applied individuall to CO$_2$ and CH$_4$ emissions. This simplifies the analysis but introduces a new source of error.\n",
    "\n",
    "Here, we fit these regressions to our emission estimates and show that the obtained parameters substantially differ from the coefficient values adopted in previous studies, e.g. Almeida et al. 2019 [[3](https://doi.org/10.1038/s41467-019-12179-5)] and Carlino et al. 2024 [[4](https://doi.org/10.1038/s41893-024-01367-x)] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41808b29",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_confidence_intervals_net_regression(\n",
    "        X: pd.DataFrame,\n",
    "        y: pd.Series,\n",
    "        model,\n",
    "        n_bootstraps: int = 1_000, \n",
    "        confidence_level: float = 0.95) -> pd.Series:\n",
    "    \"\"\" \"\"\"\n",
    "    # Store bootstrap coefficients\n",
    "    bootstrap_coefficients = []\n",
    "    # Perform bootstrapping\n",
    "    for i in range(n_bootstraps):\n",
    "        model_cf = clone(model)\n",
    "        # Resample data with replacement\n",
    "        X_resampled, y_resampled = resample(X, y)\n",
    "        model_cf.fit(X_resampled, y_resampled)\n",
    "        base_coefficients = model_cf.coef_\n",
    "        # Store the coefficients\n",
    "        bootstrap_coefficients.append(base_coefficients)\n",
    "        \n",
    "    # Convert bootstrap coefficients to a DataFrame\n",
    "    bootstrap_coefficients = np.array(bootstrap_coefficients)\n",
    "    bootstrap_coefficients_2d = np.squeeze(bootstrap_coefficients, axis=(1, 2))\n",
    "    bootstrap_df = pd.DataFrame(bootstrap_coefficients_2d, columns=X.columns)\n",
    "    # Calculate the confidence intervals for each coefficient\n",
    "    ci_lower = bootstrap_df.quantile((1 - confidence_level) / 2)\n",
    "    ci_upper = bootstrap_df.quantile(1 - (1 - confidence_level) / 2)\n",
    "    deltas = (ci_upper - ci_lower) / 2\n",
    "    return deltas\n",
    "\n",
    "net_em_lr_results = {\n",
    "    \"net_CO2\": None,\n",
    "    \"net_CO2_CI\": None,\n",
    "    \"net_CO2_R2\": None,\n",
    "    \"net_CO2_MAE\": None,\n",
    "    \"net_CO2_RMSE\": None,\n",
    "    \"net_CH4\": None,\n",
    "    \"net_CH4_CI\": None,\n",
    "    \"net_CH4_R2\": None,\n",
    "    \"net_CH4_MAE\": None,\n",
    "    \"net_CH4_RMSE\": None,\n",
    "    \"Rdownstream\": 0.17\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "180d1eea",
   "metadata": {},
   "source": [
    "### 1. Fit the model using EF derived emissions with default values from Soued et al."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33cc37c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# CO2 net emissions\n",
    "co2_net_total = net_emisions[['co2_net_total']] # Net total from G-res\n",
    "co2_total_soued = net_emisions[['co2_total_soued']] # Net total from Soued's emission factors\n",
    "co2_total_fitted = net_emisions[['co2_total_fitted']] # Net total from fitted emission factors\n",
    "# CH4 net emissions\n",
    "ch4_net_total = net_emisions[['ch4_net_total']] # Net total from G-res\n",
    "ch4_total_soued = net_emisions[['ch4_total_soued']] # Net total from Soued's emission factors\n",
    "ch4_total_fitted = net_emisions[['ch4_total_fitted']] # Net total from fitted emission factors\n",
    "\n",
    "def fit_net_emission_model(\n",
    "        co2, \n",
    "        co2_net, \n",
    "        ch4, \n",
    "        ch4_net,\n",
    "        R_downstream = 0.17) -> Dict:\n",
    "    \"\"\" \"\"\"\n",
    "    # Set up regression model objects\n",
    "    model_co2 = LinearRegression(fit_intercept=False)\n",
    "    model_ch4 = LinearRegression(fit_intercept=False)\n",
    "    # Fit models\n",
    "    model_co2.fit(co2, co2_net)\n",
    "    model_ch4.fit(ch4, ch4_net)\n",
    "    # Get fitted parameters\n",
    "    m_co2 = model_co2.coef_[0]\n",
    "    m_ch4 = model_ch4.coef_[0]\n",
    "    net_CO2_fitted = m_co2 / (1+R_downstream)\n",
    "    net_CH4_fitted = m_ch4 / (1+R_downstream)\n",
    "    # Find confidence intervals on the fitted parameters\n",
    "    ci_co2 = find_confidence_intervals_net_regression(co2, co2_net, model_co2)\n",
    "    ci_ch4 = find_confidence_intervals_net_regression(ch4, ch4_net, model_ch4)\n",
    "    # Predict net emissions from the regressions\n",
    "    co2_net_lr = net_CO2_fitted * co2 * (1+R_downstream)\n",
    "    ch4_net_lr = net_CH4_fitted * ch4 * (1+R_downstream)\n",
    "    \n",
    "    r2_score_co2 = r_squared(co2_net_lr, co2_net)\n",
    "    mae_score_co2 = mae(co2_net_lr.values, co2_net.values)\n",
    "    rmse_score_co2 = rmse(co2_net_lr.values, co2_net.values)\n",
    "    r2_score_ch4 = r_squared(ch4_net_lr, ch4_net)\n",
    "    mae_score_ch4 = mae(ch4_net_lr.values, ch4_net.values)\n",
    "    rmse_score_ch4 = rmse(ch4_net_lr.values, ch4_net.values)\n",
    "    out = {\n",
    "        'net_CO2': net_CO2_fitted[0],\n",
    "        'net_CO2_CI': ci_co2[0],\n",
    "        'net_CO2_R2': r2_score_co2,\n",
    "        'net_CO2_MAE': mae_score_co2,\n",
    "        'net_CO2_RMSE': rmse_score_co2,\n",
    "        'net_CH4': net_CH4_fitted[0],\n",
    "        'net_CH4_CI': ci_ch4[0],\n",
    "        'net_CH4_R2': r2_score_ch4,\n",
    "        'net_CH4_MAE': mae_score_ch4,\n",
    "        'net_CH4_RMSE': rmse_score_ch4,\n",
    "    }\n",
    "    return out\n",
    "    \n",
    "outputs_lr_soued = fit_net_emission_model(\n",
    "    co2 = co2_total_soued, \n",
    "    co2_net = co2_net_total,\n",
    "    ch4 = ch4_total_soued, \n",
    "    ch4_net = ch4_net_total)\n",
    "outputs_lr_soued"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af3f03ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "outputs_lr_fitted = fit_net_emission_model(\n",
    "    co2 = co2_total_fitted, \n",
    "    co2_net = co2_net_total,\n",
    "    ch4 = ch4_total_fitted, \n",
    "    ch4_net = ch4_net_total)\n",
    "outputs_lr_fitted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3821fac8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_net_co2(emission_co2, net_CO2 = 0.25, R_downstream = 0.17):\n",
    "    return emission_co2 * net_CO2 * (1+R_downstream)\n",
    "def calc_net_ch4(emission_ch4, net_CH4 = 0.9, R_downstream = 0.17):\n",
    "    return emission_ch4 * net_CH4 * (1+R_downstream)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "288c33f1-8ac9-4aca-9976-f105b27f4f61",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate metrics with the original (default coefficients)\n",
    "outputs_default = {\n",
    "    \"net_CO2\": 0.25,\n",
    "    \"net_CO2_CI\": None,\n",
    "    \"net_CO2_R2\": r_squared(calc_net_co2(co2_total_soued), co2_net_total),\n",
    "    'net_CO2_MAE': mae(calc_net_co2(co2_total_soued).values, co2_net_total.values),\n",
    "    'net_CO2_RMSE': rmse(calc_net_co2(co2_total_soued).values, co2_net_total.values),\n",
    "    'net_CH4': 0.90,\n",
    "    'net_CH4_CI': None,\n",
    "    'net_CH4_R2': r_squared(calc_net_ch4(ch4_total_soued), ch4_net_total),\n",
    "    'net_CH4_MAE': mae(calc_net_ch4(ch4_total_soued).values, ch4_net_total.values),\n",
    "    'net_CH4_RMSE': rmse(calc_net_ch4(ch4_total_soued).values, ch4_net_total.values)\n",
    "}\n",
    "outputs_default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af05cfdb",
   "metadata": {},
   "outputs": [],
   "source": [
    "R_downstream = 0.17\n",
    "net_emissions = (net_emisions.\n",
    "     assign(\n",
    "         em_net_total = lambda x: x['co2_net_total'] + x['ch4_net_total'],\n",
    "         co2_net_total_soued_fitted=lambda x: x['co2_total_soued'] * outputs_lr_soued['net_CO2'] * (1 + R_downstream),\n",
    "         ch4_net_total_soued_fitted=lambda x: x['ch4_total_soued'] * outputs_lr_soued['net_CH4'] * (1 + R_downstream),\n",
    "         em_net_total_soued_fitted=lambda x: x['co2_net_total_soued_fitted'] + x['ch4_net_total_soued_fitted'],\n",
    "         co2_net_total_fitted_fitted=lambda x: x['co2_total_soued'] * outputs_lr_fitted['net_CO2'] * (1 + R_downstream),\n",
    "         ch4_net_total_fitted_fitted=lambda x: x['ch4_total_soued'] * outputs_lr_fitted['net_CH4'] * (1 + R_downstream),\n",
    "         em_net_total_fitted_fitted=lambda x: x['co2_net_total_fitted_fitted'] + x['ch4_net_total_fitted_fitted']\n",
    "     )\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d39a674",
   "metadata": {},
   "outputs": [],
   "source": [
    "net_emissions.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "886353c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "pairs_net_emissions = [\n",
    "    ('co2_net_total', 'co2_net_total_soued'), \n",
    "    ('ch4_net_total', 'ch4_net_total_soued'), \n",
    "    ('em_net_total', 'em_net_total_soued'),\n",
    "    ('co2_net_total', 'co2_net_total_soued_fitted'), \n",
    "    ('ch4_net_total', 'ch4_net_total_soued_fitted'), \n",
    "    ('em_net_total', 'em_net_total_soued_fitted')\n",
    "]\n",
    "axis_labels_net_emissions = {\n",
    "    'co2_net_total' : 'Net total CO$_2$ emission (model), ktCO$_{2e}$/yr',\n",
    "    'co2_net_total_soued': 'Net total CO$_2$ emission (EF), ktCO$_{2e}$/yr',\n",
    "    'co2_net_total_soued_fitted': 'Net total CO$_2$ emission (EF) - regression, ktCO$_{2e}$/yr',\n",
    "    'ch4_net_total': 'Net total CH$_4$ emission (model), ktCO$_{2e}$/yr',\n",
    "    'ch4_net_total_soued': 'Net total CH$_4$ emission (EF), ktCO$_{2e}$/yr',\n",
    "    'ch4_net_total_soued_fitted': 'Net total CH$_4$ emission (EF) - regression, ktCO$_{2e}$/yr',\n",
    "    'em_net_total': 'Net total emission (model), ktCO$_{2e}$/yr',\n",
    "    'em_net_total_soued': 'Net total emission (EF), ktCO$_{2e}$/yr',\n",
    "    'em_net_total_soued_fitted': 'Net total emission (EF) - regression, ktCO$_{2e}$/yr'}\n",
    "\n",
    "def make_net_emission_regression_plots(\n",
    "        df: pd.DataFrame, \n",
    "        pairs, axis_labels,\n",
    "        file_suffix: str,\n",
    "        dxdy1: float = 0.0, dxdy2: float = 300,\n",
    "        save_fig: bool = save_figure_global) -> None:\n",
    "    # Define the pairs of columns to plot\n",
    "    sns.set_theme(style=\"ticks\")\n",
    "    sns.set_context(\"paper\", font_scale=1.4) \n",
    "    label_fontsize = 10\n",
    "    tick_fontsize = 15\n",
    "\n",
    "    # Create the grid for subplots\n",
    "    fig, axes = plt.subplots(nrows=2, ncols=3, figsize=(15, 10.0))\n",
    "    axes = axes.flatten()\n",
    "    # Generate q-q plots for each pair\n",
    "    for idx, (col_x, col_y) in enumerate(pairs):\n",
    "        ax = axes[idx]\n",
    "        legend_status='auto'\n",
    "        sns.scatterplot(\n",
    "            x=col_x, y=col_y, style = 'type', hue='type', size='res_area', ax=ax, data=df,\n",
    "            markers=['o', 's', '^'], alpha=0.5, sizes=(50, 500),\n",
    "            **{'edgecolor':'black'})\n",
    "        ax.set_xscale('log')\n",
    "        ax.set_yscale('log')\n",
    "        max_val = max(df[[col_x, col_y]].max())\n",
    "        min_val = min(df[[col_x, col_y]].min())\n",
    "        ax.plot([min_val, max_val], [min_val, max_val], 'k--', lw=3, alpha = 0.6)\n",
    "        # Customize each subplot\n",
    "        ax.set_xlabel(axis_labels[col_x])\n",
    "        ax.set_ylabel(axis_labels[col_y])\n",
    "        #ax.set_xticklabels(ax.get_xticks(), size = tick_fontsize)\n",
    "        #ax.set_yticklabels(ax.get_yticks(), size = tick_fontsize)\n",
    "        ax.set_ylim([min_val-dxdy1, max_val+dxdy2])\n",
    "        ax.set_xlim([min_val-dxdy1, max_val+dxdy2])\n",
    "\n",
    "    handles, labels = ax.get_legend_handles_labels()\n",
    "    for handle in handles:\n",
    "        if handle._label in ('hydroelectric', 'multipurpose', 'irrigation'):\n",
    "            pass\n",
    "            #handle.set_markersize(handle.get_markersize() * 2)\n",
    "            \n",
    "    fig.legend(\n",
    "        handles, [label.replace('type', 'Type').replace('res_area', 'Area, km$^2$') for label in labels],\n",
    "        loc='right', bbox_to_anchor=(1.085, 0.48), \n",
    "        scatterpoints=1, frameon=False)\n",
    "\n",
    "    # Iterate again and remove legend from each subplot\n",
    "    for idx, _ in enumerate(pairs):\n",
    "        ax = axes[idx]\n",
    "        ax.legend().remove()\n",
    "    \n",
    "    plt.tight_layout(rect=[0, 0, 0.95, 0.90])  # Adjust layout to make space for the legend\n",
    "    fig.suptitle(\n",
    "        \"Comparison of Net Anthropogenic Emissions: Explicit Calculations vs. Emission Factor Estimates\", \n",
    "        fontsize=18, fontweight='bold')\n",
    "    if save_fig:\n",
    "        fig.savefig(fig_folder / f'net emisssions_comparison_{file_suffix}.svg', bbox_inches='tight')\n",
    "        fig.savefig(fig_folder / f'net emisssions_comparison_{file_suffix}.pdf', bbox_inches='tight')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28f269c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "make_net_emission_regression_plots(\n",
    "    df=net_emissions,\n",
    "    pairs=pairs_net_emissions, \n",
    "    axis_labels=axis_labels_net_emissions,\n",
    "    file_suffix=\"soued\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2de81d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "outputs_lr_fitted\n",
    "outputs_lr_soued\n",
    "outputs_default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4818522",
   "metadata": {},
   "outputs": [],
   "source": [
    "outputs_lr_soued"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b7833d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Prepare parameter value and fit metrics tables\n",
    "table1_dict = {\n",
    "    \"original_value\": [0.25, 0.90],\n",
    "    \"original_R2\": [\n",
    "        outputs_default['net_CO2_R2'],\n",
    "        outputs_default['net_CH4_R2']\n",
    "    ],\n",
    "    \"original_MAE\": [\n",
    "        outputs_default['net_CO2_MAE'],\n",
    "        outputs_default['net_CH4_MAE']\n",
    "    ],\n",
    "    \"original_RMSE\": [\n",
    "        outputs_default['net_CO2_RMSE'],\n",
    "        outputs_default['net_CH4_RMSE']\n",
    "    ],    \n",
    "    \"EF\": [\n",
    "        outputs_lr_soued['net_CO2'], \n",
    "        outputs_lr_soued['net_CH4']\n",
    "    ],\n",
    "    \"EF_R2\": [\n",
    "        outputs_lr_soued['net_CO2_R2'], \n",
    "        outputs_lr_soued['net_CH4_R2']\n",
    "    ],\n",
    "    \"EF_MAE\": [\n",
    "        outputs_lr_soued['net_CO2_MAE'], \n",
    "        outputs_lr_soued['net_CH4_MAE']\n",
    "    ],\n",
    "    \"EF_RMSE\": [\n",
    "        outputs_lr_soued['net_CO2_RMSE'], \n",
    "        outputs_lr_soued['net_CH4_RMSE']\n",
    "    ],  \n",
    "    \"EF-fitted\": [\n",
    "        outputs_lr_fitted['net_CO2'], \n",
    "        outputs_lr_fitted['net_CH4']\n",
    "    ],\n",
    "    \"EF-fitted_R2\": [\n",
    "        outputs_lr_fitted['net_CO2_R2'], \n",
    "        outputs_lr_fitted['net_CH4_R2']\n",
    "    ],\n",
    "    \"EF-fitted_MAE\": [\n",
    "        outputs_lr_fitted['net_CO2_MAE'], \n",
    "        outputs_lr_fitted['net_CH4_MAE']\n",
    "    ],\n",
    "    \"EF-fitted_RMSE\": [\n",
    "        outputs_lr_fitted['net_CO2_RMSE'], \n",
    "        outputs_lr_fitted['net_CH4_RMSE']\n",
    "    ],  \n",
    "}\n",
    "table1 = pd.DataFrame(table1_dict, index = [\"net_CO2\", \"net_CH4\"])\n",
    "# Create a latex table with regression coefficients \n",
    "table1_latex = table1.to_latex(\n",
    "    index=True, \n",
    "    float_format=\"%4.3f\",\n",
    "    caption=\"Net emission regression coefficients\", \n",
    "    label=\"tab:net_emission_parameters\")\n",
    "print(table1_latex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f65aa768",
   "metadata": {},
   "outputs": [],
   "source": [
    "net_emissions['em_net_mape_fitted'] = \\\n",
    "    _rel_err2(\n",
    "        y_true = net_emissions['em_net_total'], \n",
    "        y_pred = net_emissions['em_net_total_fitted']) * 100 * -1\n",
    "net_emissions['em_net_mape_fitted_fitted'] = \\\n",
    "    _rel_err2(\n",
    "        y_true = net_emissions['em_net_total'], \n",
    "        y_pred = net_emissions['em_net_total_fitted_fitted']) * 100 * -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3aa65415",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Prepare data for plotting\n",
    "net_emissions_long_rel_net_em = pd.melt(\n",
    "    net_emissions,\n",
    "    id_vars=[\"type\"],\n",
    "    value_vars=[\"em_net_mape\", \"em_net_mape_fitted\", \"em_net_mape_fitted_fitted\"],\n",
    "    var_name=\"error_type\",\n",
    "    value_name=\"error_value\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4738a6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "net_emissions_long_rel_net_em"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "003f5065",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualise the errors on a box plot\n",
    "def make_box_plot_mape_net_emissions(\n",
    "        df: pd.DataFrame = net_emissions_long_rel_net_em,\n",
    "        box_width: float = 0.8,\n",
    "        suptitle: bool = False,\n",
    "        save_fig: bool = save_figure_global) -> None:\n",
    "    \"\"\" \"\"\"\n",
    "    df = df.copy()\n",
    "    df[\"error_type\"] = df[\"error_type\"].replace({\n",
    "        \"em_net_mape\": \"Default EF and net regression coefficients\",\n",
    "        \"em_net_mape_fitted\": \"Fitted EF and default net regression coefficients\",\n",
    "        \"em_net_mape_fitted_fitted\": \"Fitted EF and net regression coefficients\"\n",
    "    })\n",
    "    sns.set_theme(style=\"ticks\")\n",
    "    sns.set_context(\"paper\", font_scale=1.6)\n",
    "    # Initialize the figure with a logarithmic x axis\n",
    "    f, ax = plt.subplots(figsize=(7, 6))\n",
    "    # Plot the orbital period with horizontal boxes\n",
    "    sns.boxplot(\n",
    "        df, y=\"error_value\", x=\"type\", hue=\"error_type\",\n",
    "        showfliers = False, linewidth=0.5,\n",
    "        width=box_width, palette=\"vlag\", ax=ax\n",
    "    )\n",
    "    \n",
    "    ## Add annotations\n",
    "    for patch in ax.artists:\n",
    "        r, g, b, a = patch.get_facecolor()\n",
    "        patch.set_facecolor((r, g, b, .3))\n",
    "        x = patch.get_x()\n",
    "        y = patch.get_y()\n",
    "        width = patch.get_width()\n",
    "        height = patch.get_height()\n",
    "        ax.text(x+width/2, y+height/2, \"{:.2f}\".format(height), ha='center', va='center')\n",
    "    \n",
    "    # Add in points to show each observation\n",
    "    sns.stripplot(\n",
    "        df, y=\"error_value\", x=\"type\", hue=\"error_type\", size=5, color=\"lightgray\", \n",
    "        ax = ax,\n",
    "        alpha=0.2, dodge=True,\n",
    "        edgecolor='black', linewidth=0.5)  # Subtle variation for stripplot points)\n",
    "    \n",
    "    # Add a legend\n",
    "    handles, labels = ax.get_legend_handles_labels()\n",
    "    ax.legend(\n",
    "        handles[:3], labels[:3], loc=\"upper left\", title=None,\n",
    "        bbox_to_anchor=(0.01, 0.91),\n",
    "        fontsize=\"small\")\n",
    "    \n",
    "    # Tweak the visual presentation\n",
    "    f.tight_layout(rect=[0, 0, 1, 0.90])  # Adjust layout to make space for the legend\n",
    "    if suptitle:\n",
    "        f.suptitle(\n",
    "            \"Relative Errors in Net Anthropogenic Emissions:\\nExplicit Calculations vs. Emission Factor Estimates\",\n",
    "            fontweight='bold')\n",
    "    ax.xaxis.grid(False)\n",
    "    ax.set(ylabel='Relative Net Emission Error, %', xlabel=\"\")\n",
    "    ax.spines['left'].set_linewidth(0.7)\n",
    "    ax.spines['bottom'].set_linewidth(0.7)\n",
    "    sns.despine(trim=True, left=False, offset = 5)\n",
    "    if save_fig:\n",
    "        f.savefig(fig_folder / 'mape_all_dams_histogram_net_emissions.svg', bbox_inches='tight')\n",
    "        f.savefig(fig_folder / 'mape_all_dams_histogram_net_emissions.pdf', bbox_inches='tight')\n",
    "    plt.show()\n",
    "make_box_plot_mape_net_emissions(box_width = 0.8, save_fig=True)"
   ]
  }
 ],
 "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}