{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DiscRates class\n",
    "\n",
    "This class contains the discount rates for every year and discounts given values. Its attributes are:\n",
    "\n",
    " * tag (Tag): information about the source data\n",
    " * years (np.array): years\n",
    " * rates (np.array): discount rates for each year (between 0 and 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-10-29 21:39:51,385 - climada - DEBUG - Loading default config file: /Users/aznarsig/Documents/Python/climada_python/climada/conf/defaults.conf\n",
      "Help on class DiscRates in module climada.entity.disc_rates.base:\n",
      "\n",
      "class DiscRates(builtins.object)\n",
      " |  Defines discount rates and basic methods. Loads from\n",
      " |  files with format defined in FILE_EXT.\n",
      " |  \n",
      " |  Attributes:\n",
      " |      tag (Tag): information about the source data\n",
      " |      years (np.array): years\n",
      " |      rates (np.array): discount rates for each year (between 0 and 1)\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self)\n",
      " |      Empty initialization.\n",
      " |      \n",
      " |      Examples:\n",
      " |          Fill discount rates with values and check consistency data:\n",
      " |      \n",
      " |          >>> disc_rates = DiscRates()\n",
      " |          >>> disc_rates.years = np.array([2000, 2001])\n",
      " |          >>> disc_rates.rates = np.array([0.02, 0.02])\n",
      " |          >>> disc_rates.check()\n",
      " |      \n",
      " |          Read discount rates from year_2050.mat and checks consistency data.\n",
      " |      \n",
      " |          >>> disc_rates = DiscRates(ENT_TEMPLATE_XLS)\n",
      " |  \n",
      " |  append(self, disc_rates)\n",
      " |      Check and append discount rates to current DiscRates. Overwrite\n",
      " |      discount rate if same year.\n",
      " |      \n",
      " |      Parameters:\n",
      " |          disc_rates (DiscRates): DiscRates instance to append\n",
      " |      \n",
      " |      Raises:\n",
      " |          ValueError\n",
      " |  \n",
      " |  check(self)\n",
      " |      Check attributes consistency.\n",
      " |      \n",
      " |      Raises:\n",
      " |          ValueError\n",
      " |  \n",
      " |  clear(self)\n",
      " |      Reinitialize attributes.\n",
      " |  \n",
      " |  net_present_value(self, ini_year, end_year, val_years)\n",
      " |      Compute net present value between present year and future year.\n",
      " |      \n",
      " |      Parameters:\n",
      " |          ini_year (float): initial year\n",
      " |          end_year (float): end year\n",
      " |          val_years (np.array): cash flow at each year btw ini_year and\n",
      " |              end_year (both included)\n",
      " |      Returns:\n",
      " |          float\n",
      " |  \n",
      " |  plot(self, axis=None, **kwargs)\n",
      " |      Plot discount rates per year.\n",
      " |      \n",
      " |      Parameters:\n",
      " |          axis (matplotlib.axes._subplots.AxesSubplot, optional): axis to use\n",
      " |          kwargs (optional): arguments for plot matplotlib function, e.g. marker='x'\n",
      " |      \n",
      " |      Returns:\n",
      " |          matplotlib.axes._subplots.AxesSubplot\n",
      " |  \n",
      " |  read_excel(self, file_name, description='', var_names={'sheet_name': 'discount', 'col_name': {'year': 'year', 'disc': 'discount_rate'}})\n",
      " |      Read excel file following template and store variables.\n",
      " |      \n",
      " |      Parameters:\n",
      " |          file_name (str): absolute file name\n",
      " |          description (str, optional): description of the data\n",
      " |          var_names (dict, optional): name of the variables in the file\n",
      " |  \n",
      " |  read_mat(self, file_name, description='', var_names={'sup_field_name': 'entity', 'field_name': 'discount', 'var_name': {'year': 'year', 'disc': 'discount_rate'}})\n",
      " |      Read MATLAB file generated with previous MATLAB CLIMADA version.\n",
      " |      \n",
      " |      Parameters:\n",
      " |          file_name (str): absolute file name\n",
      " |          description (str, optional): description of the data\n",
      " |          var_names (dict, optional): name of the variables in the file\n",
      " |  \n",
      " |  select(self, year_range)\n",
      " |      Select discount rates in given years.\n",
      " |      \n",
      " |      Parameters:\n",
      " |          year_range (np.array): continuous sequence of selected years.\n",
      " |      \n",
      " |      Returns:\n",
      " |          DiscRates\n",
      " |  \n",
      " |  write_excel(self, file_name, var_names={'sheet_name': 'discount', 'col_name': {'year': 'year', 'disc': 'discount_rate'}})\n",
      " |      Write excel file following template.\n",
      " |      \n",
      " |      Parameters:\n",
      " |          file_name (str): absolute file name to write\n",
      " |          var_names (dict, optional): name of the variables in the file\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from climada.entity import DiscRates\n",
    "help(DiscRates)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An example of use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "net present value: 1.01099e+08\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "from climada.entity import DiscRates\n",
    "\n",
    "# define discount rates\n",
    "disc = DiscRates()\n",
    "disc.years = np.arange(1950, 2100)\n",
    "disc.rates = np.ones(disc.years.size) * 0.02\n",
    "disc.rates[51:55] = 0.025\n",
    "disc.rates[95:120] = 0.035\n",
    "disc.check()\n",
    "disc.plot()\n",
    "\n",
    "# Compute net present value between present year and future year.\n",
    "ini_year = 2019\n",
    "end_year = 2050\n",
    "val_years = np.zeros(end_year-ini_year+1)\n",
    "val_years[0] = 100000000 # initial investment\n",
    "val_years[10:] = 75000 # maintenance from 10th year\n",
    "npv = disc.net_present_value(ini_year, end_year, val_years)\n",
    "print('net present value: {:.5e}'.format(npv))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Read discount rates of an Excel file\n",
    "\n",
    "Discount rates defined in an excel file following the template provided in sheet `discount` of `climada_python/data/system/entity_template.xlsx` can be ingested directly using the method `read_excel()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Read file: /Users/aznarsig/Documents/Python/climada_python/data/system/entity_template.xlsx\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1c248d4978>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZgAAAEWCAYAAABbgYH9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3df7xVVZ3/8dc7wfyBBurVkB+iDankFDpXtKGZ8Uc/hFGRvmY6pcbXhpzU0cmvX82atNLvqJWWU0mUqDSmluJXciwjxchU7IJXUMkg0ERQrvkDwp/gZ/7Y6+bmcO695/5YXM7l/Xw8zuOes/Za+6y92Pd+WGvtvZciAjMzs572tt6ugJmZ9U0OMGZmloUDjJmZZeEAY2ZmWTjAmJlZFg4wZmaWhQOMbbEkTZH0771dD7O+ygHG+iRJT0h6RdIaSS9Kuk/SqZL+cs5HxKkR8dXerGdbUv0/2MP7vEfSp3tyn2btcYCxvuyoiNgB2AO4BDgXuLp3q5SHpH69XQezSg4w1udFxEsRMRP4OHCypP0AJF0r6aL0fhdJt6fezvOSft3a25E0TNIMSS2S/iTp2yn9bZK+KOlJSaskTZf0jrTtEEnLy/Uo90okXSjpx6nMGkmPSmpM234IDAd+KunPkv5v5TG17l/SuZKeAa6RNCgdQ4ukF9L7oSn/xcDfAd9O+2w9hn0kzUrH/Lik40rfMV7SY6l+T0v6Pz34z2JbAAcY22JExIPAcoo/tJXOTtsagN2A84GQtBVwO/AkMAIYAtyYynwqvQ4F9gIGAN/uRJWOTvsaCMxsLRsRJwJ/pOiBDYiIy9oo/05gJ4oe2mSK3+dr0ufhwCulfX4B+DVwetrn6ZK2B2YBPwJ2BU4AvivpPWn/VwOfSb3A/YC7O3FsZg4wtsVZQfFHudIbwGBgj4h4IyJ+HcWD+sYAuwPnRMTaiHg1Iu5NZT4BXB4RSyPiz8DngeM7MVx1b0TcERHrgR8C7+vksbwJXBARr0XEKxHxp4i4JSJejog1wMXAP7RT/kjgiYi4JiLWRcR84Bbg2LT9DWCUpB0j4oW03axmDjC2pRkCPF8l/WvAEuAXkpZKOi+lDwOejIh1VcrsTtGzafUk0I+iB1SLZ0rvXwa26eRcSktEvNr6QdJ2kr6XhuxWA3OAgakXVs0ewEFpWPBFSS9SBM13pu3/CxgPPCnpV5Le34m6meGJQdtiSDqQIsDcW7kt/Y//bODsNEQ0W9JvgaeA4ZL6VQkyKyj+SLcaDqwDnqUIPtuVvnsriuG3WtXymPPKPGcDewMHRcQzkkYDDwFqI/9TwK8i4kNVdx7xW2CCpP7A6cCPKQKuWU3cg7E+T9KOko6kmO/4r4hYWCXPkZL+SpKA1cD69HoQWAlcIml7SdtIGpuK3QD8m6Q9JQ0A/h9wUwpEv6fokfxj+gP9ReDtnaj2sxTzOp2xA8W8y4uSdgIu6GCftwPvlnSipP7pdaCkfSVtLekTkt4REW/wVpuY1cwBxvqyn0paQ/E/9S8AlwOT2sg7Evgl8GfgfuC7EXFPmh85Cvgrion35RRXowFMo5g7mQMsA14FzoDiyjXgs8APgKeBtalsrf4D+GIauqr16q1vAtsCzwEPAD+v2P4t4Nh0hdmVqdf2YeB4it7YM8ClvBUITwSeSMNtpwKf7ET9zZAXHDMzsxzcgzEzsywcYMzMLAsHGDMzy8IBxszMstgi7oPZZZddYsSIEb1dDTOzujJv3rznIqIz929tYIsIMCNGjKCpqam3q2FmVlckPdlxrrZ5iMzMzLJwgDEzsywcYMzMLAsHGDMzy8IBxszMssgWYNIys7MlLUrLwZ5ZJc8+ku6X9FrlA/0kHZGWcF1SWpuD9OTauZIWS7pJ0ta5jsHMzLouZw9mHXB2ROwLHAycJmlURZ7ngX8Fvl5OTGtnfAcYB4wCTiiVvRS4IiJGAi8Ap+Q7BDMz66psASYiVrYusZoeC76IYrGncp5VaVGjNyqKjwGWpKVoX6dYx2NCWqvjMODmlO864Jhcx2BmZl23SeZgJI0A9gfm1lhkCMUaHq2Wp7SdgRdLKwu2plf7zsmSmiQ1tbS0dKXaZmbWDdkDTFrp7xbgrIhYXWuxKmnRTvrGiRFTI6IxIhobGrr8pAMzM+uirAEmLRV7C3B9RMzoRNHlbLj291CKFfeeAwZK6leRbmZmm5mcV5EJuBpYFBGXd7L4b4GR6YqxrSmWdJ0ZxfKbs4FjU76Tgdt6qs5mZtZzcj7scizFmt4LJTWntPOB4QARMUXSO4EmYEfgTUlnAaMiYrWk04E7ga2AaRHxaNrHucCNki4CHqIIYmZmtpnJFmAi4l6qz5mU8zxDMcxVbdsdwB1V0pdSXGVmZmabMd/Jb2ZmWTjAmJlZFg4wZmaWhQOMmZll4QBjZmZZOMCYmVkWDjBmZpaFA4yZmWXhAGNmZlk4wJiZWRYOMGZmloUDjJmZZeEAY2ZmWTjAmJlZFg4wZmaWhQOMmZllkXPJ5GGSZktaJOlRSWdWySNJV0paImmBpANS+qGSmkuvVyUdk7ZdK2lZadvoXMdgZmZdl3PJ5HXA2RExX9IOwDxJsyLisVKeccDI9DoIuAo4KCJmA6MBJO0ELAF+USp3TkTcnLHuZmbWTdl6MBGxMiLmp/drgEXAkIpsE4DpUXgAGChpcEWeY4GfRcTLuepqZmY9b5PMwUgaAewPzK3YNAR4qvR5ORsHoeOBGyrSLk5DaldIensb3zlZUpOkppaWli7X3czMuiZ7gJE0ALgFOCsiVldurlIkSmUHA38N3Fna/nlgH+BAYCfg3GrfGxFTI6IxIhobGhq6cQRmZtYVWQOMpP4UweX6iJhRJctyYFjp81BgRenzccCtEfFGa0IaeouIeA24BhjT8zU3M7PuynkVmYCrgUURcXkb2WYCJ6WryQ4GXoqIlaXtJ1AxPNY6R5P2fwzwSI9X3szMui3nVWRjgROBhZKaU9r5wHCAiJgC3AGMp7hK7GVgUmvhNG8zDPhVxX6vl9RAMbzWDJya7QjMzKzLsgWYiLiX6nMs5TwBnNbGtifYeMKfiDisJ+pnZmZ5+U5+MzPLwgHGzMyycIAxM7MsHGDMzCwLBxgzM8vCAcbMzLJwgDEzsywcYMzMLAsHGDMzy8IBxszMsnCAMTOzLBxgzMwsCwcYMzPLwgHGzMyycIAxM7MsHGDMzCyLnEsmD5M0W9IiSY9KOrNKHkm6UtISSQskHVDatl5Sc3rNLKXvKWmupMWSbpK0da5jMDOzrsvZg1kHnB0R+wIHA6dJGlWRZxwwMr0mA1eVtr0SEaPT6+hS+qXAFRExEngBOCXbEZiZWZdlCzARsTIi5qf3a4BFbLwE8gRgehQeAAZKGtzWPiUJOAy4OSVdBxzT45U3M7Nu2yRzMJJGAPsDcys2DQGeKn1ezltBaBtJTZIekNQaRHYGXoyIdVXyV37n5FS+qaWlpQeOwszMOqNf7i+QNAC4BTgrIlZXbq5SJNLP4RGxQtJewN2SFgKV5cv5N0yMmApMBWhsbKyax8zM8snag5HUnyK4XB8RM6pkWQ4MK30eCqwAiIjWn0uBeyh6QM9RDKP1q8xvZmabl5xXkQm4GlgUEZe3kW0mcFK6muxg4KWIWClpkKS3p/3sAowFHouIAGYDx6byJwO35ToGMzPrupxDZGOBE4GFkppT2vnAcICImALcAYwHlgAvA5NSvn2B70l6kyIIXhIRj6Vt5wI3SroIeIgiiJmZ2WYmW4CJiHupPsdSzhPAaVXS7wP+uo0yS4ExPVFHMzPLx3fym5lZFg4wZmaWRU1DZJJ2pZhT2R14BXgEaIqINzPWzczM6li7AUbSocB5wE4UE+qrgG0o7p5/l6SbgW9Uub/FzMy2cB31YMYD/xwRf6zckO5FORL4EMW9LmZmZn/RboCJiHPa2bYO+P89XiMzM+sTOjXJL+lgSXdL+o2kibkqZWZm9a+jOZh3RsQzpaTPAUdT3N9yH3BrxrqZmVkd62gOZoqkecDXIuJV4EXgn4A3qf7gSTMzM6CDIbKIOAZoBm6XdCJwFkVw2Q6vw2JmZu3ocA4mIn4KfAQYCMwAHo+IKyPCi6yYmVmb2g0wko6WdC9wN8XNlccDEyXdIOldm6KCZmZWnzqag7kIeD+wLXBHRIwBPidpJHAxRcAxMzPbSEcB5iWKILItxV38AETEYhxczMysHR3NwUykmNBfR3H1mJmZWU06CjCvRsR/RsSUtp43JmlAG+nDJM2WtEjSo5LOrJJHkq6UtETSAkkHpPTRku5P5RZI+nipzLWSlklqTq/RnTheMzPbRDoaIrstrUZ5GzAvItYCSNoLOBQ4Dvg+cHOVsuuAsyNivqQdgHmSZpVWpgQYB4xMr4OAq9LPl4GTImKxpN1T2Tsj4sVU7pyIqPadZma2mejoWWSHSxoPfAYYK2kQReB4HPhv4OSKO/3LZVcCK9P7NZIWAUOAcoCZAExPK1s+IGmgpMER8fvSflZIWgU0UNzoaWZmdaDD9WAi4g7gju58iaQRwP7A3IpNQ4CnSp+Xp7SVpbJjgK2BP5TyXSzpS8BdwHkR8VqV75wMTAYYPnx4d6pvZmZdkH1FyzRHcwtwVpV5HFUpEqWyg4EfApNKi5t9HtgHOJBinZpzq31vREyNiMaIaGxoaOjmUZiZWWdlDTCS+lMEl+sjYkaVLMuBYaXPQ4EVqeyOFMNwX4yIB1ozRMTKKLwGXAOMyVV/MzPrumwBRpKAq4FFEXF5G9lmAielq8kOBl6KiJWStqZ4UvP0iPhJxX4Hl/Z/DMUTBszMbDPT4RxMK0kfAEZGxDWSGoABEbGsnSJjgROBhelKNIDzgeEAETGFYm5nPLCE4sqxSSnfccDfAztL+lRK+1RENAPXp+8XxYM4T631GMzMbNNRcQFXB5mkC4BGYO+IeHe6dPgnETE2dwV7QmNjYzQ1NfV2NczM6oqkeRHR2NXytQ6RTaRYaGwtFJcOAzt09UvNzKzvqzXAvJ7uVQkASdvnq5KZmfUFtQaYH0v6HjBQ0j8DvwR+kK9aZmZW72qa5I+Ir0v6EMUyyXsDX4qIWVlrZmZmda2mACPp0og4F5hVJc3MzGwjtQ6RfahK2rierIiZmfUt7fZgJP0L8FlgL0kLSpt2AH6Ts2JmZlbfOhoi+xHwM+A/gPNK6Wsi4vlstTIzs7rX0eP6X6JYNvkEAEm7AtsAAyQNiIg/5q+imZnVo5rmYCQdJWkxsAz4FfAERc/GzMysqlon+S8CDgZ+HxF7AofjORgzM2tHrQHmjYj4E/A2SW+LiNnA6Iz1MjOzOlfr05RfTAuHzaF4mvEqiqWTzczMqqq1BzOB4nH6/wb8nGL54qNyVcrMzOpfhz0YSVsBt0XEB4E3geuy18rMzOpehz2YiFgPvCzpHZugPmZm1kfUOkT2KsXKlFdLurL11V4BScMkzZa0SNKjks6skkdpX0skLZB0QGnbyZIWp9fJpfS/kbQwlbkyLZ1sZmabmVon+f87vTpjHXB2RMyXtAMwT9KsiHislGccMDK9DgKuAg6StBPQuopmpLIzI+KFlGcy8ADFkstH4HtyzMw2O7U+rr/T8y4RsRJYmd6vkbQIGAKUA8wEYHpazOwBSQMlDQYOAWa1Po5G0izgCEn3ADtGxP0pfTpwDB0EmKUta/n49+7v7CGYmVk31DpE1i2SRgD7A3MrNg0Bnip9Xp7S2ktfXiW92ndOltQkqemNN97oTvXNzKwLah0i67J0/8wtwFkRsbpyc5Ui0YX0jRMjpgJTARobG+Omz7y/5jqbmRn8+NTula/1WWQfqyWtSp7+FMHl+oiYUSXLcmBY6fNQYEUH6UOrpJuZ2Wam1iGyz9eY9hfp6q6rgUURcXkb2WYCJ6WryQ4GXkpzN3cCH5Y0SNIg4MPAnWnbGkkHp/2fBNxW4zGYmdkm1NGCY+OA8cCQisuSd6TjR8WMBU6kuLy5OaWdDwwHiIgpFFeBjQeWUDwpYFLa9rykrwK/TeW+Ulp/5l+Aa4FtKSb3fQWZmdlmqKM5mBVAE3A0MK+UvobisTFtioh7qT5nUs4TwGltbJsGTKuS3gTs126tzcys13W04NjDwMOSfhQRvhTLzMxqVutVZGMkXQjskcqIogOyV66KmZlZfas1wFxNMSQ2D1ifrzpmZtZX1BpgXooIT6abmVnNag0wsyV9DZgBvNaaGBHzs9TKzMzqXq0B5qD0s7GUFsBhPVsdMzPrK2p92OWhuStiZmZ9S00BRtKXqqVHxFd6tjpmZtZX1DpEtrb0fhvgSGBRz1fHzMz6ilqHyL5R/izp6xTPETMzM6uqq+vBbAf4JkszM2tTrXMwC3lr3ZWtgAbA8y9mZtamWudgjiy9Xwc8GxEdPU3ZzMy2YDUNkUXEk8BA4ChgIjAqZ6XMzKz+1bqi5ZnA9cCu6XW9pDNyVszMzOpbrUNkpwAHRcRaAEmXAvcD/5mrYmZmVt9qvYpMbPgU5fV0sJiYpGmSVkl6pI3tgyTdKmmBpAcl7ZfS95bUXHqtlnRW2nahpKdL28bXWH8zM9vEau3BXAPMlXRr+nwMxSP823Mt8G1gehvbzweaI2KipH2A7wCHR8TjwGgASVsBTwO3lspdERFfr7HeZmbWS2qd5L8cmAQ8D7wATIqIb3ZQZk7K35ZRwF0p7++AEZJ2q8hzOPCHdJGBmZnVkVon+Q8GFkfElRHxLWCJpIM6KteBh4GPpv2PoVgtc2hFnuOBGyrSTk/DatMkDWqnzpMlNUlqamlp6WZVzcyss2qdg7kK+HPp89qU1h2XAIMkNQNnAA9R3GMDgKStgaOBn1TU410UQ2grgQ0eYVMWEVMjojEiGhsaGrpZVTMz66xa52AUEa138hMRb0qqtWxVEbGaYtgNSQKWpVerccD8iHi2VOYv7yV9H7i9O3UwM7N8au3BLJX0r5L6p9eZwNLufLGkgamXAvBpYE4KOq1OoGJ4TNLg0seJQNUr1MzMrPfV2gs5FbgS+CLFM8nuAia3V0DSDcAhwC6SlgMXAP0BImIKsC8wXdJ64DGKe21ay24HfAj4TMVuL5M0OtXhiSrbzcxsM6HSyFef1djYGE1NTb1dDTOzuiJpXkQ0drV8rVeRXSZpxzQ8dpek5yR9sqtfamZmfV+tczAfTvMjRwLLgXcD52SrlZmZ1b1aA0z/9HM8cENEtHcDpZmZWc2T/D+V9DvgFeCzkhqAV/NVy8zM6l2tj4o5D3g/0BgRb1DcaDkhZ8XMzKy+tduDkXRYRNwt6aOltHKWGbkqZmZm9a2jIbJ/AO6mWMmyUuAAY2ZmbWg3wETEBennpE1THTMz6ys6GiL7XHvb02P8zczMNtLRENkO6efewIHAzPT5KGBOrkqZmVn962iI7MsAkn4BHBARa9LnC9nwMfpmZmYbqPVGy+HA66XPrwMjerw2ZmbWZ9R6o+UPgQcl3Upx9dhE4LpstTIzs7pXU4CJiIsl/Qz4u5Q0KSIeylctMzOrdzWvShkR84H5GetiZmZ9SK1zMJ0maZqkVZKqrjopaZCkWyUtkPSgpP1K256QtFBSs6SmUvpOkmZJWpx+DspVfzMz655sAQa4Fjiine3nA80R8V7gJOBbFdsPjYjRFYvdnAfcFREjKVbVPK8H62tmZj0oW4CJiDlAe4/1H0URJIiI3wEjJO3WwW4n8NbFBdcBx3S3nmZmlkfOHkxHHgY+CiBpDLAHMDRtC+AXkuZJmlwqs1tErARIP3dta+eSJktqktTU0tKS5QDMzKxtvRlgLgEGSWoGzgAeAtalbWMj4gBgHHCapL/v7M4jYmpENEZEY0NDQ49V2szMalPzVWQ9LS3BPAlAxRoAy9KLiFiRfq5K996MoXg0zbOSBkfESkmDgVW9UnkzM+tQr/VgJA2UtHX6+GlgTkSslrS9pB1Snu2BDwOtV6LNBE5O708GbtuUdTYzs9pl68FIugE4BNhF0nLgAqA/QERMAfYFpktaDzwGnJKK7gbcmhY26wf8KCJ+nrZdAvxY0inAH4GP5aq/mZl1T7YAExEndLD9fmBklfSlwPvaKPMn4PAeqaCZmWXVm5P8ZmbWhznAmJlZFg4wZmaWhQOMmZll4QBjZmZZOMCYmVkWDjBmZpaFA4yZmWXhAGNmZlk4wJiZWRYOMGZmloUDjJmZZeEAY2ZmWTjAmJlZFg4wZmaWhQOMmZllkS3ASJomaZWkR9rYPkjSrZIWSHpQ0n4pfZik2ZIWSXpU0pmlMhdKelpSc3qNz1V/MzPrnpw9mGuBI9rZfj7QHBHvBU4CvpXS1wFnR8S+wMHAaZJGlcpdERGj0+uODPU2M7MekC3ARMQc4Pl2sowC7kp5fweMkLRbRKyMiPkpfQ2wCBiSq55mZpZHb87BPAx8FEDSGGAPYGg5g6QRwP7A3FLy6WlYbZqkQW3tXNJkSU2SmlpaWnq67mZm1oHeDDCXAIMkNQNnAA9RDI8BIGkAcAtwVkSsTslXAe8CRgMrgW+0tfOImBoRjRHR2NDQkOkQzMysLf1664tT0JgEIEnAsvRCUn+K4HJ9RMwolXm29b2k7wO3b8o6m5lZ7XqtByNpoKSt08dPA3MiYnUKNlcDiyLi8ooyg0sfJwJVr1AzM7Pel60HI+kG4BBgF0nLgQuA/gARMQXYF5guaT3wGHBKKjoWOBFYmIbPAM5PV4xdJmk0EMATwGdy1d/MzLonW4CJiBM62H4/MLJK+r2A2ihzYs/UzszMcvOd/GZmloUDjJmZZeEAY2ZmWTjAmJlZFg4wZmaWhQOMmZll4QBjZmZZOMCYmVkWDjBmZpaFA4yZmWXhAGNmZlk4wJiZWRYOMGZmloUDjJmZZeEAY2ZmWTjAmJlZFlkDjKRpklZJqrq0saRBkm6VtEDSg5L2K207QtLjkpZIOq+UvqekuZIWS7qptOyymZltRnL3YK4Fjmhn+/lAc0S8FzgJ+BaApK2A7wDjgFHACZJGpTKXAldExEjgBd5aatnMzDYjWQNMRMwBnm8nyyjgrpT3d8AISbsBY4AlEbE0Il4HbgQmSBJwGHBzKn8dcEyu+puZWdf19hzMw8BHASSNAfYAhgJDgKdK+ZantJ2BFyNiXUX6RiRNltQkqamlpSVT9c3MrC29HWAuAQZJagbOAB4C1gGqkjfaSd84MWJqRDRGRGNDQ0NP1dfMzGrUrze/PCJWA5MA0vDXsvTaDhhWyjoUWAE8BwyU1C/1YlrTzcxsM9OrPRhJA0tXgX0amJOCzm+BkemKsa2B44GZERHAbODYVOZk4LZNXW8zM+tY1h6MpBuAQ4BdJC0HLgD6A0TEFGBfYLqk9cBjpCvCImKdpNOBO4GtgGkR8Wja7bnAjZIuohhSuzrnMZiZWdeo6BT0bY2NjdHU1NTb1TAzqyuS5kVEY1fL9/Ykv5mZ9VEOMGZmloUDjJmZZeEAY2ZmWWwRk/yS1gCP93Y9NgO7UNxLZG6LVm6HgtuhUNkOe0REl+9U79UbLTehx7tzJURfIanJ7VBwWxTcDgW3Q6Gn28FDZGZmloUDjJmZZbGlBJipvV2BzYTb4S1ui4LboeB2KPRoO2wRk/xmZrbpbSk9GDMz28QcYMzMLIu6DDCShkmaLWmRpEclnZnSd5I0S9Li9HNQSpekKyUtkbRA0gGlfZ2c8i+WdHJvHVNXdKEdPpGOf4Gk+yS9r7SvIyQ9ntrovN46pq7qbFuUyh0oab2kY0tpW8w5kbYdIqk55f9VKb1uz4ku/G68Q9JPJT2c8k8q7atuzwdoty0+lj6/Kamxoszn07/745I+Ukrv3DkREXX3AgYDB6T3OwC/B0YBlwHnpfTzgEvT+/HAzyhWxDwYmJvSdwKWpp+D0vtBvX18Gdvhb1uPDxhXaoetgD8AewFbUyxlPaq3jy9nW5SO+27gDuDYLfScGEixVMbw9HnXvnBOdKEdzi+9bwCeT8dd1+dDB22xL7A3cA/QWMo/Kv17vx3YM50HW3XlnKjLHkxErIyI+en9GmARMASYAFyXsl0HHJPeTwCmR+EBilUxBwMfAWZFxPMR8QIwCzhiEx5Kt3S2HSLivnScAA9QrAgKMAZYEhFLI+J14Ma0j7rRhXMCimW6bwFWldK2qHMC+CdgRkT8MZVpbYu6Pie60A4B7CBJwACKALOOOj8foO22iIhFEVHtCScTgBsj4rWIWAYsoTgfOn1O1GWAKZM0AtgfmAvsFhEroWhUYNeUbQjwVKnY8pTWVnrdqbEdyk6h6NVBH2oHqK0tJA0BJgJTKor3mbao8Zx4NzBI0j2S5kk6KaVvae3wbYr/0a8AFgJnRsSb9KF2gI3aoi099veyrh8VI2kAxf9Az4qI1cV/PqpnrZIW7aTXlU60Q2v+QykCzAdak6pkq7t2gE61xTeBcyNifUWePtEWnWiHfsDfAIcD2wL3S3qALa8dPgI0A4cB7wJmSfo1faQdYOO2aC9rlbSgeoek3bao2x6MpP4UjXV9RMxIyc+moS/Sz9bu/nJgWKn4UIr/qbSVXjc62Q5Iei/wA2BCRPwpJdd9O0Cn26KRYuntJ4Bjge9KOoY+0BZd+N34eUSsjYjngDnA+9jy2mESxVBhRMQSYBmwD32gHaDNtmhLz/297O0JqK68KCLsdOCbFelfY8MJvMvS+39kw0n+B1P6ThQn0qD0Wgbs1NvHl7EdhlOMp/5tRf5+FJOXe/LW5N17evv4crZFRZ5r2XCSf0s6J/YF7krnwHbAI8B+9X5OdKEdrgIuTO93A56meLJwXZ8P7bVFafs9bDjJ/x42nORfSjHB3+lzotcPvosN9gGKrtkCim5tM8WVYjunX5bF6edOpQb+DsUVEAsrGvN/pz+6S4BJvX1smdvhB8ALpbxNpX2Np7i65A/AF3r72HK3RUXZa0kBZks7J1KZcyiuJHuEYvik7s+JLvxu7A78Iv19eAT4ZF84Hzpoi4kUvZLXgGeBO0tlvpD+3R8HxnX1nPCjYszMLIu6nYMxM7PNmwOMmZll4QBjZmZZOMCYmVkWDjBmZpaFA4xZD1PhXknjSmnHSfp5b9bLbFPzZcpmGUjaD/gJxXOftqK49+CIiPhDN/bZLyLW9VAVzbZlK4AAAAE7SURBVLJzgDHLRNJlwFpge2BNRHw1rSdyGsWd0PcBp0fEm5KmAgdQPA/spoj4StrHcuB7FE/w/WZE/KQXDsWsS+r6YZdmm7kvA/OB14HG1KuZSPGonnUpqBwP/Iji8SXPS+oHzJZ0c0Q8lvazNiLG9sYBmHWHA4xZJhGxVtJNwJ8j4jVJHwQOBJrSU3235a3Hn58g6RSK38ndKRZ9ag0wN23ampv1DAcYs7zeTC8onok3LSL+vZxB0kjgTGBMRLwo6b+AbUpZ1m6Smpr1MF9FZrbp/BI4TtIuAJJ2ljQc2BFYA6wurbRqVvfcgzHbRCJioaQvA7+U9DbgDeBUoIm3nma8FPhN79XSrOf4KjIzM8vCQ2RmZpaFA4yZmWXhAGNmZlk4wJiZWRYOMGZmloUDjJmZZeEAY2ZmWfwPV1i99FcWDJsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from climada.entity import DiscRates\n",
    "from climada.util import ENT_TEMPLATE_XLS\n",
    "\n",
    "# Fill DataFrame from Excel file\n",
    "file_name = ENT_TEMPLATE_XLS # provide absolute path of the excel file\n",
    "disc = DiscRates()\n",
    "disc.read_excel(file_name)\n",
    "print('Read file:', disc.tag.file_name)\n",
    "disc.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Write discount rates"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Discount rates defined in an excel file following the template provided in sheet `discount` of `climada_python/data/system/entity_template.xlsx` can be ingested directly using the method `read_excel()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from climada.entity import DiscRates\n",
    "from climada.util import ENT_TEMPLATE_XLS\n",
    "\n",
    "# Fill DataFrame from Excel file\n",
    "file_name = ENT_TEMPLATE_XLS # provide absolute path of the excel file\n",
    "disc = DiscRates()\n",
    "disc.read_excel(file_name)\n",
    "\n",
    "# write file\n",
    "disc.write_excel('results/tutorial_disc.xlsx')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pickle can always be used as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-10-29 21:39:55,425 - climada.util.save - INFO - Written file /Users/aznarsig/Documents/Python/climada_python/doc/tutorial/results/tutorial_disc.p\n"
     ]
    }
   ],
   "source": [
    "from climada.util.save import save\n",
    "# this generates a results folder in the current path and stores the output there\n",
    "save('tutorial_disc.p', disc)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}