{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# DiscRates class\n", "\n", "Discount rates are used to calculate the net present value of any future or past value. They are thus used to compare amounts paid (costs) and received (benefits) in different years. A project is economically viable (attractive), if the net present value of benefits exceeds the net present value of costs - a const-benefit ratio < 1.\n", "\n", "There are several important implications that come along with discount rates. Namely, that higher discount rates lead to smaller net present values of future impacts (costs). As a consequence of that, climate action and mitigation measures can be postboned. In the literature higher discount rates are typically justified by the expectation of continued exponential growth of the economy.\n", "The most widley used interest rate in climate change economics is 1.4% as propsed by the Stern Review (2006). Neoliberal economists around Nordhaus (2007) claim that rates should be higher, around 4.3%. Environmental economists argue that future costs shouldn't be discounted at all. This is especially true for non-monetary variables such as ecosystems or human lifes, where no price tag should be applied out of ethical reasons. This discussion has a long history, reaching back to the 18th century: “Some things have a price, or relative worth, while other things have a dignity, or inner worth” (Kant, 1785).\n", "\n", "\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": { "ExecuteTime": { "end_time": "2021-10-15T12:25:12.663121Z", "start_time": "2021-10-15T12:25:08.668156Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on class DiscRates in module climada.entity.disc_rates.base:\n", "\n", "class DiscRates(builtins.object)\n", " | DiscRates(years=None, rates=None, tag=None)\n", " | \n", " | Defines discount rates and basic methods. Loads from\n", " | files with format defined in FILE_EXT.\n", " | \n", " | Attributes\n", " | ---------\n", " | tag: Tag\n", " | information about the source data\n", " | years: np.array\n", " | list of years\n", " | rates: np.array\n", " | list of discount rates for each year (between 0 and 1)\n", " | \n", " | Methods defined here:\n", " | \n", " | __init__(self, years=None, rates=None, tag=None)\n", " | Fill discount rates with values and check consistency data\n", " | \n", " | Parameters\n", " | ----------\n", " | years : numpy.ndarray(int)\n", " | Array of years. Default is numpy.array([]).\n", " | rates : numpy.ndarray(float)\n", " | Discount rates for each year in years.\n", " | Default is numpy.array([]).\n", " | Note: rates given in float, e.g., to set 1% rate use 0.01\n", " | tag : climate.entity.tag\n", " | Metadata. Default is None.\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", " | ----------\n", " | disc_rates: climada.entity.DiscRates\n", " | DiscRates instance to append\n", " | \n", " | Raises\n", " | ------\n", " | ValueError\n", " | \n", " | check(self)\n", " | Check attributes consistency.\n", " | \n", " | Raises\n", " | ------\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", " | ----------\n", " | ini_year: float\n", " | initial year\n", " | end_year: float\n", " | end year\n", " | val_years: np.array\n", " | cash flow at each year btw ini_year and end_year (both included)\n", " | \n", " | Returns\n", " | -------\n", " | net_present_value: float\n", " | net present value between present year and future year.\n", " | \n", " | plot(self, axis=None, figsize=(6, 8), **kwargs)\n", " | Plot discount rates per year.\n", " | \n", " | Parameters\n", " | ----------\n", " | axis: matplotlib.axes._subplots.AxesSubplot, optional\n", " | axis to use\n", " | figsize: tuple(int, int), optional\n", " | size of the figure. The default is (6,8)\n", " | kwargs: optional\n", " | keyword arguments passed to plotting function axis.plot\n", " | \n", " | Returns\n", " | -------\n", " | axis: matplotlib.axes._subplots.AxesSubplot\n", " | axis handles of the plot\n", " | \n", " | read_excel(self, *args, **kwargs)\n", " | This function is deprecated, use DiscRates.from_excel instead.\n", " | \n", " | read_mat(self, *args, **kwargs)\n", " | This function is deprecated, use DiscRates.from_mats instead.\n", " | \n", " | select(self, year_range)\n", " | Select discount rates in given years.\n", " | \n", " | Parameters\n", " | ----------\n", " | year_range: np.array(int)\n", " | continuous sequence of selected years.\n", " | \n", " | Returns: climada.entity.DiscRates\n", " | The selected discrates in the year_range\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", " | ----------\n", " | file_name: str\n", " | filename including path and extension\n", " | var_names: dict, optional\n", " | name of the variables in the file. The Default is\n", " | DEF_VAR_EXCEL = {'sheet_name': 'discount',\n", " | 'col_name': {'year': 'year', 'disc': 'discount_rate'}}\n", " | \n", " | ----------------------------------------------------------------------\n", " | Class methods defined here:\n", " | \n", " | from_excel(file_name, description='', var_names={'sheet_name': 'discount', 'col_name': {'year': 'year', 'disc': 'discount_rate'}}) from builtins.type\n", " | Read excel file following template and store variables.\n", " | \n", " | Parameters\n", " | ----------\n", " | file_name: str\n", " | filename including path and extension\n", " | description: str, optional\n", " | description of the data. The default is ''\n", " | var_names: dict, optional\n", " | name of the variables in the file. The Default is\n", " | DEF_VAR_EXCEL = {'sheet_name': 'discount',\n", " | 'col_name': {'year': 'year', 'disc': 'discount_rate'}}\n", " | \n", " | Returns\n", " | -------\n", " | climada.entity.DiscRates :\n", " | The disc rates from excel\n", " | \n", " | from_mat(file_name, description='', var_names={'sup_field_name': 'entity', 'field_name': 'discount', 'var_name': {'year': 'year', 'disc': 'discount_rate'}}) from builtins.type\n", " | Read MATLAB file generated with previous MATLAB CLIMADA version.\n", " | \n", " | Parameters\n", " | ----------\n", " | file_name: str\n", " | filename including path and extension\n", " | description: str, optional\n", " | description of the data. The default is ''\n", " | var_names: dict, optional\n", " | name of the variables in the file. The Default is\n", " | DEF_VAR_MAT = {'sup_field_name': 'entity', 'field_name': 'discount',\n", " | 'var_name': {'year': 'year', 'disc': 'discount_rate'}}\n", " | \n", " | Returns\n", " | -------\n", " | climada.entity.DiscRates :\n", " | The disc rates from matlab\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 - we define discount rates and apply them on a coastal protection scheme which initially costs 100 mn. USD plus 75'000 USD maintance each year, starting after 10 years. Net present value of the project can be calculated as displayed:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2021-10-15T12:25:23.110277Z", "start_time": "2021-10-15T12:25:22.976995Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "net present value: 1.01231e+08\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAHwCAYAAACrEGhDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAx5ElEQVR4nO3deZxsZ13n8c+3bi4ESCBgLhKygiwOoCxeCBlwQASFGLYBnSACg44RFAUFBJRhGUUFlFHMQOQlIJsoyhYgiGETgkJIQhZCCLIFQgJJgCw3JCHp85s/zjnVlU53nadv7nOq63m+79erX923ls6vOlX1rWdXRGBmZvWaLLoAMzNbLAeBmVnlHARmZpVzEJiZVc5BYGZWOQeBmVnlHARWBEnHSfrfi67DbBk5CGzLk/R1SVdJukLSpZL+XdLTJE2fvxHxtIj4o0XWuZGu/ofu4d/5cUn/a0/+TquXg8CWxSMjYl/gUODPgOcBr19sSXlI2mvRNVhdHAS2VCLisog4HvgfwFMk3QNA0t9J+uPu5/0lvb9rPXxP0if71oOkgyW9S9LFkr4r6dju8omkF0o6T9JFkt4s6VbddQ+WdP5sHbOf8iW9RNI7uvtcIelsSTu7694CHAK8T9IuSb+/9jH1v1/S8yR9G3ijpFt3j+FiSd/vfj6ou/3LgJ8Gju1+Z/8YflzSid1jPlfSL838N46U9IWuvm9Jes4e/N9iS85BYEspIk4Gzqd9Q1zr2d11O4AfBf4ACEnbgPcD5wGHAQcC/9Dd5392Xz8D3BHYBzh2EyU9qvtd+wHH9/eNiCcB36Bt0ewTEa/Y4P63A25D2+I5hva1+cbu34cAV838zj8EPgk8o/udz5B0C+BE4O+B2wJPAF4j6e7d73898Btdq+oewEc38discA4CW2YX0L55rnUtcABwaERcGxGfjHZTrfsBtweeGxFXRsTVEXFSd58nAq+KiK9GxC7gBcDRm+imOSkiToiIFeAtwD03+Vga4MURcU1EXBUR342Id0bEDyLiCuBlwIPm3P8o4OsR8caIuC4iTgPeCTy+u/5a4G6SbhkR3++uNwMcBLbcDgS+t87lrwS+DPyrpK9Ken53+cHAeRFx3Tr3uT1tS6F3HrAXbYsixbdnfv4BsPcm+/ovjoir+39Iurmkv+m6qi4HPgHs17Vq1nMocHjXHXappEtpw+123fWPA44EzpP0b5KO2ERtVjgPStlSknRf2iA4ae113SfoZwPP7rpGPibps8A3gUMk7bVOGFxA+2baOwS4DvgObUjcfOa/vY222ylVyha/a2/zbOCuwOER8W1J9wI+B2iD238T+LeIeNi6vzzis8CjJW0HngG8gzYYzdwisOUi6ZaSjqLtj39rRJy1zm2OknQnSQIuB1a6r5OBC4E/k3QLSXtLekB3t7cDvyvpDpL2Af4E+McuML5E+wn/F7o30hcCN91E2d+hHXfYjH1pxwUulXQb4MUDv/P9wF0kPUnS9u7rvpL+i6SbSHqipFtFxLWs/k3MAAeBLY/3SbqC9pPvHwKvAp66wW3vDHwY2AX8B/CaiPh413//SOBOtAO459POPgJ4A23f/ieArwFXA78N7Uwl4DeBvwW+BVzZ3TfVnwIv7LpsUmfr/CVwM+AS4NPAv6y5/q+Ax3czil7dtYJ+DjiatnXzbeDlrAbWk4Cvd91MTwN+ZRP1W+Hkg2nMzOrmFoGZWeUcBGZmlXMQmJlVzkFgZlY5B4GZWeWWbkHZ/vvvH4cddtiiyzAzWyqnnnrqJRGx7kLIpQuCww47jFNOOWXRZZiZLRVJ5210nbuGzMwq5yAwM6ucg8DMrHIOAjOzyjkIzMwq5yAwM6ucg8DMrHIOAjOzyjkIzMwq5yAwM6ucg8DMrHIOAjOzyjkIzMwq5yAwM6tctiCQtLekkyWdIelsSS9d5zYPlnSZpNO7rxflqsfMzNaX8zyCa4CHRMQuSduBkyR9MCI+veZ2n4yIozLWYWZmc2QLgogIYFf3z+3dV+T675nZ7rnmuhWuvrZZdBl73PZt4uY3WbqztxYi619J0jbgVOBOwP+LiM+sc7MjJJ0BXAA8JyLOzlmTma266ocr3P9PP8JlV1276FL2uIngH3/jCO572G0WXcqWlzUIImIFuJek/YB3S7pHRHx+5ianAYd23UdHAu8B7rz290g6BjgG4JBDDslZsllVrrjmWi676lqO/Inb8VOHlvOGecmua3jtx7/ChZddvehSlsIo7aaIuFTSx4GHA5+fufzymZ9PkPQaSftHxCVr7v864HUAO3fudPeS2Z7SvZoecKf9eeLhhy62lj3oKxfv4rUf/wptD7UNyTlraEfXEkDSzYCHAl9cc5vbSVL38/26er6bqyYzu76me58UWmwhe1j/aJwDaXK2CA4A3tSNE0yAd0TE+yU9DSAijgMeDzxd0nXAVcDR4Qg3G010TYJJWTnApP18OX18Nl/OWUNnAvde5/LjZn4+Fjg2Vw1mNt+0RVBYEPSPpylvMlQWXllsVrG+Aa7CkmC1RWApHARmFYvpGEGZGvc0J3EQmFWsf5+clNYi6Ac9nANJHARmFWumXUMLLmQP6x+OWwRpHARmFevfJosLAjcINsVBYFax/hNzcV1D3eNxiyCNg8CsYqW+T3pB2eY4CMyqVmaLQJ4+uikOArOKlb6gzBsVpHEQmFWs2OmjfYvAOZDEQWBWsen00QXXsad5+ujmOAjMKjZdWewWQdUcBGYVK3VBWd8kcIsgjYPAzAocI1h0BcvFQWBWsWLHCLygbFMcBGYVi1Knj3bfnQNpHARmFSt/i4kFF7IkHARmFZu+T5aVAzObzjkJUjgIzCpW6oKy1ZXFi61jWTgIzCoWpQ4W068jcBKkcBCYVax/myytRTBxi2BTHARmFWuaMheUyYPFm+IgMKtYqSeUTTxYvCkOArOKrS4oKysJ3CLYHAeBWc2ms4YWW0YOEh4kSOQgMKtYU+juo9DOhHKLII2DwKxifR96gTmAJI8RJHIQmFWsKbhraCK3CFI5CMwqtrrgqrwkEPIQQSIHgVnFVheULbSMLCRPH03lIDCr2HSLiQIHCSRPGkrlIDCrWBQ9RiDvNZTIQWBWsen00SLHCDxYnMpBYFaxKPXwevoWwaKrWA4OArOKrS4oW2wdWchnFqdyEJhVrcyjKqHMx5SLg8CsYiW3COQWQTIHgVnFovDBYudAGgeBWcX6T8ylTh91iyCNg8CsYqUeTAP9ymJL4SAwq1jZK4s9fTSVg8CsYqtjBOVpxwicBCkcBGYVi8KnjzoH0jgIzCrWNO33AnPA00c3wUFgVrHVbajLS4KJ5MHiRA4Cs4qV/om59Me3pzgIzGrWb0Nd4EKCyQTPH03kIDCrWP+JubwYaFdLu0WQxkFgVjEvKDNwEJhVbXWLifKSoN1iYtFVLAcHgVnFvKDMwEFgVrXVrqHyosBdQ+kcBGYVK/moSvnw+mQOArOK9e+TZY4R+DyCVA4Cs4p5+qiBg8CsaiW3COQWQTIHgVnFmoKnDcnTR5M5CMys0KMqwfOG0jgIzCrWFH1CGW4RJHIQmFWs4J4hhKePpnIQmFWsKXiweOIWQTIHgVnF+qMqC8wB8ME0yRwEZhWbdg0VGATtgjJHQQoHgVnFpltMFDhK0G46t+gqloODwKxiqwvKFltHDu2ZxU6CFA4Cs4o1066h8pJAgqZZdBXLwUFgVrH+E3OJLQK5RZDMQWBWsaJbBHj6aCoHgVnNIoqcMQTd2ggHQRIHgVnFmihzVTH0W0w4CVI4CMwqFkSR3ULgoyo3w0FgVrEmyhwohrZryC2CNA4Cs4pFlLmYrOccSOMgMKtY2zW06CrymHivoWQOArOKRZS5zxD0R1U6ClI4CMwqFhFFbkENXYvAOZDEQWBWsaKnj+Lpo6kcBGYViyjzUBrotphwDiRxEJhVrIlymwReUJbOQWBWuVJbBKWuj8jBQWBWsabgvYaEF5SlchCYVazgnqFu+uiiq1gODgKzijWFTx91iyCNg8CsYkG5C8rwpnPJHARmFWtXFpeZBD6PIF22IJC0t6STJZ0h6WxJL13nNpL0aklflnSmpPvkqsfMbigiyh0jwNNHU+2V8XdfAzwkInZJ2g6cJOmDEfHpmds8Arhz93U48Nruu5mNoOQFZRM3CJJlaxFEa1f3z+3d19r/L48G3tzd9tPAfpIOyFWTmV1f0dNHPVicLOsYgaRtkk4HLgJOjIjPrLnJgcA3Z/59fneZmY0gKLdF4Omj6bIGQUSsRMS9gIOA+0m6x5qbrPcMvMH/OknHSDpF0ikXX3xxhkrN6lTyJ2bhvYZSjTJrKCIuBT4OPHzNVecDB8/8+yDggnXu/7qI2BkRO3fs2JGrTLP6BEwKnTs48XkEyXLOGtohab/u55sBDwW+uOZmxwNP7mYP3R+4LCIuzFWTmV1fE1HsUZXtpnOLrmI55Jw1dADwJknbaAPnHRHxfklPA4iI44ATgCOBLwM/AJ6asR4zW6PkBWVChOcNJckWBBFxJnDvdS4/bubnAH4rVw1mNl9T8vTRiVsEqQrtHTSzFCUvKMODxckcBGYVK7lrqD2PwEmQwkFgVrGIKHavIQ8Wp3MQmFWs3WJi0VXkMZE8fTSRg8CsYkVPH8UtglQOArOKtdtQL7qKPOQWQTIHgVnFmoLPI/BeQ+kcBGZVi7LHCBZdxJJwEJhVrCm5a4iyN9XbkxwEZhWLkgeL3TWUzEFgVrGm8OmjbhGkcRCYVSyg6L4hx0AaB4FZxSLKHix2EqRxEJhVLGL9YwJL4MHidA4Cs4oFUe421J4+msxBYFaxpil4iEBuEaRyEJhVLCh591GfR5DKQWBWsabwMQLwAfYpHARmNSv5qMrucTkHhjkIzCrWRBQ9RgAeJ0jhIDCrWMlHVU67hhZaxXJwEJhVrImCp492K+XcIhjmIDCrWA3vkTU8xhvLQWBWsaD8wWIb5iAwq1h4sNhwEJhVLYqePtp+dw4McxCYVayJKHhBmQeLUzkIzCoWhR9eD54+msJBYFaxsheUdSuLmwUXsgQcBGaVK/dgmvZ7uE0wyEFgVrGm5MPru++Nc2CQg8CsYu0YwaKryGPaNeTB4kEOArOKFb3FxHQdwWLrWAYOArOKBRR8IEHXIvAYwSAHgVnNKlhQ5hwY5iAwq1gdC8oWXMgScBCYVazddG7RVeTh6aPpHARmFWsXlJWZBPJgcTIHgVnFPH3UwEFgVrUIil9Q5hwY5iAwq1hEFDxG0LcIFlzIEnAQmFWsKbprqP3ubaiHOQjMKhYUvNeQt6FO5iAwq1gTMCn0XaDvGnKLYFihTwEzSxFF7zHRcg4McxCYVa38wWJ3Dg1zEJhVrI7B4sXWsQwcBGYVi6K3ofb00VQOArOKNVHuCMHqCWVOgiEOArOKRdF7DblFkMpBYFaxsvcaar+7RTDMQWBWsXYb6jKToNTHlYODwKxiZR9M03KLYJiDwKxiNXQNOQeGOQjMKtZUMH3ULYJhDgKzihW9w4Q3nUvmIDCrWZQ7qOoFZen2SrmRpNsCDwBuD1wFfB44JSKajLWZWWY1DBb7qMphc4NA0s8AzwduA3wOuAjYG3gM8GOS/hn4i4i4PHOdZpZBDdNHHQPDhloERwK/HhHfWHuFpL2Ao4CHAe/MUJuZZdZEFD9rqPGuc4PmBkFEPHfOddcB79nTBZnZeNrpo2UmgU8oS7epwWJJ95f0UUmfkvTYXEWZWX5933mZMcD0CE5PHx02NEZwu4j49sxFvwc8iva58+/AuzPWZmYZ9e+P5Y4RdD84BwYNjREcJ+lU4JURcTVwKfDLQAN4gNhsifWflAvNgWmXl4cIhs3tGoqIxwCnA++X9CTgWbQhcHPamUNmtqT698dCc2BmjMBJMGRwjCAi3gf8PLAf8C7g3Ih4dURcnLk2M8uobxFMCj20uH9YbhEMmxsEkh4l6STgo7SLyI4GHivp7ZJ+bIwCzSyP8sdQ+5XFxT/QG21ojOCPgSOAmwEnRMT9gN+TdGfgZbTBYGZLrPTBYsfAsKEguIz2zf5mtKuKAYiI/8QhYLbUahksdotg2NAYwWNpB4avo50tZGaFWJ0+utg6cpm2CJwDg4ZaBFdHxF/Pu4GkfSJi1x6sycxGMG0RFDpvaHVB2YILWQJDLYL3SvoLSf9N0i36CyXdUdKvSfoQ8PC8JZpZDtPpo2XmwMwJZU6CIUN7Df2spCOB3wAeIOnWtN1E5wIfAJ6yZuWxmS2JfhP50vcacotg2OB5BBFxAnDCCLWY2Yj6hVbljhF4j4lUPqHMrFL9J+VCc8Atgk1wEJhVarr7aKldQ9MFZQsuZAk4CMwq1VQyfdTbUA9LDgJJD5T01O7nHZLukK8sM8ttuhlbqS0CryxOlhQEkl4MPA94QXfRduCtuYoysxEU3iLwyuJ0qS2Cx9IeSHMlQERcAOybqygzy291sLjMJJjOGXIODEoNgh9GG6sBMLu4zMyWUy3TR30ewbDUIHiHpL8B9pP068CHgb/NV5aZ5daUPUSwOn20WWwdy2BwQRlARPy5pIfRHk95V+BFEXFi1srMLKvSp4+utghsSFIQSHp5RDwPOHGdy8xsCUXhC8p6nj46LLVr6GHrXPaIPVmImY1rdRvqMqNg4pNpkg0dVfl0SWcBd5V05szX14AzB+57sKSPSTpH0tmSnrnObR4s6TJJp3dfL7pxD8fMUhV/ME333S2CYUNdQ38PfBD4U+D5M5dfERHfG7jvdcCzI+I0SfsCp0o6MSK+sOZ2n4yIozZVtZndaNVsQ73YMpbC0DbUl9EeV/kEAEm3BfYG9ukOpPnGnPteCFzY/XyFpHOAA4G1QWBmC9B/Ui62a0j9wTSOgiGpg8WPBF4F3J727OJDgXOAuyfe/zDg3sBn1rn6CElnABcAz4mIs1N+py2357/zTM761mXrXnfzm2zjr46+N7ff72YjV1WX0t8fvaAsXepg8R8D9we+FBF3AH4W+FTKHSXtA7wTeFZEXL7m6tOAQyPinsBfA+/Z4HccI+kUSadcfPHFiSXbVvae07/Frmuu44Bb7X29r1vcZC8++/Xvc+63r1h0iRUou0UgTx9NltQiAK6NiO9KmkiaRMTHJL186E6SttOGwNsi4l1rr58Nhog4QdJrJO0fEZesud3rgNcB7Ny50/9fC9A08Ih7HMDzH/Hj17v8rPMv45HHnsSKN5HPrpYFZd5raFhqEFzafbL/BPA2SRfRDgZvSG0cvx44JyJetcFtbgd8JyJC0v1oWyjfTa7eltZKBNvWaY9OJqvXW17FTx+dbjq34EKWQGoQPBq4Cvhd4InArYD/M3CfBwBPAs6SdHp32R8AhwBExHHA44GnS7qu+/1Hh+O7CitNsG2dN6Bt3dzvxi2C7KbTRxdcRy6ePppuMAgkbQPeGxEPBRrgTSm/OCJOYuA5FhHHAsem/D4rR/8mP1lnt7M+HNwiyG+6stgtguoNDhZHxArwA0m3GqEeq8C8aYuaTvkbtaQqlb6grP8Y6hbBsNSuoatpu3hOpDuTACAifidLVVa0/tP+tvVaBO4aGl25YwSLrmB5pAbBB7ovsxut3xZ4vTegadeQgyC74scIvKAsWeo21EnjAmYpVlsEN7zOs4bGE6VPH+2++6k0LPnwerM9Zd4YQd815Mlj+dWzxcSCC1kCDgIb3XTW0DpvQJNp19CoJVVp+v5YZg7MbDrnJBiSFASSfjHlMrMUff//eoPFE08fHU3pC8pWVxYvto5lkNoieEHiZWaD+jf5ddcReNbQaKL0wWLczZhq7mCxpEcARwIHSnr1zFW3ZGCLCbON9LOG1l1Z7FlDo+n/wqW2CCZuESQbmjV0AXAK8Cjg1JnLr6DdbsJs01YHKW94nSbXv43l07e6Cs0BL07chKGDac4AzpD09xFx7Ug1WeFWEraYcBDkV/oJZRMPFidLXVB2P0kvoT2QZi/absWIiDvmKszK1b/Jz9t0zrOG8ltdUFZmErhFkC41CF5P2xV0KrCSrxyrQcqsIbcIRjCdNbTYMnJS+5F10WVsealBcFlEfDBrJVaN/hPavFlDHizOb/VgmnKTQLhFkCI1CD4m6ZXAu4Br+gsj4rQsVVnR5g0W95e5RZBf33decA4gyWMECVKD4PDu+86ZywJ4yJ4tx2ow7RraYBtqyesIxtBU0DU0kVsEKVI3nfuZ3IVYPebNGoI2ILyyOL/VhVblJoGQhwgSJAWBpBetd3lEDB1XaXYD82YNQRsQnjWU3+qCsoWWkZXk6aMpUruGrpz5eW/gKOCcPV+O1WB1sHj96yfytgBjmG4xUfAggeRJQylSu4b+Yvbfkv4cOD5LRVa8lTm7j0LXNeSO3eyiijEC+UNFgt3dhvrmgBeT2W6Zdg1t8A40mXiMYAzT6aNFjxF4sDhF6hjBWax2KW4DdgAeH7DdMm/WELQB4VlD+a12DS24kIzaFsGiq9j6UscIjpr5+TrgOxHh3UdttzRztqEGzxoay+qCssXWkZW8JiVFUtdQRJwH7Ac8EngscLeMNVnh5h1eD+3gpRsEYyj7qEoo+7HtSaknlD0TeBtw2+7rbZJ+O2dhVq55h9f3l7trKL8aWgRyiyBJatfQrwGHR8SVAJJeDvwH8Ne5CrNyzTuzGDxraCxRyWCxc2BY6qwhcf1dR1coeTmiZTVv91HwrKGxzNvzqRQTyS2CBKktgjcCn5H07u7fj6Hdmtps01bfgDYIAs/0GEXpB9NAv7LYhqQuKHuVpI8DD6RtCTw1Ij6XszAr11AQbJu4a2gMdaws9oeKFKnrCO4PnN1vOy1pX0mHR8RnslZnRer3Edqwa0i4a2gEq2ME5eqOUlx0GVte6hjBa4FdM/++srvMbNOGZw15QdkYopLpo86BYcmDxTETqxHRkD6+YHY9kTBG4K6h/Pr1HAXngKePJkoNgq9K+h1J27uvZwJfzVmYlWto07mJF5SNYnUb6nKTYCJ5sDhBahA8DfivwLeA82lPLDsmV1FWtqHpo9smnvI3hlr+xrU8zhsjddbQRcDRmWuxSgztNTTxrKFxTM+FKLhFMMHzRxOkbjHxCkm37LqFPiLpEkm/krs4K9N01tCGK4v9KW4M/d+43BhoV037uTQstWvo5yLictpdSM8H7gI8N1tVVrShFa0eLB6HF5RZLzUItnffjwTeHhHfy1SPVSCla8if4vIbWthXAk88SJM6BfR9kr4IXAX8pqQdwNX5yrKSDR5M4xbBKLygzHqp5xE8HzgC2BkR19IuKHt0zsKsXNPpo3NmDXllcX6rXUPlRoG7htLMbRFIekhEfFTSf5+5bPYm78pVmJWrf4+fu/uoWwTZ1XBUpXx4fZKhrqEHAR+lPZlsrcBBYLthZXCw2M35MfR/4rLHCHweQYq5QRARL+6+P3WccqwGQyuLfWbxODx91HpDXUO/N+/6iHjVni3HatCkHEzTjFlRnWpoEcgtgiRDXUP7dt/vCtwXOL779yOBT+Qqyso23X10TovAu4/m11QwbUiePppkqGvopQCS/hW4T0Rc0f37JcA/Za/OijR0aPpk4vMIxlTwDhPdY/NzaUjqgrJDgB/O/PuHwGF7vBqrQtMEE208bdHnzI5jOkZQeNeQWwTDUheUvQU4uTuzOIDHAm/KVpUVbSViw/EB8ME0Y6mgZwjh6aMpUncffZmkDwI/3V3kM4ttt7UtgjlB4FlDo2gqGCyeuEWQJPmUse684tMy1mKVaAZaBJOJpqdnWT79UZUF5wD4YJokqWMEZnvMSjP/U+jE21CPIgYG7UvgxYlpHAQ2uiZi7kyVbd5iYhTTLSYKHiVoN51bdBVbn4PARrfSDHQNedbQKFYXlC22jpzaM4v9XBriILDRpcwacosgv9X1HOUmgYTHmxI4CGx0ETH3zccnlI2j/6RccotAbhEkcRDY6Faa2HB7Ceia837tZldFiwBPH03hILDRrTQbbzgHsM1bTIwjougZQ9DNTvNTaZCDwEbXRDCZ88zzwTTjaKLsVcXQbzHh59IQB4GNron5XUPbPGtoFMH8sZoSuEGQxkFgo1sZ2GJi4q2DR9FE2QPF4KnIqRwENrq2a2j+FhPuGsovouzFZD3nwDAHgY1uaNZQf513IM2r7RpadBV5TbzXUBIHgY1upWFui2Bb96z0zKG8IsreZwj6oyr9PBriILDRxcBeQ/0ApruH8mr/P5SdBF6TksZBYKNL2WIC3LebWxXTR/H00RQOAhvd0KyhfozAXUN5RZR9KA10W0z4aTTIQWCjSzmYBtw1lFsT5TcJvKAsjYPARtc0DMwa6m/nF3BupbcISl8nsac4CGx0KwN73ExbBP4kl1VTwV5DwgvKUjgIbHRNwsE04CZ9bhX0DHXTRxddxdbnILDRpc4a8oEieTWVTB/1B4phDgIbXTMwW8WzhsYRlL+gDG86l8RBYKNrmqEFZau3s3zalcVlJ4HPI0jjILDRDR1eP+0acosgq4gof4wAP49SOAhsdEN909u8jmAUNSwom7hBkMRBYKMbahF41tA4qpg+6sHiJA4CG91Qi2Ay3XRurIrqFJTfIvD00TQOAhtdE4nbULtrKKsaPikL7zWUwkFgo2sPptn4encNjSRgUvg7wMTnESQp/GlgW9FKM/+oSs8aGkcTUfxRle2mc4uuYutzENjoIuYfVendR8dRw4IyIcLzhgY5CGx0K4mDxW4R5DW0wrsEk4lbBCkcBDa6wTOLp0EwVkV1qmFBGR4sTuIgsNG1B9NsfP3Es4ZGUUPXUPt5w8+jIQ4CG107ayihReAgyCoiit9ryIPFabIFgaSDJX1M0jmSzpb0zHVuI0mvlvRlSWdKuk+uemzraAbegHwwzTjaLSYWXUVeE8nTRxPslfF3Xwc8OyJOk7QvcKqkEyPiCzO3eQRw5+7rcOC13XcrWOrBNO4ayquK6aO4RZAiW4sgIi6MiNO6n68AzgEOXHOzRwNvjtangf0kHZCrJtsaUg+m8Qe5vNptqBddRV5yiyDJKGMEkg4D7g18Zs1VBwLfnPn3+dwwLKwwTZN4MI0/ymXVVHAegfcaSpM9CCTtA7wTeFZEXL726nXucoP/bZKOkXSKpFMuvvjiHGXaiJJnDfkVnNn8A4JKMJE8ZyhB1iCQtJ02BN4WEe9a5ybnAwfP/Psg4IK1N4qI10XEzojYuWPHjjzF2miSF5S5RZBVU0PXEF6YmCLnrCEBrwfOiYhXbXCz44End7OH7g9cFhEX5qrJFi8iBg9E2eZZQ6OIGgaL3TWUJOesoQcATwLOknR6d9kfAIcARMRxwAnAkcCXgR8AT81Yj20Bfb9/2sE0o5RUraaS6aNuEQzLFgQRcRLrjwHM3iaA38pVg209/af8pDOLnQRZBVTRN+Rn0TCvLLZR9R/O5r3/9BnhWUN5RdQxWOwkGOYgsFFNu4ZSjqp0kz6riIEmewE8WJzGQWCj2kzXkBcC5RXMn71VAk8fTeMgsFH1/f5Js4Z8eH1WTVPBEIHcIkjhILBR9d3+SXsN+QWcVVDD7qM+jyCFg8BGtTJtEWx8m/46zxrKq6lkjADczTjEQWCj6pvpKYfXe9ZQZjUcVSlvYJjCQWCjSpo11K8j8Ks3q/ZciEVXkVf/+Pxcms9BYKOadg0lnVnsF29ONRxVOe0aWmgVW5+DwEbVv7enbDrnWUN5NQOb/5XArcs0DgIb1eo6go1v029D7RdvXjX9eWt6rLvDQWCjWklZR+BtqEcR1DNYbPM5CGxUzSZWFnsdQV7hwWLrOAhsVNMgmPMOJKldEeoWQVZD50KUoP+84RyYz0Fgo+q7hoZWtE4ktwgyayIqWFDmweIUDgIbVdPNBJrXNQRti8GzhvKKSg6vB08fHeIgsFGlzBqCduaQtwXIq44FZd3KYn+omMtBYKNKmTUEfYvAQZBb+QfTtN/DbYK5HAQ2qv5T/lAQeIwgv6aGw+u77/5MMZ+DwEaVcng9tCtCPWsor3aMYNFV5DXtGvKHirkcBDaqlcQWwbaJ/Ckusyq2mJiuI1hsHVudg8BGlTpryF1D+QVUcCBB1yLwGMFcDgIbVZM4a2jbxAvKsqtoQZlzYD4HgY2q/5SftKDMQZBVXQvKFlzIFucgsFE1CQfTgLuGxtBuOrfoKvLy9NE0DgIbVeqsoW0THzqeW7ugrOwkkAeLkzgIbFTNJmYNuWsoL08ftZ6DwEbVv7dPBp55krehzi2CahaU+ak0n4PARpVyeH1/vWcN5RURFYwR9C2CBReyxTkIbFTTrqGEMQJ3DeXVVNE11H73NtTzOQhsVKktgom8sji3oIK9hrwNdRIHgY2qf3NPmTXkT3F5NTE8VrPs+q4hP5fmK/xpYFtNMz2hbP7tJsJdQ5lFFXtMtJwD8zkIbFSrB9Mk7D7qV29m9QwWu3NoPgeBjWpTs4YcBFnVNVi82Dq2OgeBjSp11tDEs4ayiyq2ofb00RQOAhtVk3hU5USrW1ZbHk2UP0KwekKZk2AeB4GNaqWfNZSyxYRfvFlFFXsNuUWQwkFgo5q2CAaeed6GOr869hpqv7tFMJ+DwEaVOmuo3X3UL96c2m2oy06C0h/fnuIgsFEl7z7q8wiyq+NgmpZbBPM5CGxUqYPFkljxYHFWNXUNOQfmcxDYqFYSD6/3mcX5NRVNH3WLYD4HgY1qZdo1NP923msovyp2mPCmc0kcBDaqpmm3NUg6vN5BkFeUP5jqBWVpHAQ2qtTuiIkPpsmupsFiz0Cbz0Fgo1qJGNxeArygbAw1TR/1M2k+B4GNqmlicFUx9C2CEQqqWBNRzawhty7ncxDYqFaa4RlD0M0acosgq3b6aNlJ4BPK0jgIbFRN4oHpPrM4r77PvOwYYHoUpz9UzOcgsFE1iWME8nkEWfV/2vLHCLof/FSay0Fgo1pJHCPY5k3nsupDtvAcmHZ9+ak0n4PARpXaInDXUF79X7bwHJgZI/BzaR4HgY0qtUUwkbwIKKPUk+KWXf/w/JliPgeBjaqJ4e0loL2N1xHkU8+ftl9ZXM0D3i0OAhtV07hraCupZbDYz6T5HAQ2qpWIpHUEE286l1Vtg8VuEcznILBRbWbWkBsE+axOH11sHblNWwR+Ls3lILBRRaQNUE7cNZTVtEVQ+Lyh1QVlCy5ki3MQ2KhWmrSVxdPZHn4FZzGdPlp2DsycUObn0TwOAhvVSuI21H33kWcO5RHdhn617DXkzxPzOQhsVE2TPlgMuHsok36BVfljBN5jIoWDwEaVOmuov40bBHn0+Vp4DrhFkMhBYKNqErc+7rPCXUN5THcfLb1rCH+gSOEgsFG1B9MM365v0rtrKI+msumjXpMyn4PARrWSOEbQ38azhvKYbsJWeovAK4uTOAhsVMmzhvog8Ce5PCppEXhlcRoHgY0qUreY8PTRrFYHi8tOgumcIT+N5nIQ2KjaBWXpQeAD7POobfqozyOYz0Fgo1pJ3GJi26S/vV/AOTR1DBGsTh/1B4q5HAQ2qs3OGvJgcR61TB9dbRHYPA4CG9WmZw25RZBFVLKgrOfn0XwOAhtVE5G4oMzrCHJa3Ya67CiY+GSaJA4CG1UTiWcWu0WQVTUH03Tf/Tyaz0Fgo0ruGpq2CHJXVKfqtqFebBlbnoPARtVsctaQP8nl0f9di+8akluWKRwENqq2a2j4dh4jyKuW90UvKEvjILBRbXpBmV/BmdTRIpCnjyZxENiomiYSu4bcIsiptgVl3mtoPgeBjWrFs4a2hGqmj043nVtwIVucg8BGtdIkDhZPu4ZyV1Sn6fTRBdeRm6ePpnEQ2KgiImmjs+kJZU6CLKYri90iMBwENrLUM4snPpgmq1oWlPVNArcI5nMQ2KhSZw1NB4v9As6q/DGCRVewHBwENqomcWWx1xHkVc0YgachJ8kWBJLeIOkiSZ/f4PoHS7pM0und14ty1WJbRxNsavdRv37ziFqmj3bf/Tyab6+Mv/vvgGOBN8+5zScj4qiMNdgWsxKR9ObjweK86ttiYsGFbHHZWgQR8Qnge7l+vy2n9mAan1m8aNO/atk5MLPpnJ9H8yx6jOAISWdI+qCkuy+4FhtB6qyhbZ41lFUtC8pWVxYvto6tLmfX0JDTgEMjYpekI4H3AHde74aSjgGOATjkkENGK9D2rIggIu3NZ/WEstxV1SlqGSymH2vyE2mehbUIIuLyiNjV/XwCsF3S/hvc9nURsTMidu7YsWPUOm3PaTbxKXQ6RuAXcBb9X7X0FsHELYIkCwsCSbdTN7dL0v26Wr67qHosv37gd1vCs86H1+fV/10Lz4GZ6aMLLmSLy9Y1JOntwIOB/SWdD7wY2A4QEccBjweeLuk64Crg6HD7rWjTmSrefXThajmhbOLB4iTZgiAinjBw/bG000utEtMWgWcNLdzqgrKyk8AtgjSLnjVkFenffDa3oMyv4Cym4zWLLWMMEh4kGOAgsNE03UH0KTterm4xkbOieq0eTFN+Egi3CIY4CGw0fTdP0pnFk+vfx/asvs+8ghxAkscIBjgIbDSrs4Y2cTCNP8pl0VTUNTSRWwRDHAQ2mt2ZNeRdI/NYHXspPwmEPEQwwEFgo9nMRmfyNtRZrS4oW2gZo5A8fXSIg8BGs5npo24R5DXdYqKCQQLJk4aGOAhsNP2soc0cXu9ZQ3lEVWME8jTkAQ4CG8101lDKFhPdbdwiyGM6fbSKMQIPFg9xENhoNjNG4FlDea12DS24kBG0LYJFV7G1OQhsNP2betruo95iIqfVBWWLrWMUcstyiIPARrOyiS0mJj6YJrM6jqqEOh7jjeUgsNGsbKJFAG1guEWQR00tArlFMGiRJ5Ttlq9dciVPfsPJiy7DdsOuq68F0loE0I4THH/GBZz1rctzllWli6+4BqhnsPjDX/gOX//uDxZdypa1dEGw0gSXX3Xtosuw3XTEHX+Eu9/+lkm3ffzOg/jCBZf7/3cGN91rwoPvuoODb3OzRZeS3ePucxCnnPd9P4/m0LLNr925c2eccsopiy7DzGypSDo1Inaud53HCMzMKucgMDOrnIPAzKxyDgIzs8o5CMzMKucgMDOrnIPAzKxyDgIzs8o5CMzMKucgMDOrnIPAzKxyDgIzs8o5CMzMKucgMDOrnIPAzKxyDgIzs8o5CMzMKucgMDOr3NIdVSnpYuC8TL9+f+CSTL87F9ec37LVC655LMtU86ERsWO9K5YuCHKSdMpGZ3puVa45v2WrF1zzWJax5vW4a8jMrHIOAjOzyjkIru91iy5gN7jm/JatXnDNY1nGmm/AYwRmZpVzi8DMrHJFB4GkN0i6SNLnZy67p6T/kHSWpPdJuuXMdT/ZXXd2d/3e3eU/1f37y5JeLUlboWZJ2yW9qbv8HEkvmLnPmDUfLOljXQ1nS3pmd/ltJJ0o6T+777eeuc8LutrOlfTzY9a92XolPUzSqV1dp0p6yJj17k7NM/c7RNIuSc9ZhpoX/RrcjefGlngN3mgRUewX8N+A+wCfn7nss8CDup9/Ffij7ue9gDOBe3b//hFgW/fzycARgIAPAo/YIjX/MvAP3c83B74OHLaAmg8A7tP9vC/wJeBuwCuA53eXPx94effz3YAzgJsCdwC+MubfejfqvTdw++7newDfmvldo/ydN1vzzP3eCfwT8JytXvNWeA3uRs1b4jV4ox/3ogvI/gDhMK7/pno5q2MjBwNf6H4+EnjrBk+ML878+wnA32yRmp8AvK97Af1I96S9zSJqXlP/e4GHAecCB8z8Hc/tfn4B8IKZ23+oe8EspO6hetfcVsB3aUNsYX/nlJqBxwCvBF5CFwRbueat9BrcRM1b8jW42a+iu4Y28HngUd3Pv0j7xgpwFyAkfUjSaZJ+v7v8QOD8mfuf3102po1q/mfgSuBC4BvAn0fE91hgzZIOo/0E/RngRyPiQoDu+227mx0IfHOd+kavO7HeWY8DPhcR1yyiXkirWdItgOcBL11z9y1bM1vsNZhY85Z7De6OvRZdwAL8KvBqSS8Cjgd+2F2+F/BA4L7AD4CPSDqV9tP4WmNPtdqo5vsBK8DtgVsDn5T0YdpPrWtlr1nSPrRdEc+KiMvndIluVN+odW+i3v72dwdeDvxcf9E6N8v6d95EzS8F/m9E7Fpzm61c85Z5DW6i5i31Gtxd1QVBRHyR7oUs6S7AL3RXnQ/8W0Rc0l13Am1f/VuBg2Z+xUHABaMVzNyafxn4l4i4FrhI0qeAncAnGblmSdtpXzhvi4h3dRd/R9IBEXGhpAOAi7rLz2e1VTNb3/lj1b3JepF0EPBu4MkR8ZWZxzHa33mTNR8OPF7SK4D9gEbS1d39t2rNW+I1uMmat8xr8MaormtIUt90ngAvBI7rrvoQ8JOSbi5pL+BBtH3xFwJXSLp/N+r/ZNp+w61Q8zeAh6h1C+D+tP2So9bc/TdeD5wTEa+auep44Cndz0+ZqeF44GhJN5V0B+DOwMlj1b3ZeiXtB3yAdlzjU/2Nx/w7b7bmiPjpiDgsIg4D/hL4k4g4divXzBZ4De5GzVviNXijLXqQIucX8HbavrtraT9t/BrwTNoBnS8Bf0Y3CNvd/leAs2n75F8xc/nO7rKvAMfO3meRNQP70M4IORv4AvDcBdX8QNpm75nA6d3XkbSDZx8B/rP7fpuZ+/xhV9u5zMymGKPuzdZLG75Xztz2dOC2Y/6dd+dvPHPfl3D9WUNbtuZFvwZ347mxJV6DN/bLK4vNzCpXXdeQmZldn4PAzKxyDgIzs8o5CMzMKucgMDOrnIPAbEA3R/wkSY+YueyXJP3LIusy21M8fdQsgaR70M4XvzewjXZ++cNjdZXxZn7XtohY2bMVmu0+B4FZom67hiuBW3TfDwV+gnarlpdExHu7jcre0t0G4BkR8e+SHgy8mHax4L0i4m7jVm+2MQeBWaJuC4HTaDf9ez9wdkS8tduC4mTa1kIATURcLenOwNsjYmcXBB8A7hERX1tE/WYbqW7TObPdFRFXSvpHYBfwS8AjtXry197AIbQbix0r6V60u1LeZeZXnOwQsK3IQWC2OU33JeBxEXHu7JWSXgJ8B7gn7WSMq2euvnKkGs02xbOGzHbPh4Df7naWRNK9u8tvBVwYEQ3wJNqBZbMtzUFgtnv+CNgOnCnp892/AV4DPEXSp2m7hdwKsC3Pg8VmZpVzi8DMrHIOAjOzyjkIzMwq5yAwM6ucg8DMrHIOAjOzyjkIzMwq5yAwM6vc/wddwKaDPhUBfwAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "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", "years = np.arange(1950, 2100)\n", "rates = np.ones(years.size) * 0.014\n", "rates[51:55] = 0.025\n", "rates[95:120] = 0.035\n", "disc = DiscRates(years=years, rates=rates)\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 `from_excel()`." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2021-10-15T12:25:33.821328Z", "start_time": "2021-10-15T12:25:33.333591Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Read file: /Users/ckropf/climada/data/entity_template.xlsx\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "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.from_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 `from_excel()`." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2021-10-15T12:25:45.026313Z", "start_time": "2021-10-15T12:25:44.966485Z" } }, "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.from_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": [], "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": { "hide_input": false, "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.8.10" }, "latex_envs": { "LaTeX_envs_menu_present": true, "autoclose": false, "autocomplete": true, "bibliofile": "biblio.bib", "cite_by": "apalike", "current_citInitial": 1, "eqLabelWithNumbers": true, "eqNumInitial": 1, "hotkeys": { "equation": "Ctrl-E", "itemize": "Ctrl-I" }, "labels_anchors": false, "latex_user_defs": false, "report_style_numbering": false, "user_envs_cfg": false }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": true, "toc_window_display": false } }, "nbformat": 4, "nbformat_minor": 4 }