Tree_Diagrams.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c207f01a",
   "metadata": {},
   "source": [
    "# Tree Diagrams\n",
    "## A Climate Asset Pricing model -- AR6 analysis notebook\n",
    "\n",
    "This notebook lets users create tree diagrams to analyze node-by-node output of the Climate Asset Pricing model -- AR6."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91c2f745",
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "import os\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt \n",
    "import matplotlib as mpl\n",
    "\n",
    "from src.tree import TreeModel\n",
    "from src.climate import BPWClimate\n",
    "from src.emit_baseline import BPWEmissionBaseline\n",
    "from src.damage import BPWDamage\n",
    "from src.tools import import_csv\n",
    "from src.analysis.output_unpacker import OutputUnpacker\n",
    "from src.analysis.tree_diagrams import TreeDiagram\n",
    "\n",
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "plt.rcParams['figure.figsize'] = 16, 10\n",
    "params = {'legend.fontsize': 14,\n",
    "          'legend.frameon': True,\n",
    "          'figure.figsize': (16, 10),\n",
    "         'axes.labelsize': 20,\n",
    "         'axes.titlesize': 20,\n",
    "         'xtick.labelsize': 18,\n",
    "         'ytick.labelsize': 18,\n",
    "         'font.family': 'serif'}\n",
    "mpl.rcParams.update(params)\n",
    "\n",
    "# make base filename\n",
    "today = datetime.datetime.now()\n",
    "year = str(today.year)\n",
    "day = str(today.day)\n",
    "month = str(today.month)\n",
    "\n",
    "basefile = ''.join([month, '-', day, '-', year, '-'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49a46f32",
   "metadata": {},
   "source": [
    "## Make instances of model classes, store output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08476459",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\"\"\"Import header, indices, and data from reference .csv file.\n",
    "\"\"\"\n",
    "\n",
    "data_csv_file = 'research_runs'\n",
    "header, indices, data = import_csv(data_csv_file, delimiter=',', indices=2)\n",
    "\n",
    "\"\"\"Run TCREZClimate for runs of interest. To change which runs the code does,\n",
    "change desired_runs.\n",
    "\"\"\"\n",
    "\n",
    "# runs needing analysis\n",
    "done_runs = [0,1,2,3]\n",
    "\n",
    "tree_list = []\n",
    "damage_list = []\n",
    "climate_list = []\n",
    "emit_baseline_list = []\n",
    "\n",
    "for i in done_runs:\n",
    "    ra, eis, pref, growth, tech_chg, tech_scale, dam_func,\\\n",
    "            baseline_num, tip_on, bs_premium, d_unc, t_unc, nfl = data[i]\n",
    "\n",
    "    baseline_num = int(baseline_num)\n",
    "    dam_func = int(dam_func)\n",
    "    tip_on = int(tip_on)\n",
    "    d_unc = int(d_unc)\n",
    "    t_unc = int(t_unc)\n",
    "    nfl = int(nfl)\n",
    "\n",
    "    \"\"\"Initialize model classes. First is the tree model.\n",
    "    \"\"\"\n",
    "\n",
    "    tmp_tree = TreeModel(decision_times=[0, 10, 40, 80, 130, 180, 230],\n",
    "                  prob_scale=1.0)\n",
    "\n",
    "    \"\"\"Emission baseline model. We also run its setup function.\n",
    "    \"\"\"\n",
    "\n",
    "    tmp_baseline_emission_model = BPWEmissionBaseline(tree=tmp_tree,\n",
    "                                                  baseline_num=baseline_num)\n",
    "    tmp_baseline_emission_model.baseline_emission_setup()\n",
    "\n",
    "    \"\"\"Climate class. We set draws to the number of Monte Carlo samples to take\n",
    "    from damage distributions, such as TCRE, and if the floor is on.\n",
    "    \"\"\"\n",
    "\n",
    "    draws = 3 * 10**6\n",
    "    tmp_climate = BPWClimate(tmp_tree, tmp_baseline_emission_model, draws=draws)\n",
    "\n",
    "    \"\"\"Damage class. We set draws to the number of Monte Carlo samples to take\n",
    "    from damage distributions, such as TCRE. We also pass a list of constant\n",
    "    values of mitigation for the damage simulation.\n",
    "    \"\"\"\n",
    "\n",
    "    d_m = 0.01\n",
    "    mitigation_constants = np.arange(0, 1 + d_m, d_m)[::-1]\n",
    "    tmp_df = BPWDamage(tree=tmp_tree, emit_baseline=tmp_baseline_emission_model,\n",
    "                   climate=tmp_climate, mitigation_constants=mitigation_constants,\n",
    "                   draws=draws)\n",
    "\n",
    "    \"\"\"Run the damage simulation. If a damage simulation has already been run,\n",
    "    then comment the line below and uncomment the df.import_damages() line.\n",
    "\n",
    "    NOTE: import_damages has the optional argument for a filename. This is\n",
    "    important if you're varying the damage function across simulations.\n",
    "\n",
    "    The default is currently \"BPW_simulated_damages_TCRE.csv\".\n",
    "    \"\"\"\n",
    "\n",
    "    damsim_filename = ''.join([\"simulated_damages_df\", str(dam_func),\n",
    "                               \"_TP\", str(tip_on), \"_SSP\", str(baseline_num),\n",
    "                               \"_dunc\", str(d_unc), \"_tunc\", str(t_unc), \"_dmult\"])\n",
    "\n",
    "    tmp_df.import_damages(file_name=damsim_filename)\n",
    "    \n",
    "    tree_list.append(tmp_tree)\n",
    "    emit_baseline_list.append(tmp_baseline_emission_model)\n",
    "    climate_list.append(tmp_climate)\n",
    "    damage_list.append(tmp_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "101fbc50",
   "metadata": {},
   "outputs": [],
   "source": [
    "# list of prefixes to output files of EZClimate. i.e., the string before \"_node_period_output.csv\".\n",
    "# in EZClimate main file, this is the parameter \"name\" located at about line 42 \n",
    "\n",
    "# prefixes (\"name\" variable in main file)\n",
    "prefix_list = ['pref-run', 'feat-15', 'feat-25', 'feat-3']\n",
    "\n",
    "# path to data, in order of the prefixes listed above\n",
    "path_list = [os.getcwd()] * len(prefix_list) \n",
    "\n",
    "# file description - this will be used in plot titles and helps keep track of which file is which\n",
    "# in the prefix_list\n",
    "descriptions = ['2% discount rate', '1.5% discount rate', '2.5% discount rate', '3% discount rate']\n",
    "\n",
    "\n",
    "# make list of file names to be unpacked\n",
    "output_list = []\n",
    "picklefile_list = []\n",
    "\n",
    "# total files\n",
    "N_files = len(prefix_list)\n",
    "\n",
    "# populate output_list and picklefile_list\n",
    "for file in range(0, N_files):\n",
    "    tmp_filename = path_list[file] + prefix_list[file] + \"_node_period_output.csv\"\n",
    "    tmp_picklefile_name = path_list[file] + prefix_list[file] + \"_log.pickle\"\n",
    "    output_list.append(tmp_filename)\n",
    "    picklefile_list.append(tmp_picklefile_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "20c57805",
   "metadata": {},
   "outputs": [],
   "source": [
    "# use OutputUnpacker to \"unpack\" the files above\n",
    "\n",
    "# make one array of objects which correspond to the 'output' files (i.e., the files that end with\n",
    "# _node_period_output.csv) and another for the pickle files\n",
    "output_obj_list = []\n",
    "pickle_obj_list = []\n",
    "\n",
    "# populate these arrays\n",
    "for file in range(0, N_files):\n",
    "    tmp_output_obj = OutputUnpacker(output_list[file], descriptions[file], 'output', \n",
    "                                    tree=tree_list[file], emit_baseline=emit_baseline_list[file],\n",
    "                                    climate=climate_list[file], damage=damage_list[file])\n",
    "    output_obj_list.append(tmp_output_obj)\n",
    "    tmp_pickle_obj = OutputUnpacker(picklefile_list[file], descriptions[file], 'pickle',\n",
    "                                    tree=tree_list[file], emit_baseline=emit_baseline_list[file],\n",
    "                                    climate=climate_list[file], damage=damage_list[file])\n",
    "    pickle_obj_list.append(tmp_pickle_obj)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63cca01f",
   "metadata": {},
   "source": [
    "## Save your output?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5832b99",
   "metadata": {},
   "outputs": [],
   "source": [
    "save_fig = False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df925d43",
   "metadata": {},
   "source": [
    "### Mitigation\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e0299f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "for file in range(0, N_files):\n",
    "    tmp_Tree = TreeDiagram(6, pickle_obj_list[file].m_opt_node, False, descriptions[file], save_fig=save_fig)\n",
    "    tmp_Tree.makePlot()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e13b8c42",
   "metadata": {},
   "source": [
    "### Temperature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96fdf56d",
   "metadata": {},
   "outputs": [],
   "source": [
    "for file in range(0, N_files):\n",
    "    tmp_Tree = TreeDiagram(6, pickle_obj_list[file].temp_path, True, descriptions[file], save_fig=save_fig)\n",
    "    tmp_Tree.makePlot()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a81fd49",
   "metadata": {},
   "source": [
    "### Prices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55484434",
   "metadata": {},
   "outputs": [],
   "source": [
    "for file in range(0, N_files):\n",
    "    tmp_Tree = TreeDiagram(6, output_obj_list[file].price_node, False, descriptions[file], save_fig=save_fig)\n",
    "    tmp_Tree.makePlot()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a430196",
   "metadata": {},
   "source": [
    "### Concentrations "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0924b0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "for file in range(0, N_files):\n",
    "    tmp_Tree = TreeDiagram(6, output_obj_list[file].ghg_lvl_node, False, descriptions[file], save_fig=save_fig)\n",
    "    tmp_Tree.makePlot()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecf7f997",
   "metadata": {},
   "source": [
    "### Damages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c39d641",
   "metadata": {},
   "outputs": [],
   "source": [
    "for file in range(0, N_files):\n",
    "    tmp_Tree = TreeDiagram(6, pickle_obj_list[file].econ_dam_node, False, descriptions[file], save_fig=save_fig)\n",
    "    tmp_Tree.makePlot()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a304c8d",
   "metadata": {},
   "source": [
    "## Paper figures: cost and damage with highlighted boxes\n",
    "\n",
    "Remember to loop through only the runs you want: this bit of code assumes you only want the first run in the list made above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6041c61",
   "metadata": {},
   "outputs": [],
   "source": [
    "for file in range(0, 1):\n",
    "    tmp_Tree = TreeDiagram(N_periods=6, data=output_obj_list[file].price_node, \n",
    "                           path_notation=False, plot_title=None, save_fig=save_fig,\n",
    "                          fig_name=''.join([basefile, 'cost-tree']), is_cost=True)\n",
    "    tmp_Tree.makePlot(pfig=True)\n",
    "\n",
    "for file in range(0, 1):\n",
    "    tmp_Tree = TreeDiagram(N_periods=6, data=pickle_obj_list[file].econ_dam_node, \n",
    "                           path_notation=False, plot_title=None, save_fig=save_fig,\n",
    "                          fig_name=''.join([basefile, 'dam-tree']), is_cost=False)\n",
    "    tmp_Tree.makePlot(pfig=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e2f763e",
   "metadata": {},
   "source": [
    "## Analysis: Checking recombined node structure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "afa6ecc8",
   "metadata": {},
   "outputs": [],
   "source": [
    "nodes = np.arange(0, 63, 1, dtype=np.int)\n",
    "mit = pickle_obj_list[1].m_opt_node\n",
    "#mit = np.array([0.0] * len(nodes))\n",
    "dams = np.zeros_like(nodes, dtype=np.float32)\n",
    "for node in nodes:\n",
    "    dams[node] = damage_list[0]._damage_function_node(mit, node)\n",
    "\n",
    "\n",
    "tmp_Tree = TreeDiagram(N_periods=6, data=dams, \n",
    "                       path_notation=False, plot_title=None, save_fig=save_fig,\n",
    "                      fig_name=''.join([basefile, 'dam-tree']))\n",
    "tmp_Tree.makePlot(pfig=False)"
   ]
  }
 ],
 "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}