Notebook_13_plot_maps_of_MOO_results.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c84ceb06",
   "metadata": {},
   "source": [
    "## Plot maps with solution (dam porftolios) for different power generation targets\n",
    "### T. Janus\n",
    "### Designed: 06.02.2024\n",
    "### Modified: 12.11.2024"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4053dfe",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pathlib\n",
    "import copy\n",
    "import json\n",
    "import pandas as pd\n",
    "import geopandas as gpd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from lib.notebook13 import (\n",
    "    SeabornFig2Grid, plot_mya_reservoirs, make_radar_plots, plot_rivord_histograms,\n",
    "    plot_elev_dist, plot_histograms\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64fdf9b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "from matplotlib.lines import Line2D\n",
    "from shapely.geometry import Point\n",
    "import matplotlib.gridspec as gridspec\n",
    "def add_reservoir_contours(\n",
    "        data: pd.DataFrame,\n",
    "        ax: matplotlib.axes.Axes,\n",
    "        lon_field: str = \"coordinates_1\",\n",
    "        lat_field: str = \"coordinates_0\",\n",
    "        res_label_field: str | None = None,\n",
    "        title: str | None = None,\n",
    "        title_font_size: int = 14,\n",
    "        marker_size: int | str = 40,\n",
    "        marker_size_multiplier: float = 1.0,\n",
    "        cmap = None,\n",
    "        plot_legends = (False, False, False),\n",
    "        offset: float = 0.0,\n",
    "        legend_y_coords = (1.0, 0.2, -0.05),\n",
    "        marker_constant = 1.00,\n",
    "        **kwargs):\n",
    "    \"\"\"Plots the maps with dams\"\"\"\n",
    "    crs={'init':'epsg:4326'}\n",
    "    geometry=[Point(xy) for xy in zip(data[lon_field], data[lat_field])]\n",
    "    data_gdf=gpd.GeoDataFrame(data,crs=crs, geometry=geometry)\n",
    "    # Divide dams into storage and RoR\n",
    "    data_gdf_ror = data_gdf[data_gdf['hp_type_reem'] == 'ror']\n",
    "    data_gdf_sto = data_gdf[data_gdf['hp_type_reem'] == 'sto']\n",
    "    \n",
    "    data_gdf_sto_hp = data_gdf[\n",
    "        (data_gdf['hp_type_reem'] == 'sto') & (data_gdf['type_y'] == 'hydroelectric')]\n",
    "    data_gdf_sto_mp = data_gdf[\n",
    "        (data_gdf['hp_type_reem'] == 'sto') & (data_gdf['type_y'] == 'multipurpose')]\n",
    "    \n",
    "    if isinstance(marker_size, str):\n",
    "        marker_size_ror = np.sqrt(data_gdf_ror[marker_size].astype(float))\n",
    "        marker_size_sto = np.sqrt(data_gdf_sto[marker_size].astype(float))\n",
    "        marker_size_sto_hp = np.sqrt(data_gdf_sto_hp[marker_size].astype(float))\n",
    "        marker_size_sto_mp = np.sqrt(data_gdf_sto_mp[marker_size].astype(float))\n",
    "    else:\n",
    "        marker_size_ror = marker_size\n",
    "        marker_size_sto = marker_size\n",
    "        marker_size_sto_hp = marker_size\n",
    "        marker_size_sto_mp = marker_size\n",
    "        \n",
    "    p1 = data_gdf_ror.plot(\n",
    "        kind='geo', ax=ax, cmap=cmap, \n",
    "        column=None, \n",
    "        facecolor=\"none\",            # No fill color for transparency\n",
    "        #color=\"white\",\n",
    "        #hatch='///',                 # Hatch pattern (slanted lines)\n",
    "        markersize=marker_size_ror*marker_size_multiplier*marker_constant,\n",
    "        marker = \"^\", k=10,\n",
    "        alpha=0.6,\n",
    "        linewidth=0.5, edgecolor='red', categorical = True, \n",
    "        legend_kwds={\n",
    "            'loc':'upper right', \n",
    "            'bbox_to_anchor': (1.17+offset, legend_y_coords[0]),\n",
    "            'markerscale':0.5, \n",
    "            'title_fontsize':'medium', \n",
    "            'frameon':False,\n",
    "            'fontsize':\"small\"},\n",
    "        legend=plot_legends[0],\n",
    "        **kwargs)\n",
    "    p2 = data_gdf_sto_hp.plot(\n",
    "        kind = 'geo', ax=ax, \n",
    "        column=None, \n",
    "        cmap=cmap, \n",
    "        alpha=0.6,\n",
    "        facecolor=\"none\",            # No fill color for transparency\n",
    "        #hatch='///',                 # Hatch pattern (slanted lines)\n",
    "        markersize=marker_size_sto_hp*marker_size_multiplier*marker_constant, \n",
    "        marker = \"o\", k = 10,\n",
    "        linewidth=0.5, edgecolor='red', categorical = True,        \n",
    "        **kwargs)\n",
    "    p3 = data_gdf_sto_mp.plot(\n",
    "        kind = 'geo', ax=ax, \n",
    "        column=None, \n",
    "        cmap=cmap, \n",
    "        aspect=1,\n",
    "        alpha=0.6,\n",
    "        facecolor=\"none\",            # No fill color for transparency\n",
    "        #hatch='///',                 # Hatch pattern (slanted lines)\n",
    "        markersize=marker_size_sto_mp*marker_size_multiplier*marker_constant, \n",
    "        marker = \"s\", k = 10,\n",
    "        linewidth=0.5, edgecolor='red', categorical = True, **kwargs)\n",
    "    \n",
    "    #You can use different 'cmaps' such as jet, plasm,magma, infereno,cividis, binary...(I simply chose cividis)\n",
    "    ax.set_yticks([])\n",
    "    ax.set_xticks([])\n",
    "    x_spacing = 3\n",
    "    y_spacing = 3\n",
    "    #ax.set_xlim(data_gdf.total_bounds[0] - x_spacing/2, data_gdf.total_bounds[2] + x_spacing/2)\n",
    "    #ax.set_ylim(data_gdf.total_bounds[1] - y_spacing/2, data_gdf.total_bounds[3] + y_spacing/2)\n",
    "    if title is not None:\n",
    "        ax.set_title(title, fontsize=title_font_size, loc='left', y=1.0, pad=-18)\n",
    "    # Remove axes\n",
    "    for pos in ('top', 'right', 'bottom', 'left'):\n",
    "        ax.spines[pos].set_visible(False)\n",
    "    # Label the reservoirs\n",
    "    if res_label_field is not None:\n",
    "        for x, y, label in zip(data['coordinates_1'], data['coordinates_0'], data[res_label_field]):\n",
    "            ax.annotate(label, xy=(x,y), xytext=(4,4), textcoords='offset points', fontsize=5, alpha=0.7)\n",
    "\n",
    "    return p1, p2, p3\n",
    "\n",
    "def plot_mya_reservoirs(\n",
    "        data: pd.DataFrame,\n",
    "        ax: matplotlib.axes.Axes,\n",
    "        column_name: str,\n",
    "        lon_field: str = \"coordinates_1\",\n",
    "        lat_field: str = \"coordinates_0\",\n",
    "        rivers_shp: str | None = r'bin/gis_layers/mya_rivers.shp',\n",
    "        outline_shp: str | None = r'bin/gis_layers/myanmar_outline/Myanmar_outline.shp',\n",
    "        res_label_field: str | None = None,\n",
    "        title: str | None = None,\n",
    "        title_font_size: int = 14,\n",
    "        marker_size: int | str = 40,\n",
    "        marker_size_multiplier: float = 1.0,\n",
    "        cmap = 'tab10',\n",
    "        plot_legends = (False, False, False),\n",
    "        offset: float = 0.0,\n",
    "        legend_y_coords = (1.0, 0.2, -0.05),\n",
    "        contour: bool = False,\n",
    "        **kwargs):\n",
    "    \"\"\"Plots the maps with dams\"\"\"\n",
    "    crs={'init':'epsg:4326'}\n",
    "    geometry=[Point(xy) for xy in zip(data[lon_field], data[lat_field])]\n",
    "    data_gdf=gpd.GeoDataFrame(data,crs=crs, geometry=geometry)\n",
    "    if rivers_shp is not None:\n",
    "        rivers = gpd.read_file(rivers_shp, crs=crs)\n",
    "        rivers.plot(ax=ax, edgecolor = 'k', linewidth=0.3, alpha = 0.5)\n",
    "    if outline_shp is not None:\n",
    "        outline = gpd.read_file(outline_shp)\n",
    "        outline.plot(ax=ax, facecolor='Grey', edgecolor='k',alpha=0.05,linewidth=1,cmap=\"cividis\")\n",
    "        outline.plot(ax=ax, facecolor='none', edgecolor='k',alpha=1,linewidth=0.2,cmap=\"cividis\")\n",
    "    # Divide dams into storage and RoR\n",
    "    data_gdf_ror = data_gdf[data_gdf['hp_type_reem'] == 'ror']\n",
    "    data_gdf_sto = data_gdf[data_gdf['hp_type_reem'] == 'sto']\n",
    "    \n",
    "    data_gdf_sto_hp = data_gdf[(data_gdf['hp_type_reem'] == 'sto') & (data_gdf['type_y'] == 'hydroelectric')]\n",
    "    data_gdf_sto_mp = data_gdf[(data_gdf['hp_type_reem'] == 'sto') & (data_gdf['type_y'] == 'multipurpose')]\n",
    "    \n",
    "    if isinstance(marker_size, str):\n",
    "        marker_size_ror = np.sqrt(data_gdf_ror[marker_size].astype(float))\n",
    "        marker_size_sto = np.sqrt(data_gdf_sto[marker_size].astype(float))\n",
    "        marker_size_sto_hp = np.sqrt(data_gdf_sto_hp[marker_size].astype(float))\n",
    "        marker_size_sto_mp = np.sqrt(data_gdf_sto_mp[marker_size].astype(float))\n",
    "    else:\n",
    "        marker_size_ror = marker_size\n",
    "        marker_size_sto = marker_size\n",
    "        marker_size_sto_hp = marker_size\n",
    "        marker_size_sto_mp = marker_size\n",
    "    \n",
    "    if contour:\n",
    "        skwargs = {\n",
    "            'alpha': 0.6,\n",
    "            'facecolor': \"none\",\n",
    "            'linewidth': 0.75,\n",
    "            'edgecolor': 'firebrick',\n",
    "            'column': column_name\n",
    "        }\n",
    "    else:\n",
    "        skwargs = {\n",
    "            'alpha': 0.45,\n",
    "            'edgecolor': 'k',\n",
    "            'linewidth': 0.5,\n",
    "            'column': column_name\n",
    "        }\n",
    "    \n",
    "    #kwargs.update(skwargs)\n",
    "    \n",
    "    p1 = data_gdf_ror.plot(\n",
    "        kind='geo', ax=ax, cmap=cmap,\n",
    "        markersize=marker_size_ror*marker_size_multiplier,\n",
    "        marker = \"^\", k=10,\n",
    "        categorical = True, \n",
    "        legend_kwds={\n",
    "            'loc':'upper right', \n",
    "            'bbox_to_anchor': (1.17+offset, legend_y_coords[0]),\n",
    "            'markerscale':0.5, \n",
    "            'title_fontsize':'medium', \n",
    "            'frameon':False,\n",
    "            'fontsize':\"small\"},\n",
    "        legend=plot_legends[0],\n",
    "        **skwargs,\n",
    "        **kwargs)\n",
    "    \n",
    "    p2 = data_gdf_sto_hp.plot(\n",
    "        kind = 'geo', ax=ax, cmap=cmap, \n",
    "        markersize=marker_size_sto_hp*marker_size_multiplier, \n",
    "        marker = \"o\", k = 10,\n",
    "        categorical = True,  \n",
    "        **skwargs,\n",
    "        **kwargs)\n",
    "    p3 = data_gdf_sto_mp.plot(\n",
    "        kind = 'geo', ax=ax, aspect=1, cmap=cmap,\n",
    "        markersize=marker_size_sto_mp*marker_size_multiplier, \n",
    "        marker = \"s\", k = 10,\n",
    "        categorical = True, **skwargs, **kwargs)\n",
    "    \n",
    "    if plot_legends[0]:\n",
    "        leg1 = p1.get_legend()\n",
    "        leg1._legend_box.align = \"left\"\n",
    "        custom_labels = [\"0.0-3.1\", \"3.1-20\", \"20-40\", \"40-60\", \"60-100\", \"100-400\", \"400-800\", \"800-5000\"]\n",
    "        if leg1:\n",
    "            leg1.set_title(\"GHG Emission\\nIntensity\\n[gCO$_{2,eq}$/kWh]\")\n",
    "        if leg1 and custom_labels:\n",
    "            new_legtxt = custom_labels\n",
    "            for ix,eb in enumerate(leg1.get_texts()):\n",
    "                eb.set_text(new_legtxt[ix])\n",
    "        ax.add_artist(leg1)\n",
    "    \n",
    "    if plot_legends[1]:\n",
    "        legend_elements = [\n",
    "            Line2D([0], [0], marker='o', markeredgecolor='k', markeredgewidth=0.2, alpha=1,\n",
    "                   color='none',\n",
    "                   label='Sto HP', markerfacecolor='none', markersize=10),\n",
    "            Line2D([0], [0], marker='s', markeredgecolor='k', markeredgewidth=0.2, alpha=1,\n",
    "                   color=\"none\",\n",
    "                   label='Sto Multipurpose', markerfacecolor='none', markersize=10),\n",
    "            Line2D([0], [0], marker='^', markeredgecolor='k', markeredgewidth=0.2, alpha=1,\n",
    "                   color='none',\n",
    "                   label='RoR', markerfacecolor='none', markersize=10)]\n",
    "        ax.legend(handles=legend_elements, **{\n",
    "                'loc':'upper right', \n",
    "                'bbox_to_anchor': (1.2+offset, legend_y_coords[1]),\n",
    "                'markerscale':1, \n",
    "                'title_fontsize':'medium', \n",
    "                'frameon':False,\n",
    "                'fontsize':\"small\"})\n",
    "        leg2 = ax.get_legend()\n",
    "        leg2._legend_box.align = \"left\"\n",
    "        leg2.set_title(\"HP Type\")\n",
    "        ax.add_artist(leg2)\n",
    "    if plot_legends[2]:\n",
    "        legend_elements = [\n",
    "            Line2D([0], [0], marker='o', markeredgecolor='k', markeredgewidth=0.2, alpha=1,\n",
    "                   color='none',\n",
    "                   label='10MW', markerfacecolor='none', markersize=4),\n",
    "            Line2D([0], [0], marker='o', markeredgecolor='k', markeredgewidth=0.2, alpha=1,\n",
    "                   color=\"none\",\n",
    "                   label='100MW', markerfacecolor='none', markersize=10),\n",
    "            Line2D([0], [0], marker='o', markeredgecolor='k', markeredgewidth=0.2, alpha=1,\n",
    "                   color='none',\n",
    "                   label='1000MW', markerfacecolor='none', markersize=20)]\n",
    "        ax.legend(handles=legend_elements, **{\n",
    "                'loc':'upper right', \n",
    "                'bbox_to_anchor': (1.2+offset, legend_y_coords[2]),\n",
    "                'markerscale':1.00, \n",
    "                'title_fontsize':'medium', \n",
    "                'frameon':False,\n",
    "                'fontsize':'small'})\n",
    "        leg3 = ax.get_legend()\n",
    "        leg3._legend_box.align = \"left\"\n",
    "        leg3.set_title(\"Mean Power Output\")\n",
    "    \n",
    "    #You can use different 'cmaps' such as jet, plasm,magma, infereno,cividis, binary...(I simply chose cividis)\n",
    "    ax.set_yticks([])\n",
    "    ax.set_xticks([])\n",
    "    x_spacing = 3\n",
    "    y_spacing = 3\n",
    "    #ax.set_xlim(data_gdf.total_bounds[0] - x_spacing/2, data_gdf.total_bounds[2] + x_spacing/2)\n",
    "    #ax.set_ylim(data_gdf.total_bounds[1] - y_spacing/2, data_gdf.total_bounds[3] + y_spacing/2)\n",
    "    if title is not None:\n",
    "        ax.set_title(title, fontsize=title_font_size, loc='left', y=1.0, pad=-18)\n",
    "    # Remove axes\n",
    "    for pos in ('top', 'right', 'bottom', 'left'):\n",
    "        ax.spines[pos].set_visible(False)\n",
    "    # Label the reservoirs\n",
    "    if res_label_field is not None:\n",
    "        for x, y, label in zip(data['coordinates_1'], data['coordinates_0'], data[res_label_field]):\n",
    "            ax.annotate(label, xy=(x,y), xytext=(4,4), textcoords='offset points', fontsize=5, alpha=0.7)\n",
    "\n",
    "    return p1, p2, p3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64ea4250",
   "metadata": {},
   "outputs": [],
   "source": [
    "# File paths\n",
    "all_dams_shp_file_path = pathlib.Path(\n",
    "    \"bin/gis_layers/ifc_database/all_dams_replaced_refactored.shp\")\n",
    "dam_data_plotting_path = pathlib.Path(\n",
    "    \"intermediate/dams_for_plotting_moo.csv\")\n",
    "optim_scenarios_5obj_path = pathlib.Path(\n",
    "    'intermediate/optim_scenarios_5obj.json')\n",
    "optim_scenarios_5obj_soued_path = pathlib.Path(\n",
    "    'intermediate/optim_scenarios_5obj_soued.json')\n",
    "all_hp_path = pathlib.Path('outputs/moo/all_hp.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a385560",
   "metadata": {},
   "outputs": [],
   "source": [
    "all_hp = pd.read_csv(all_hp_path, index_col = 'ifc_id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24e52156",
   "metadata": {},
   "outputs": [],
   "source": [
    "all_hp.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85e48e60",
   "metadata": {},
   "outputs": [],
   "source": [
    "all_hp.loc[236]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1285942d",
   "metadata": {},
   "source": [
    "### Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1dfca202",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Load elevation data and basin data from ifc database\n",
    "ifcdb_df = gpd.read_file(all_dams_shp_file_path)\\\n",
    "    .loc[:, ['IFC_ID', 'DAM_NAME', 'Basin', 'Sub-Basin', 'Sub-Basi_1', 'RIV_ORD', 'FSL (m)']]\\\n",
    "    .set_index('IFC_ID')\n",
    "# Set missing FSL values from Pywr model data\n",
    "ifcdb_df.at[8, 'FSL (m)'] = 313 #400\n",
    "ifcdb_df.at[10, 'FSL (m)'] = 323.0 #428\n",
    "ifcdb_df.at[120, 'FSL (m)'] = 178\n",
    "\n",
    "# 2. Load outputs file with MOO results\n",
    "outputs_file = dam_data_plotting_path\n",
    "output_df = pd.read_csv(outputs_file, index_col=None)\n",
    "# output_df has duplicated ifc ids. Therefore, assign ifc_id of Mali dam to 236\n",
    "output_df.loc[output_df['name'] == \"Mali\", \"ifc_id\"] = 236\n",
    "output_df.set_index(\"ifc_id\", inplace=True)\n",
    "# Define bin edges for land loss\n",
    "bins = [0, 3.1, 20, 40, 60, 100, 400, 800, 5000]\n",
    "# Define labels for the bins\n",
    "#labels = ['0-400 km2', '400-800 km2', '800-1200 km2', '1200-1600 km2']\n",
    "output_df['GHG intensity cat [gCO2,eq/kWh]'] = pd.cut(\n",
    "    output_df['GHG intensity [gCO2,eq/kWh]'], bins=bins)\n",
    "output_df['GHG intensity Soued cat [gCO2,eq/kWh]'] = pd.cut(\n",
    "    output_df['GHG intensity Soued [gCO2,eq/kWh]'], bins=bins)\n",
    "\n",
    "output_df['GHG intensity HP cat [gCO2,eq/kWh]'] = pd.cut(\n",
    "    output_df['GHG intensity HP [gCO2,eq/kWh]'], bins=bins)\n",
    "output_df['GHG intensity Soued HP cat [gCO2,eq/kWh]'] = pd.cut(\n",
    "    output_df['GHG intensity Soued HP [gCO2,eq/kWh]'], bins=bins)\n",
    "\n",
    "# 3. Load file with selected dams per optimization scenario\n",
    "with open(pathlib.Path('intermediate/optim_scenarios.json'), 'r') as file:\n",
    "    optim_scenarios = json.load(file)\n",
    "    \n",
    "with open(optim_scenarios_5obj_path, 'r') as file:\n",
    "    optim_scenarios_5obj = json.load(file)\n",
    "    \n",
    "with open(optim_scenarios_5obj_soued_path, 'r') as file:\n",
    "    optim_scenarios_5obj_soued = json.load(file)\n",
    "    \n",
    "df_combined = ifcdb_df\n",
    "\n",
    "output_df_riv_ord = output_df.reset_index().merge(\n",
    "    ifcdb_df.reset_index()[['IFC_ID', 'RIV_ORD']], left_on=\"ifc_id\", right_on=\"IFC_ID\",\n",
    "    how=\"left\").set_index(\"ifc_id\")\n",
    "\n",
    "# Create a map of scenarios: optimization with g-res GHG emissions and GHG emissions from emission factors\n",
    "options = {\n",
    "    '5obj': {\n",
    "        'scenario': optim_scenarios_5obj\n",
    "    },\n",
    "    '5obj_soued': {\n",
    "        'scenario': optim_scenarios_5obj_soued\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b56ca4b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "def list_nan_indices(df: pd.DataFrame, col_name: str) -> List[int]:\n",
    "    return df[df[col_name].isna()].index.tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c06867df",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assert that there are no intensity values that are NaN\n",
    "assert not list_nan_indices(df=output_df, col_name='GHG intensity cat [gCO2,eq/kWh]')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e9e0a10",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compare_scenarios(\n",
    "        sc1, \n",
    "        sc2, \n",
    "        sc1_name: str = \"5obj\", \n",
    "        sc2_name: str = \"5obj_soued\"):\n",
    "    for (sc1, dams1), (sc2, dams2) in zip(sc1.items(), sc2.items()):\n",
    "        if not sc1 == sc2:\n",
    "            continue\n",
    "        print(f\"Scenario {sc1}\")\n",
    "        dam_difference_sc1_sc2 = set(dams1) - set(dams2)\n",
    "        if dam_difference_sc1_sc2:\n",
    "            dams_sc1_not_in_sc2 = \", \".join(list(map(str, dam_difference_sc1_sc2)))\n",
    "        else:\n",
    "            dams_sc1_not_in_sc2 = \"None\"\n",
    "        dam_difference_sc2_sc1 = set(dams2) - set(dams1)\n",
    "        if dam_difference_sc2_sc1:\n",
    "            dams_sc2_not_in_sc1 = \", \".join(list(map(str, dam_difference_sc2_sc1)))\n",
    "        else:\n",
    "            dams_sc2_not_in_sc1 = \"None\"\n",
    "        print(f\"Dams in {sc1_name} not featured in {sc2_name} - {dams_sc1_not_in_sc2}\")\n",
    "        print(f\"Dams in {sc2_name} not featured in {sc1_name} - {dams_sc2_not_in_sc1}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "493bfde5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct scenario Ib\n",
    "optim_scenarios_5obj['Ib'].append(150)\n",
    "optim_scenarios_5obj_soued['Ib'].append(165)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce21f5c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "compare_scenarios(optim_scenarios_5obj, optim_scenarios_5obj_soued)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f628d41f",
   "metadata": {},
   "outputs": [],
   "source": [
    "output_df.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "812643be",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Columns\\n----------\\n\"+\"\\n\".join(output_df.columns))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f74384f",
   "metadata": {},
   "source": [
    "## Create data for the radar plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b542797",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_radar = copy.deepcopy(\n",
    "    output_df_riv_ord[[\n",
    "        'forest_area_loss_km2', 'crop_area_loss_km2', 'Area, km2', 'GHG, tCO2eq/yr', \n",
    "        'GHG Soued, tCO2eq/yr', 'Firm Power Ratio, [%]', 'HP Production [GWh/year]', \n",
    "        'RIV_ORD']])\n",
    "# Metric 1\n",
    "df_radar['Loss of forest, [%]'] = \\\n",
    "    df_radar['forest_area_loss_km2'] / (df_radar['forest_area_loss_km2']).sum() * 100\n",
    "# Metric 2\n",
    "df_radar['Loss of agricultural land, [%]'] = \\\n",
    "    df_radar['crop_area_loss_km2'] / (df_radar['crop_area_loss_km2']).sum() * 100\n",
    "# Metric 3\n",
    "df_radar['GHG emissions, [%]'] = \\\n",
    "    df_radar['GHG, tCO2eq/yr'] / df_radar['GHG, tCO2eq/yr'].sum() * 100\n",
    "# Alternative Metric 3 using GHG emission information of Soued\n",
    "df_radar['GHG emissions (IPCC), [%]'] = \\\n",
    "    df_radar['GHG Soued, tCO2eq/yr'] / df_radar['GHG Soued, tCO2eq/yr'].sum() * 100\n",
    "\n",
    "# Metric 4\n",
    "# Firm Power Ratio, [%]\n",
    "# Metric 5\n",
    "# Percentage of total HP Production\n",
    "df_radar['HP Production, [%]'] = \\\n",
    "    df_radar['HP Production [GWh/year]'] / df_radar['HP Production [GWh/year]'].sum() * 100\n",
    "# Create two dataframes - one for plotting data with emissions according to Gres and the other one with\n",
    "# emissions according to IPCC\n",
    "df_radar = df_radar.drop(columns = [\n",
    "    'forest_area_loss_km2', 'crop_area_loss_km2', 'Area, km2', 'GHG, tCO2eq/yr', \n",
    "    'HP Production [GWh/year]', 'GHG Soued, tCO2eq/yr'\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f212a37b",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_radar.head(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c83990b1",
   "metadata": {},
   "source": [
    "### Plot the maps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0ab46e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "include_statistics = False\n",
    "if include_statistics:\n",
    "    plot_type = 'with_statistics'\n",
    "else:\n",
    "    plot_type: str = 'without_statistics'\n",
    "# Select scenario\n",
    "optim_scenario: str = '5obj'\n",
    "_optim_scenarios = options[optim_scenario]['scenario']\n",
    "_optim_scenarios_5obj = options['5obj']['scenario']\n",
    "_optim_scenarios_5obj_soued = options['5obj_soued']['scenario']\n",
    "# Create a plot with both scenarios as an option\n",
    "total_plot: bool = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "716b4e6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "output_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1d5bd7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "add_soued_plots = True\n",
    "    \n",
    "title_fontsize = 18\n",
    "\n",
    "fig, axs = plt.subplots(\n",
    "    2,3, figsize = (9,8), \n",
    "    gridspec_kw=dict(\n",
    "            left=.02, bottom=.02, right=.98, top=.98, wspace=.02, hspace=.0\n",
    "        ),\n",
    "    layout=\"constrained\")\n",
    "scenario_id_to_latex = {\n",
    "    \"Ib\" : \"$I_b$\",\n",
    "    \"Inb\" : \"$I_{nb}$\",\n",
    "    \"IIb\" : \"$II_b$\",\n",
    "    \"IInb\" : \"$II_{nb}$\",\n",
    "    \"IIIb\" : \"$III_b$\",\n",
    "    \"IIInb\" : \"$III_{nb}$\"}\n",
    "column_name = 'GHG intensity cat [gCO2,eq/kWh]'\n",
    "vmin = 0\n",
    "vmax = 500\n",
    "\n",
    "# reorder the optim_scenarios_dictionary\n",
    "desired_order = ['Ib', 'IIb', 'IIIb', 'Inb', 'IInb', 'IIInb']\n",
    "# Create a new dictionary with keys in the desired order\n",
    "reordered_scenarios_5obj = {key: _optim_scenarios_5obj[key] for key in desired_order}\n",
    "reordered_scenarios_5obj_soued = {key: _optim_scenarios_5obj_soued[key] for key in desired_order}\n",
    "\n",
    "for ix, (scenario_id, dams) in enumerate(reordered_scenarios_5obj.items()):\n",
    "    \"\"\" \"\"\"\n",
    "    dams_soued = reordered_scenarios_5obj_soued[scenario_id]\n",
    "    data = output_df.loc[dams]\n",
    "    data_soued = output_df.loc[dams_soued]\n",
    "\n",
    "    #print(f\"Scenario: {scenario_id}, Plotting dams {dams}\")\n",
    "    #print(set(dams) - set(dams_soued))\n",
    "    #print(set(dams_soued) - set(dams))\n",
    "    # Add plots\n",
    "    if ix == 3:\n",
    "        plt.subplots_adjust(right=0.9) \n",
    "        p1, p2, p3 = plot_mya_reservoirs(\n",
    "            data = data, \n",
    "            rivers_shp = r'bin/gis_layers/mya_rivers.shp',\n",
    "            outline_shp = r'bin/gis_layers/myanmar_outline/Myanmar_outline.shp',\n",
    "            column_name = column_name,\n",
    "            ax=axs.flat[ix], \n",
    "            title=scenario_id_to_latex[scenario_id],\n",
    "            marker_size = 'HP Production [GWh/year]', \n",
    "            marker_size_multiplier=2.5, \n",
    "            title_font_size=title_fontsize, \n",
    "            cmap='RdYlGn_r', \n",
    "            vmin=0, \n",
    "            vmax = 9, \n",
    "            plot_legends = (True, False, False),\n",
    "            legend_y_coords = (1.0, 1.0, 1.0),\n",
    "            offset=1.1)\n",
    "        if add_soued_plots:\n",
    "            plt.subplots_adjust(right=0.9) \n",
    "            p1, p2, p3 = plot_mya_reservoirs(\n",
    "                data = data_soued, \n",
    "                rivers_shp = None,\n",
    "                outline_shp = None,\n",
    "                column_name = None,\n",
    "                ax=axs.flat[ix], \n",
    "                title=scenario_id_to_latex[scenario_id],\n",
    "                marker_size = 'HP Production [GWh/year]', \n",
    "                marker_size_multiplier=2.5, \n",
    "                title_font_size=title_fontsize, \n",
    "                cmap=None, \n",
    "                vmin=0, \n",
    "                vmax = 9, \n",
    "                plot_legends = (True, False, False),\n",
    "                legend_y_coords = (1.0, 1.0, 1.0),\n",
    "                contour = True,\n",
    "                offset=1.1)\n",
    "    elif ix == 5:\n",
    "        p1, p2, p3 = plot_mya_reservoirs(\n",
    "            data = data, \n",
    "            rivers_shp = r'bin/gis_layers/mya_rivers.shp',\n",
    "            outline_shp = r'bin/gis_layers/myanmar_outline/Myanmar_outline.shp',\n",
    "            column_name = column_name, \n",
    "            ax=axs.flat[ix], \n",
    "            title=scenario_id_to_latex[scenario_id],\n",
    "            marker_size = 'HP Production [GWh/year]', \n",
    "            marker_size_multiplier=2.5, \n",
    "            title_font_size=title_fontsize, \n",
    "            cmap='RdYlGn_r', \n",
    "            vmin=0, \n",
    "            vmax = 9, \n",
    "            plot_legends = (True, True, True),\n",
    "            legend_y_coords = (1.0, 1.0, 0.7),\n",
    "            offset=1.1)\n",
    "        if add_soued_plots:\n",
    "            p1, p2, p3 = plot_mya_reservoirs(\n",
    "                data = data_soued, \n",
    "                rivers_shp = None,\n",
    "                outline_shp = None,\n",
    "                column_name = None, \n",
    "                ax=axs.flat[ix], \n",
    "                title=scenario_id_to_latex[scenario_id],\n",
    "                marker_size = 'HP Production [GWh/year]', \n",
    "                marker_size_multiplier=2.5, \n",
    "                title_font_size=title_fontsize, \n",
    "                cmap=None, \n",
    "                vmin=0, \n",
    "                vmax = 9,\n",
    "                contour = True,\n",
    "                plot_legends=(False, False, False),\n",
    "                offset=1.1)\n",
    "    else:\n",
    "        p1, p2, p3 = plot_mya_reservoirs(\n",
    "            data = data, \n",
    "            rivers_shp = r'bin/gis_layers/mya_rivers.shp',\n",
    "            outline_shp = r'bin/gis_layers/myanmar_outline/Myanmar_outline.shp',\n",
    "            column_name = column_name, \n",
    "            ax=axs.flat[ix], \n",
    "            title=scenario_id_to_latex[scenario_id],\n",
    "            marker_size = 'HP Production [GWh/year]', \n",
    "            marker_size_multiplier=2.5, \n",
    "            title_font_size=title_fontsize, \n",
    "            cmap='RdYlGn_r', \n",
    "            vmin=0, \n",
    "            vmax = 9,\n",
    "            plot_legends=(False, False, False))\n",
    "        if add_soued_plots:\n",
    "            p1, p2, p3 = plot_mya_reservoirs(\n",
    "                data = data_soued, \n",
    "                rivers_shp = None,\n",
    "                outline_shp = None,\n",
    "                column_name = None, \n",
    "                ax=axs.flat[ix], \n",
    "                title=scenario_id_to_latex[scenario_id],\n",
    "                marker_size = 'HP Production [GWh/year]', \n",
    "                marker_size_multiplier=2.5, \n",
    "                title_font_size=title_fontsize, \n",
    "                cmap=None, \n",
    "                vmin=0, \n",
    "                vmax = 9,\n",
    "                contour = True,\n",
    "                plot_legends=(False, False, False))\n",
    "\n",
    "# 'HP Production [GWh/year]'\n",
    "fig.tight_layout(pad=0.0)\n",
    "fig.show()\n",
    "fig.savefig(\n",
    "    pathlib.Path(\n",
    "        f'outputs/figures/moo/GHG_emissions_optim_maps_composite_{optim_scenario}.png'), \n",
    "    transparent=True, \n",
    "    bbox_inches='tight',\n",
    "    dpi=600)\n",
    "fig.savefig(\n",
    "    pathlib.Path(\n",
    "        f'outputs/figures/moo/GHG_emissions_optim_maps_composite_{optim_scenario}.svg'),\n",
    "    bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7a02055",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_radar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c9acf1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi\n",
    "from lib.notebook13 import calc_composite_metrics_radar_df\n",
    "def make_radar_plots(\n",
    "        axs, \n",
    "        df_radar: pd.DataFrame, \n",
    "        optim_scenarios: pd.DataFrame,\n",
    "        **kwargs) -> None:\n",
    "    \"\"\" \"\"\"\n",
    "    optim_scenarios_keys = list(optim_scenarios.keys())\n",
    "    optim_scenarios_alt = kwargs.get('optim_scenarios_alt', None)\n",
    "    \n",
    "    if optim_scenarios_alt:\n",
    "        # Process additional data containing alternative scenarios for comparison\n",
    "        # By convention alternative scenarios will be plotted with thin dashed lines\n",
    "        optim_scenarios_keys_alt = list(optim_scenarios_alt.keys())\n",
    "    \n",
    "    for ix, (scenario_id, dams) in enumerate(optim_scenarios.items()):\n",
    "        \"\"\" \"\"\"\n",
    "        if ix * 2 + 1 > len(optim_scenarios_keys):\n",
    "            break\n",
    "        key1 = optim_scenarios_keys[ix * 2]\n",
    "        key2 = optim_scenarios_keys[ix * 2 + 1]\n",
    "        dams1 = optim_scenarios[key1]\n",
    "        dams2 = optim_scenarios[key2]\n",
    "        \n",
    "        marker_size = 10\n",
    "        # Calculate the number of categories in the radar plot\n",
    "        categories=list(df_radar)[:]\n",
    "        N = len(categories)\n",
    "        # What will be the angle of each axis in the plot? (we divide the plot / number of variable)\n",
    "        angles = [n / float(N) * 2 * pi for n in range(N)]\n",
    "        angles += angles[:1] \n",
    "        \n",
    "        scenarios = (\"I\", \"II\", \"III\")\n",
    "        ax = axs[ix]\n",
    "\n",
    "        handles = [\n",
    "            Line2D([], [],  lw=0.4, c=color, marker=\"o\", markersize=marker_size/6, label=species)\n",
    "            for species, color in zip([\"Built\", \"Not Built\"], ['tab:blue', 'tab:orange'])\n",
    "        ]\n",
    "\n",
    "        if ix == 2:\n",
    "            legend = ax.legend(\n",
    "                handles=handles,\n",
    "                prop={'size': 8},\n",
    "                loc=(1, 0),       # bottom-right\n",
    "                labelspacing=0.5, # add space between labels\n",
    "                frameon=False     # don't put a frame\n",
    "            )\n",
    "            \n",
    "        data1 = df_radar.loc[dams1]\n",
    "        data1_summary = calc_composite_metrics_radar_df(data1)\n",
    "        data2 = df_radar.loc[dams2]\n",
    "        data2_summary = calc_composite_metrics_radar_df(data2)\n",
    "        \n",
    "        ax.set_theta_offset(pi / 2)\n",
    "        ax.set_theta_direction(-1)\n",
    "        \n",
    "        ax.set_yticks([])\n",
    "        ax.set_xticks([])\n",
    "        ax.yaxis.grid(True)\n",
    "        ax.xaxis.grid(True)\n",
    "        \n",
    "        categories_abbr = list(data1_summary.index)\n",
    "        ax.set_xticks(angles[:-1], categories_abbr, size=8)\n",
    "\n",
    "        # First series\n",
    "        values1=data1_summary.values.flatten().tolist()\n",
    "        values1 += values1[:1]\n",
    "        # Plot the first series\n",
    "        ax.plot(angles, values1, linewidth=0.75, linestyle='solid', label=\"Built\", alpha=0.5)\n",
    "        ax.fill(angles, values1, 'tab:blue', alpha=0.1)\n",
    "        ax.scatter(angles, values1, s=marker_size, zorder=10)\n",
    "        # Second series\n",
    "        values2=data2_summary.values.flatten().tolist()\n",
    "        values2 += values2[:1]\n",
    "        ax.plot(angles, values2, linewidth=0.75, linestyle='solid', label=\"Not Built\", alpha=0.5)\n",
    "        ax.fill(angles, values2, 'tab:orange', alpha=0.1)\n",
    "        ax.scatter(angles, values2, s=marker_size, zorder=10)\n",
    "\n",
    "        max_value = max(values1 + values2)\n",
    "        #upper_limit = min([value for value in ytick_values if value > max_value])\n",
    "        upper_limit = max_value\n",
    "        ax.set_ylim(0, upper_limit)\n",
    "\n",
    "        ax.set_xticks(angles[:-1])\n",
    "        ax.tick_params(pad=3, size=7)\n",
    "        \n",
    "        ax.spines[\"start\"].set_color(\"none\")\n",
    "        \n",
    "        HANGLES = np.linspace(0, 2 * np.pi)\n",
    "        \n",
    "        H0 = np.zeros(len(HANGLES))\n",
    "        H1 = np.ones(len(HANGLES)) * 20\n",
    "        H2 = np.ones(len(HANGLES)) * 40\n",
    "        H3 = np.ones(len(HANGLES)) * 60\n",
    "        H4 = np.ones(len(HANGLES)) * 80\n",
    "        H5 = np.ones(len(HANGLES)) * 100\n",
    "        \n",
    "        if upper_limit == 80:\n",
    "            Hs = {0: H0, 40: H2, 80: H4}\n",
    "        elif upper_limit == 100:\n",
    "            Hs = {0: H0, 20: H1, 60: H3, 100:H5}\n",
    "        else:\n",
    "            Hs = {0: H0, 20: H1, 40: H2, 60: H3, 100:H5}\n",
    "\n",
    "        for key, hangle in Hs.items():\n",
    "            if key > upper_limit:\n",
    "                break\n",
    "            ax.plot(HANGLES, hangle, lw=0.8, ls=(0, (5, 6)), c='Grey')\n",
    "\n",
    "        text_angle = -37.1\n",
    "        PAD = 2\n",
    "        \n",
    "        ax.set_title(\n",
    "            scenarios[ix], fontsize=14, loc='left', y=1.2, pad=-2, fontdict={'fontstyle': 'italic'})\n",
    "        ax.tick_params(axis='x', labelsize=9)\n",
    "        \n",
    "        for level in Hs:\n",
    "            if level == 0:\n",
    "                continue\n",
    "            if level > upper_limit:\n",
    "                break\n",
    "            text = f\"{level}%\"\n",
    "            ax.text(text_angle, level + PAD, text, size=6, alpha=0.7)\n",
    "            \n",
    "    if optim_scenarios_alt:\n",
    "        for ix, (scenario_id, dams) in enumerate(optim_scenarios_alt.items()):\n",
    "            \"\"\" \"\"\"\n",
    "            if ix * 2 + 1 > len(optim_scenarios_keys_alt):\n",
    "                break\n",
    "            categories=list(df_radar)[:]\n",
    "            N = len(categories)\n",
    "            # What will be the angle of each axis in the plot? (we divide the plot / number of variable)\n",
    "            angles = [n / float(N) * 2 * pi for n in range(N)]\n",
    "            angles += angles[:1] \n",
    "            ax = axs[ix]\n",
    "            key1_alt = optim_scenarios_keys_alt[ix * 2]\n",
    "            key2_alt = optim_scenarios_keys_alt[ix * 2 + 1]\n",
    "            dams1_alt = optim_scenarios_alt[key1_alt]\n",
    "            dams2_alt = optim_scenarios_alt[key2_alt]\n",
    "            \n",
    "            data1_alt = df_radar.loc[dams1_alt]\n",
    "            data1_summary_alt = calc_composite_metrics_radar_df(data1_alt)\n",
    "            data2_alt = df_radar.loc[dams2_alt]\n",
    "            data2_summary_alt = calc_composite_metrics_radar_df(data2_alt)\n",
    "            \n",
    "            # First series\n",
    "            values1_alt=data1_summary_alt.values.flatten().tolist()\n",
    "            values1_alt += values1_alt[:1]\n",
    "            # Plot the first series\n",
    "            ax.plot(\n",
    "                angles, values1_alt, marker='+',\n",
    "                ms=6,\n",
    "                color='dimgray', linewidth=0.15,\n",
    "                linestyle='none',\n",
    "                markeredgewidth=0.35,\n",
    "                label=\"Built\", alpha=1, zorder=20)\n",
    "            #ax.scatter(angles, values1, 'k+', zorder=10)\n",
    "            # Second series\n",
    "            values2_alt=data2_summary_alt.values.flatten().tolist()\n",
    "            values2_alt += values2_alt[:1]\n",
    "            ax.plot(\n",
    "                angles, values2_alt, marker='+',\n",
    "                color='dimgray', linewidth=0.15,\n",
    "                markeredgewidth=0.35,\n",
    "                ms=6,\n",
    "                linestyle='none', \n",
    "                label=\"Not Built\", alpha=1, zorder=20)\n",
    "            #ax.scatter(angles, values2, 'k+', zorder=10)\n",
    "            \n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12444b4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Plot statistics on a separate plot\n",
    "title_fontsize = 18\n",
    "fig, axs = plt.subplots(\n",
    "    3,3, figsize = (6.5,4), \n",
    "    gridspec_kw=dict(\n",
    "            left=.02, bottom=.02, right=.98, top=.98, wspace=.02, hspace=.0\n",
    "        ),\n",
    "    layout=\"constrained\")\n",
    "for ax in axs.flat[:]:\n",
    "    ax.remove()  \n",
    "# Remove the remaining (unused) axes \n",
    "gs = axs[0,0].get_gridspec()\n",
    "gs.update(wspace=1, hspace=1)\n",
    "statistics_grid = gs[:, :]\n",
    "nrows = 3\n",
    "ncols = 3\n",
    "\n",
    "gs00 = statistics_grid.subgridspec(nrows, ncols, hspace=0.45,wspace=0.6)\n",
    "\n",
    "polar_axs = []\n",
    "cart_axs = []\n",
    "cart_axs2 = []\n",
    "for nrow in range(nrows):\n",
    "    for ncol in range(ncols):\n",
    "        if nrow == 0:\n",
    "            polar_axs.append(fig.add_subplot(gs00[nrow, ncol], projection='polar'))\n",
    "        elif nrow == 1:\n",
    "            cart_axs.append(fig.add_subplot(gs00[nrow, ncol]))\n",
    "        else:\n",
    "            cart_axs2.append(fig.add_subplot(gs00[nrow, ncol]))\n",
    "\n",
    "make_radar_plots(\n",
    "    polar_axs, df_radar.drop(\n",
    "        columns=[\"RIV_ORD\", \"GHG emissions (IPCC), [%]\"]\n",
    "    ), \n",
    "    optim_scenarios_5obj, \n",
    "    optim_scenarios_alt = optim_scenarios_5obj_soued)\n",
    "#plot_histograms(cart_axs, output_df_riv_ord, optim_scenarios)\n",
    "plot_elev_dist(cart_axs, output_df_riv_ord, _optim_scenarios_5obj, df_combined)\n",
    "plot_rivord_histograms(cart_axs2, output_df_riv_ord, _optim_scenarios_5obj)\n",
    "\n",
    "\n",
    "# 'HP Production [GWh/year]'\n",
    "fig.tight_layout(pad=0.50)\n",
    "fig.show()\n",
    "fig.savefig(\n",
    "    pathlib.Path(f'outputs/figures/moo/GHG_emissions_stats_{optim_scenario}.png'), \n",
    "    transparent=True, dpi=600, bbox_inches='tight')\n",
    "fig.savefig(\n",
    "    pathlib.Path(\n",
    "        f'outputs/figures/moo/GHG_emissions_stats_{optim_scenario}.svg'),\n",
    "    bbox_inches='tight')\n",
    "fig.savefig(\n",
    "    pathlib.Path(\n",
    "        f'outputs/figures/moo/GHG_emissions_stats_{optim_scenario}.pdf'),\n",
    "    bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe96bf75",
   "metadata": {},
   "source": [
    "### Unused code"
   ]
  },
  {
   "cell_type": "raw",
   "id": "4260db82",
   "metadata": {},
   "source": [
    "### Create a statistics figure\n",
    "## Experimental code\n",
    "plot_elev_dist: bool = True\n",
    "plot_hists: bool = False\n",
    "plot_radars: bool = False\n",
    "plot_distr_intensity = False\n",
    "plot_joint_distr = False\n",
    "\n",
    "fig2, ax2s = plt.subplots(\n",
    "    1,3, figsize = (10,5.5), \n",
    "    gridspec_kw=dict(\n",
    "            left=.02, bottom=.02, right=.98, top=.98, wspace=.02, hspace=.0\n",
    "        ),\n",
    "    layout=\"constrained\")\n",
    "\n",
    "optim_scenarios_keys = list(optim_scenarios.keys())\n",
    "\n",
    "for ix, (scenario_id, dams) in enumerate(optim_scenarios.items()):\n",
    "    \"\"\" \"\"\"\n",
    "    if ix * 2 + 1 > len(optim_scenarios_keys):\n",
    "        break\n",
    "    key1 = optim_scenarios_keys[ix * 2]\n",
    "    key2 = optim_scenarios_keys[ix * 2 + 1]\n",
    "    dams1 = optim_scenarios[key1]\n",
    "    dams2 = optim_scenarios[key2]\n",
    "    \n",
    "    if plot_joint_distr:\n",
    "        \"\"\" \"\"\"\n",
    "        #sns.set_style(\"white\")\n",
    "        #sns.despine()\n",
    "        data_df1 = df_combined.loc[dams1]\n",
    "        data_df1['Scenario'] = \"Built\"\n",
    "        data_df2 = df_combined.loc[dams2]\n",
    "        data_df2['Scenario'] = \"Not Built\"\n",
    "        data_df = pd.concat([data_df1, data_df2], axis=0, ignore_index=True)\n",
    "        \n",
    "        ax = ax2s.flat[ix]\n",
    "        sns.boxplot(y=\"Basin\", x='HP Production [GWh/year]',\n",
    "            hue=\"Scenario\", palette=[\"tab:blue\", \"tab:orange\"],\n",
    "            data=data_df, ax = ax)\n",
    "        sns.stripplot(data_df, y=\"Basin\", x='HP Production [GWh/year]', size=4, hue=\"Scenario\")\n",
    "        #sns.despine(offset=10, trim=True)\n",
    "        #ax.set_xlim(0, 25000)\n",
    "        \"\"\"\n",
    "        custom_params = {\"axes.spines.right\": False, \"axes.spines.top\": False}\n",
    "        sns.set_theme(style=\"ticks\", rc=custom_params)\n",
    "        ax = ax2s.flat[ix]\n",
    "        data_df1 = df_combined.loc[dams1]\n",
    "        data_df1['Scenario'] = \"Built\"\n",
    "        data_df2 = df_combined.loc[dams2]\n",
    "        data_df2['Scenario'] = \"Not Built\"\n",
    "        data_df = pd.concat([data_df1, data_df2], axis=0, ignore_index=True)\n",
    "        pplot = sns.jointplot(\n",
    "            data=data_df, x='FSL (m)', y='HP Production [GWh/year]', \n",
    "            hue=\"Scenario\", kind='scatter', alpha = 0.3, joint_kws=dict(color='k', marker='o', s=100))\n",
    "        pplot.plot_marginals(sns.rugplot, color=\"r\", height=-.15, clip_on=False)\n",
    "        pplot.ax_marg_x.set_xlim(0, 1500)\n",
    "        pplot.ax_marg_y.set_ylim(0, 40000)\n",
    "        \"\"\"\n",
    "\n",
    "    \n",
    "    if plot_elev_dist:\n",
    "        \"\"\" \"\"\"\n",
    "        data1 = df_combined.loc[dams1]['FSL (m)'].to_numpy()\n",
    "        data2 = df_combined.loc[dams2]['FSL (m)'].to_numpy()\n",
    "        combined_data = np.concatenate([data1, data2])\n",
    "        # Determine the bins based on the combined data\n",
    "        bins = np.histogram_bin_edges(combined_data, bins=10)\n",
    "\n",
    "        ax=ax2s.flat[ix]\n",
    "        #color = ['skyblue', 'salmon']\n",
    "        ax.hist([data1, data2], bins=bins, alpha = 0.5, edgecolor='black',\n",
    "                label=['Built', 'Not Built'], color=None)\n",
    "        ax.set_ylim(0, 25)\n",
    "        ax.set_ylabel(\"Number of sites\")\n",
    "        ax.set_xlabel(\"Elevation, m.a.s.l.\")\n",
    "        ax.spines['top'].set_visible(False)\n",
    "        ax.spines['right'].set_visible(False)\n",
    "        if ix * 2 + 1 == len(optim_scenarios_keys) - 1:\n",
    "            ax.legend(frameon=False, loc=\"upper left\", bbox_to_anchor = (0.4, 1.1))      \n",
    "\n",
    "# Show the graph\n",
    "fig2.show()"
   ]
  },
  {
   "cell_type": "raw",
   "id": "7e612fa4",
   "metadata": {},
   "source": [
    "def example_plot(ax, fontsize=12, hide_labels=False):\n",
    "    ax.plot([1, 2])\n",
    "\n",
    "    ax.locator_params(nbins=3)\n",
    "    if hide_labels:\n",
    "        ax.set_xticklabels([])\n",
    "        ax.set_yticklabels([])\n",
    "    else:\n",
    "        ax.set_xlabel('x-label', fontsize=fontsize)\n",
    "        ax.set_ylabel('y-label', fontsize=fontsize)\n",
    "        ax.set_title('Title', fontsize=fontsize)\n",
    "\n",
    "\n",
    "# warnings.filterwarnings('ignore')\n",
    "title_fontsize = 18\n",
    "fig, axs = plt.subplots(\n",
    "    2,4, figsize = (9,8), \n",
    "    gridspec_kw=dict(\n",
    "            left=.02, bottom=.02, right=.98, top=.98, wspace=.02, hspace=.0\n",
    "        ),\n",
    "    layout=\"constrained\")\n",
    "scenario_id_to_latex = {\n",
    "    \"Ib\" : \"$I_b$\",\n",
    "    \"Inb\" : \"$I_{nb}$\",\n",
    "    \"IIb\" : \"$II_b$\",\n",
    "    \"IInb\" : \"$II_{nb}$\",\n",
    "    \"IIIb\" : \"$III_b$\",\n",
    "    \"IIInb\" : \"$III_{nb}$\"}\n",
    "column_name = 'GHG intensity cat [gCO2,eq/kWh]'\n",
    "vmin = 0\n",
    "vmax = 500\n",
    "\n",
    "for ix, (scenario_id, dams) in enumerate(optim_scenarios.items()):\n",
    "    \"\"\" \"\"\"\n",
    "    data = output_df.loc[dams]\n",
    "    if ix == 3:\n",
    "        example_plot(axs.flat[ix]) \n",
    "    elif ix == 5:\n",
    "        example_plot(axs.flat[ix])\n",
    "    else:\n",
    "        example_plot(axs.flat[ix])\n",
    "        \n",
    "# Remove the remaining (unused) axes\n",
    "for ax in axs.flat[-2:]:\n",
    "    ax.remove()  \n",
    "gs = axs[1, 2].get_gridspec()\n",
    "statistics_grid = gs[1, 2:4]\n",
    "nrows = 3\n",
    "ncols = 3\n",
    "gs00 = statistics_grid.subgridspec(nrows, ncols, hspace=0.5,wspace=0.7)\n",
    "\n",
    "polar_axs = []\n",
    "cart_axs = []\n",
    "cart_axs2 = []\n",
    "for nrow in range(nrows):\n",
    "    for ncol in range(ncols):\n",
    "        if nrow == 0:\n",
    "            polar_axs.append(fig.add_subplot(gs00[nrow, ncol], projection='polar'))\n",
    "        elif nrow == 1:\n",
    "            cart_axs.append(fig.add_subplot(gs00[nrow, ncol]))\n",
    "        else:\n",
    "            cart_axs2.append(fig.add_subplot(gs00[nrow, ncol]))\n",
    "\n",
    "make_radar_plots(polar_axs, df_radar, optim_scenarios)\n",
    "\n",
    "plot_histograms(cart_axs, output_df, optim_scenarios)\n",
    "plot_elev_dist(cart_axs2, output_df, optim_scenarios)\n",
    "\n",
    "# 'HP Production [GWh/year]'\n",
    "fig.tight_layout(pad=0.0)\n",
    "fig.show()\n",
    "fig.savefig(pathlib.Path('figures/moo/figsave.png'), transparent=True, dpi=300)"
   ]
  }
 ],
 "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
}