IRR_etc_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Read input data from external Excel sheets...play with economics then\n",
    "- External excel sheets have some representative input data...the last one you could use for playing\n",
    "- Don't change the format in the Excel\n",
    "- ipynb package might not be there in all Anaconda installations\n",
    "- You might have to change file and directory names\n",
    "- There are places where one generates the samples and after that saves them to files. You can speed things up later on by reading the samples from the files and skipping the \"computation\" i.e. resampling. Running everything is often an overkill.\n",
    "- Functions here are just for plotting. Tweak as needed\n",
    "- Sampling here loops over discount rates to generate the images...different loops can of course be considered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from matplotlib import rc\n",
    "import matplotlib.cm as cm\n",
    "import matplotlib.gridspec as gridspec\n",
    "from IPython.display import HTML\n",
    "import matplotlib as mpl\n",
    "#enable latex editing\n",
    "rc('font',**{'family':'sans-serif','sans-serif':['Helvetica']})\n",
    "## for Palatino and other serif fonts use:\n",
    "#rc('font',**{'family':'serif','serif':['Palatino']})\n",
    "rc('text', usetex=True)\n",
    "font = {'family' : 'normal',\n",
    "        'weight' : 'bold',\n",
    "        'size'   : 20}\n",
    "mpl.rc('font', **font)\n",
    "import matplotlib.pylab as pylab\n",
    "params = {'xtick.labelsize':'x-large',\n",
    "         'ytick.labelsize':'x-large'}\n",
    "pylab.rcParams.update(params)\n",
    "#might need this to get the movie output working\n",
    "%matplotlib notebook "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ipynb.fs.full.NPV_and_LCOE_and_IRR import NPV,NPV2,LCOE,IRR,NPV3  #need: pip install ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename=\"./Energy_src_parameters_2019.xlsx\"  #Has collection of different parameters from different sources\n",
    "#some artistic license has been used in adding missing entries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "xl = pd.ExcelFile(filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "names=xl.sheet_names "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Parameters ATB', 'Parameters Fraunhofer 2018', 'Parameters LUT', 'Parameters Narrow', 'Danish data', 'Danish Coal refurbish', 'LUT coal extend', 'EIA', 'EIA existing', 'References']\n"
     ]
    }
   ],
   "source": [
    "print(names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(names)-1):\n",
    "    df = pd.read_excel(filename,sheet_name=names[i]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Choose which parameter set you use: several sheets exist in the excel\n",
    "#df = pd.read_excel(filename,sheet_name=names[0]) #AT\n",
    "df = pd.read_excel(filename,sheet_name=names[2]) #LUT\n",
    "#df = pd.read_excel(filename,sheet_name=names[1]) #Fraunhofer...somewhat\n",
    "#df = pd.read_excel(filename,sheet_name=names[3]) #Playground with small uncertainty\n",
    "#df = pd.read_excel(filename,sheet_name=names[5]) #Danish coal life extension\n",
    "#df = pd.read_excel(filename,sheet_name=names[6]) #LUT coal life extension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(21, 11)\n"
     ]
    }
   ],
   "source": [
    "print(df.shape)\n",
    "keynames=df.keys()\n",
    "dimensions=df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Roughly LUT parameters', 'Units', 'Wind onshore', 'Wind offshore',\n",
       "       'PV', 'PV rooftop', 'Nuclear', 'Natural gas CCGT', 'Natural gas OCGT',\n",
       "       'Coal', 'Coal extend'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keynames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n"
     ]
    }
   ],
   "source": [
    "#How many techs have been implemented? 1st two columns are parameter names and units\n",
    "ntech=dimensions[1]-2\n",
    "#How many parameters each have \n",
    "nparams=dimensions[0]\n",
    "print(nparams)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#Read the technology data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0                        CAPEX min\n",
      "1                    CAPEX typical\n",
      "2                        CAPEX max\n",
      "3                         lifetime\n",
      "4            Construction time min\n",
      "5        Construction time typical\n",
      "6            Construction time max\n",
      "7                Discount rate min\n",
      "8                Discount rate max\n",
      "9              Capacity factor min\n",
      "10         Capacity factor typical\n",
      "11             Capacity factor max\n",
      "12                       FIXED O&M\n",
      "13                    Variable O&M\n",
      "14                       Heat rate\n",
      "15    Fuel cost min primary energy\n",
      "16    Fuel cost max primary energy\n",
      "17           Exchange euro to euro\n",
      "18               Fuel cost min MWh\n",
      "19               Fuel cost max MWh\n",
      "20                   CO2 intensity\n",
      "Name: Roughly LUT parameters, dtype: object\n"
     ]
    }
   ],
   "source": [
    "techdata=np.zeros([nparams,ntech])\n",
    "#Parameter names\n",
    "param_names=df[keynames[0]]\n",
    "print(param_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(ntech):\n",
    "    #test=pd.DataFrame(df,columns=[keynames[i+2]])\n",
    "    test=df[keynames[i+2]]\n",
    "    techdata[:,i]=test[0:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Read the parameters needed for net present value calculation. Careful with the order!\n",
    "2. Generate random samples for those that are uncertain\n",
    "3. Compute the NPV for this particular set of parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Roughly LUT parameters', 'Units', 'Wind onshore', 'Wind offshore',\n",
       "       'PV', 'PV rooftop', 'Nuclear', 'Natural gas CCGT', 'Natural gas OCGT',\n",
       "       'Coal', 'Coal extend'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keynames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.19621680316129744\n"
     ]
    }
   ],
   "source": [
    "i=0\n",
    "x=0\n",
    "co=0\n",
    "loopsamples=11\n",
    "co2min=0\n",
    "co2max=40.0  #euros/ton CO2\n",
    "#CO2v=np.linspace(co2min,co2max,loopsamples)\n",
    "CO2v=np.zeros(loopsamples)   #CO2 tax euros/ton CO2...zero for now\n",
    "dmin=-0.05  #minimum discount\n",
    "dmax=0.1    #maximum discount\n",
    "discountv=np.linspace(dmin,dmax,loopsamples)\n",
    "samples=5000\n",
    "NPV_techv=np.zeros([samples,loopsamples,ntech])\n",
    "LCOE_techv=np.zeros([samples,loopsamples,ntech])\n",
    "It0v=np.zeros([samples,loopsamples,ntech])\n",
    "rv=np.zeros([samples,loopsamples,ntech])\n",
    "cfv=np.zeros([samples,loopsamples,ntech])\n",
    "#40 euros/MWh wholesale average\n",
    "#filename_add='_low_wholesale_30penetration'   #Add to filenames to clarify\n",
    "filename_add='_low_wholesale'\n",
    "wholesalemin=35-12*0   #20  -12 euros/MWh is about the OECD/NEA 2019 estimate for wind price drop at about 30% penetration\n",
    "wholesalemax=45-12*0   #80\n",
    "#filename_add='_high_wholesale'   #Add to filenames to clarify\n",
    "#wholesalemin=70-12*0   #high cost option\n",
    "#wholesalemax=90-12*0   #\n",
    "It0=np.random.uniform(low=techdata[0,i],high=techdata[2,i])\n",
    "n=int(techdata[3,i])\n",
    "construction_period=int(np.random.uniform(low=techdata[4,i],high=techdata[6,i]))\n",
    "cf=np.random.uniform(low=techdata[9,i],high=techdata[11,i])\n",
    "r=np.random.uniform(low=techdata[7,i],high=techdata[8,i])\n",
    "OMkwh=(techdata[13,i]+np.random.uniform(low=techdata[18,i],high=techdata[19,i]))/1000  #Euros/kWh variable O&M\n",
    "OMfixed=techdata[12,i]\n",
    "CO2intensity=techdata[20,i]  #tons CO2/MWh\n",
    "NPV_techv[x,co,i]=NPV2(construction_period,n,r,cf,It0,OMkwh+CO2intensity*CO2v[0]/1000,OMfixed,wholesalemin,wholesalemax)/It0\n",
    "print(NPV_techv[x,co,i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IRR= 0.5705234076723075 0\n",
      "IRR= -1.3627722142706176 1\n",
      "IRR= -3.79994646179847 2\n",
      "IRR= -6.542901460621632 3\n",
      "IRR= 4.458411600775271 4\n",
      "IRR= -200.0 5\n",
      "IRR= -200.0 6\n",
      "IRR= -200.0 7\n",
      "IRR= -200.0 8\n"
     ]
    }
   ],
   "source": [
    "wholesale=0.5*(wholesalemin+wholesalemax)\n",
    "i=0\n",
    "for i in range(ntech):\n",
    "    n=int(techdata[3,i])\n",
    "    OMfixed=techdata[12,i]\n",
    "    CO2intensity=techdata[20,i]\n",
    "    It0=techdata[1,i]\n",
    "    construction_period=techdata[5,i]\n",
    "    cf=techdata[10,i]\n",
    "    OMkwh=(techdata[13,i]+0.5*(techdata[18,i]+techdata[19,i]))/1000\n",
    "    if (i==0):\n",
    "        internal_rate=IRR(construction_period,n,r,cf,It0,OMkwh+CO2intensity*CO2v[co]/1000,OMfixed,wholesale-12)\n",
    "    else:\n",
    "        internal_rate=IRR(construction_period,n,r,cf,It0,OMkwh+CO2intensity*CO2v[co]/1000,OMfixed,wholesale)\n",
    "    print(\"IRR=\",internal_rate*100,i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Techonology:  Wind onshore 0\n",
      "IRR mean:  -6.03937947349278e-05\n",
      "Techonology:  Wind offshore 1\n",
      "IRR mean:  -0.052209460540530446\n",
      "Techonology:  PV 2\n",
      "IRR mean:  -0.04121850519210491\n",
      "Techonology:  PV rooftop 3\n",
      "IRR mean:  -0.06909863304627738\n",
      "Techonology:  Nuclear 4\n",
      "IRR mean:  0.03103932162519896\n",
      "Techonology:  Natural gas CCGT 5\n",
      "IRR mean:  -2.0\n",
      "Techonology:  Natural gas OCGT 6\n",
      "IRR mean:  -2.0\n",
      "Techonology:  Coal 7\n",
      "IRR mean:  -2.0\n",
      "Techonology:  Coal extend 8\n",
      "IRR mean:  -2.0\n"
     ]
    }
   ],
   "source": [
    "#Loop over all techs and generate all samples for different CO2 prices or discount rates\n",
    "meanLCOE=np.zeros([loopsamples,ntech])\n",
    "minLCOE=np.zeros([loopsamples,ntech])\n",
    "maxLCOE=np.zeros([loopsamples,ntech])\n",
    "meandiscountedROI=np.zeros([loopsamples,ntech])\n",
    "mindiscountedROI=np.zeros([loopsamples,ntech])\n",
    "maxdiscountedROI=np.zeros([loopsamples,ntech])\n",
    "internal_rate_techv=np.zeros([samples,ntech])\n",
    "meanIRR=np.zeros(ntech)\n",
    "stdIRR=np.zeros(ntech)\n",
    "for i in range(ntech):\n",
    "    print('Techonology: ',keynames[i+2],i)\n",
    "    n=int(techdata[3,i])\n",
    "    OMfixed=techdata[12,i]\n",
    "    CO2intensity=techdata[20,i]\n",
    "    for co in range(loopsamples):\n",
    "        for x in range(samples):\n",
    "            It0=np.random.uniform(low=techdata[0,i],high=techdata[2,i])            \n",
    "            construction_period=int(np.random.uniform(low=techdata[4,i],high=techdata[6,i]))\n",
    "            cf=np.random.uniform(low=techdata[9,i],high=techdata[11,i])\n",
    "            #r=np.random.uniform(low=techdata[7,i],high=techdata[8,i])\n",
    "            r=discountv[co]\n",
    "            rv[x,co,i]=r\n",
    "            It0v[x,co,i]=It0\n",
    "            cfv[x,co,i]=cf\n",
    "            OMkwh=(techdata[13,i]+np.random.uniform(low=techdata[18,i],high=techdata[19,i]))/1000  #Euros/kWh variable O&M\n",
    "            NPV_techv[x,co,i]=NPV2(construction_period,n,r,cf,It0,OMkwh+CO2intensity*CO2v[co]/1000,OMfixed,wholesalemin,wholesalemax)/It0\n",
    "            LCOE_techv[x,co,i]=LCOE(construction_period,n,r,cf,It0,OMkwh+CO2intensity*CO2v[co]/1000,OMfixed)*1000 #euros/MWh\n",
    "            if (i==0 or i==1):\n",
    "                wholesale=0.5*(wholesalemin+wholesalemax)-12*0  #wind at 30% sees 12 euros drop\n",
    "            else:\n",
    "                wholesale=0.5*(wholesalemin+wholesalemax)\n",
    "            if co==0:\n",
    "                internal_rate_techv[x,i]=IRR(construction_period,n,r,cf,It0,OMkwh+CO2intensity*CO2v[co]/1000,OMfixed,wholesale)\n",
    "                #if internal_rate_techv[x,i]<-0.99:\n",
    "                #    internal_rate_techv[x,i]=internal_rate_techv[x-1,i]\n",
    "        meanIRR[i]=np.mean(internal_rate_techv[:,i])\n",
    "        stdIRR[i]=np.std(internal_rate_techv[:,i])\n",
    "        meanLCOE[co,i]=np.mean(LCOE_techv[:,co,i])\n",
    "        meandiscountedROI[co,i]=np.mean(NPV_techv[:,co,i])\n",
    "        minLCOE[co,i]=np.min(LCOE_techv[:,co,i])\n",
    "        maxLCOE[co,i]=np.max(LCOE_techv[:,co,i])\n",
    "        mindiscountedROI[co,i]=np.min(NPV_techv[:,co,i])\n",
    "        maxdiscountedROI[co,i]=np.max(NPV_techv[:,co,i])\n",
    "    print(\"IRR mean: \",meanIRR[i])\n",
    "            \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Native numpy format save for speed and for saving space\n",
    "#filename_add='_low_wholesale_30penetration'\n",
    "np.save('./data/samples_NPV'+filename_add+'.npy', NPV_techv)\n",
    "np.save('./data/samples_LCOE'+filename_add+'.npy', LCOE_techv)\n",
    "np.save('./data/samples_It0'+filename_add+'.npy', It0v)\n",
    "np.save('./data/samples_r'+filename_add+'.npy', rv)\n",
    "np.save('./data/samples_cf'+filename_add+'.npy', cfv)\n",
    "np.save('./data/samples_IRR'+filename_add+'.npy',internal_rate_techv)\n",
    "np.save('./data/meanLCOE'+filename_add+'.npy',meanLCOE)\n",
    "np.save('./data/meanROI'+filename_add+'.npy', meandiscountedROI)\n",
    "np.save('./data/minLCOE'+filename_add+'.npy',minLCOE)\n",
    "np.save('./data/minROI'+filename_add+'.npy', mindiscountedROI)\n",
    "np.save('./data/maxLCOE'+filename_add+'.npy',maxLCOE)\n",
    "np.save('./data/maxROI'+filename_add+'.npy', maxdiscountedROI)\n",
    "np.save('./data/meanIRR'+filename_add+'.npy',meanIRR)\n",
    "np.save('./data/stdIRR'+filename_add+'.npy',stdIRR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Read existing samples\n",
    "#filename_add='_low_wholesale'\n",
    "NPV_techv_LUT=np.load('./data/samples_NPV'+filename_add+'.npy')\n",
    "LCOE_techv_LUT=np.load('./data/samples_LCOE'+filename_add+'.npy')\n",
    "It0v_LUT=np.load('./data/samples_It0'+filename_add+'.npy')\n",
    "rv_LUT=np.load('./data/samples_r'+filename_add+'.npy')\n",
    "cfv_LUT=np.load('./data/samples_cf'+filename_add+'.npy')\n",
    "internal_rate_techv_LUT=np.load('./data/samples_IRR'+filename_add+'.npy')\n",
    "meanLCOE_LUT=np.load('./data/meanLCOE'+filename_add+'.npy')\n",
    "meandiscountedROI_LUT=np.load('./data/meanROI'+filename_add+'.npy')\n",
    "minLCOE_LUT=np.load('./data/minLCOE'+filename_add+'.npy')\n",
    "mindiscountedROI_LUT=np.load('./data/minROI'+filename_add+'.npy')\n",
    "maxLCOE_LUT=np.load('./data/maxLCOE'+filename_add+'.npy')\n",
    "maxdiscountedROI_LUT=np.load('./data/maxROI'+filename_add+'.npy')\n",
    "meanIRR_LUT=np.load('./data/meanIRR'+filename_add+'.npy')\n",
    "stdIRR_LUT=np.load('./data/stdIRR'+filename_add+'.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Roughly LUT parameters', 'Units', 'Wind onshore', 'Wind offshore',\n",
       "       'PV', 'PV rooftop', 'Nuclear', 'Natural gas CCGT', 'Natural gas OCGT',\n",
       "       'Coal', 'Coal extend'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keynames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.03764185, -0.02069361, -0.04131556, -0.06925404,  0.03098846,\n",
       "       -2.        , -2.        , -2.        , -2.        ])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "meanIRR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.01283573, 0.01062781, 0.00734709, 0.01083055, 0.00651141,\n",
       "       0.        , 0.        , 0.        , 0.        ])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stdIRR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 Wind onshore -0.00603937947349278 1.1032699394950016\n",
      "9 Wind offshore -5.220946054053044 0.9432465109942796\n",
      "9 PV -4.121850519210491 0.7374583835635047\n",
      "9 Nuclear 3.103932162519896 0.6609004900264628\n",
      "[-0.00603938 -5.22094605 -4.12185052  3.10393216]\n",
      "[1.10326994 0.94324651 0.73745838 0.66090049]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAq4AAAIeCAYAAAB6NY1zAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3U+QHOd55/nf090AGhgP2WxTHM9Ysyab8nmoZvNi6TBLAtqD90QDYDi0eyMBzXlkQNTF7Y0NkU15zxZA3XYdXhKgbnuQAGjGuxYnYghAvo/YpCI0Y4kiAZD2AA2gu549ZBY6Uaj/T9X7VmZ9PxEVQP3pqiernsp88q0n3zR3FwAAADDrFnIHAAAAAAyDwhUAAAC1QOEKAACAWqBwBQAAQC1QuAIAAKAWKFwBNIKZreWOYVxmtp47hiYxs3UzO25mRwc87lSqmDDf6rx+mjUUrsAEmNnKtIuPSb1GilhTK5enzsu0lTuApihz4ai7X5S0bWbnzGyl4zFrZnYtT4T9NfH7CUnSOp/rZFC4YiRmdtTMtsrLmfaIhZmdqTzmuJl9OOLznmnvkZYr7jMd94/8nKmUK6MLkqa2IZzUa6SINbWyKDldFirt27bM7EMzczO70JlPHX/f+dijXe6/WT6mne9r5eOvlYXRVvmvm9mlyvVL5W3HB8R/q+O2gd+zWTKp72dluc+U798jI6LlaOqp8rGnuoyqbkk6L0nuvi3pQ0mrZYzHy8/iqKQb7n4+GvMklevAR76f017/zfL6tSnK9dPpzp0ojMHduXAZ6iLpuKStjtvWJJ2TdKly23rn44Z47g8lHS//f1TSzY77R37OxO/NSvF1mv3XSBFrl9dcn+Jzb0la63L7qWGXs3zszQH3r1eur0s61+VxrmK0r/Nvzwx47qOV60N9z2bpMonvZ/m973zvrlXfu/J9uNTxmAvVz7/LuuN4l9e61C1nBi1jwvfTJ/3+Tvvz4zLU+7zG+xy/MOKKUWy5+9nqDV6MaFzouO165+MGcfdnvRwxc/fL7v5E9DlTcvdbgx81G6+RItYu+vYaBq2XedjNpJZ1u+O5VjXkz/s+eFTvhLtfrlwf6ns2Syb0/Tzd5bbLHbefVlHAV53Tw5/FjY77O0ezT0m63idneplmDvc17fXfrK9fm6LMOdoFgihcMYrVbjeWG90cxRDq45VpPGn5s2+Ogm5lxMKn6/ejW5uA5vt7dqzLbdVlPi7pesf9V8vb2zrfvwc/zVbaSsYp0qaSw5g7FzgoMIbCFSPpc5Tuucpj1gcdzTvG6078OTF9Zb/ylqY3yvCKpHen9Nz9jDpad7XH7SclvdN545Dfs0cO4mnflrqPbhLfT3c/0aWgPK7y/SmXaU0dI6rtXxAqR22/27H81cJ3S9JIReugHB72c4h8XtNe/83r+jXFZ9fFu5JOjB81lnIHgFp5Q9IlMzsr6Xz1J+f2T53ll/h1FRsca99fjoy1H7+iYmTlbGWjUx0xeUHSG5X7HnnOciXytoqNyRPa/xnvBUkfeOVAnR7P/467Xx/1eUZRHuywpuK9Ol3edlT7G99VFQeIXOxYpjVJz6goao6p6KW8/OgrjP4aI8ba7zMZ9n07qXLEq9z4S9KH1Z/P+73OENZztD64e+eo37iPP+HunaOMw3zP1lQUYdXvxEp52ylJz6syMjlk3nV+lsdU9JNerHxGa2Ucb1Weu+t3Pqryk377tVbL1+71ea+p2KE4Wy7DxTK2q+XzrUta7fVd6qNnDg/7OYz6eXW8D93Wf2fK21ZU5FD7s1xT0Rd8o7z9enl7v89/lPXrUDlRPsck1h8DDVrf9dr2aL/dZ2Kf3aDtXPk+3TKzjWGXD13kbrLlUq+LpDMqDkBxFQdU9Towxiv/73bQxbn236lYIVQPrlhXl4NQ9OgBCyvqfjBM5+POSDrVcduHldcf6nmGeG86X/ecip+U29e7HXTzUGwqVsA3tX+g2hlVDi6ZxGuM8Dx9P5MR3v+eB4MN+9n3ec8/7HNf3wOuRnlsmcMDD+bp9n70eeyKpAs97hv5e1a57aYePpBsmLzr+Vl2ue1DdTlQadTvS5/35XiZj+c6bl/vk0cD33cVBd1KZXmPq8uBW30+q57LN8znMIHHecf1o93yv8tnPe46YeycmOT6Y4hc6blsGrDtmeRnN8xrVf9u2GXk0uVzzx0Al3peyi/pVrnC8n5fcnU5qrpc4bQ3IufUsQEvn3Ol13N2PK7ztR+sRMuV4yMriTL2rWGfZ8j3pLrMjxxFXq7kVgbd3i2WabzGgOcZ+jMZ9L6pf+E61Ov0+NsVSdf63D/rhespDSicRvme9Xn/x8678rk6C5wLnbf1iiVyaX++le/y2IWrimKmOjvBhcr/Bxav/XJ42M9hAo/rdlu3Aqvz8xp5nRDNiUmuPwZ8Ln2XTQO2PZP87IZ5rcrt17rdzmW4C60CGIsXP7ddlnTWzM6pWHE92+Ph70r6yMyOlY+77A//FHRWxTyL65I2tN/DtqrhDkbp12+4IT3ys5UkfdbluUftW+zKzC6p44jz8uesG979Z85tlT9ttm/wAT9FT+I1ej1PaZTPJPK+RT77R/odR2FmKz3eq1S6tQk8ZMTv2SPGyIlun+VEvhej8uIn1XOSrqj4OVnS6J9b+bPuK+7+fHn9lB7uK741A7kwrjdUzLRQbRN60PM9zjqhx+OGua1q6uuPIZdt0LZnkkZ5rRsq1l8jtRyhwMFZGFpnc3rFWUlrvZrUyxXLMyrmTjwt6UMzqx4Jvqr9uRjPl1/2oTciAzY4ayp7njoub3nHNEWT2HCVvWfn9OiUPf1O93dDRW9X0tfo8zzSCJ9J8H2LfPbRz+tk5f+DCuCVIR4ztB6zCbTvG+t71sNIOdHjs5zYco/hsqSVskhpFzgPzRpQeT96FUBvS3qtcv1Yx2OvqtzBraHzejiP1zo+w/B6Z8ycSLH+GLhsQ2x7JmaM16rjjtJMoHDFUNqjFt3uK7+w2+oxjY+Zrbv7rbJYfF7F6MmK7U8JcklFP9sje6cTODq6Z1zTUC5j+1ST1bMc9RtVWFXxk1PS1+jzPNIUP5OOI3Ejr9MetRhX9fmvd1zv1FkQRPWaTWDs71kPE8u7abLiTGQ3+xTtK5Xl7/ycViXd8i7Tk1VG5aojW2uqFA3l846U02MeTT5xZexXrTjz1Yoe/bxzff7TXKe3DVy2IbY9EzPia4V+LZp3FK4YRc/TVkoPJlfu5hXbn6qmvbI9K+lZ25/ipnNKo/bKbSO4oqseUfyQKU//ckLS65Xlvqreo2XrGm9Kp0m9xkPPM+nPpEvBN5HXKZ93rJ2Saj6Wz7Wt4gjiVPMrnui2US+N9D3r8h5Vl20aeTcN7aKrcx3SXpZ24XlZj46Orpe3d9Nt+quHit9+o99tvXK4asDnMPLjRnBOxQjfUX90xoTkn3+CdXrbMMvWc9vTJeaqcT67oV6rtFrT1pSZQOGKkVhxHvGVzts0+CxCnRuPVRXTntyqXG8/31Htj4AN7D3rseKqTp1ztjO+8jWudtzW83lGVb7ueZWT45fXT3eJY0sd06Wkfo0ezyMN+ZkM+b5tV1bqq+XIRPiz1/j9lxf0aLFyQkUv6UMbrfL9G3hO+8r70HejPEyhNML37LoqG8/KT+rV/B86Jyb5HbBinstzwxQp5YjoIyPQKr67b1WK9bN6dA7M0+oyN2v5K0K3qdUu6eHid0O959mteiSHK/f1/RzGeNzQyh2gjW7PMYn1zqg5MaX1R6/XGWbZum57Ktcn+dkNeq22LH3jjTHpo724NPOi/eljVlQekV9ezunh6ZrWVBQFXv67pvI87+XfP7hU/uZo+djj5f/XO27r9pydt62XsZ0rb7umh8//3j46+5QqU7WM+jw93pv1ynNUp/mqPkd1ypQzZRydU12td8TS675JvUbP5xnjMxn0/q+3c6XL59LzdYbIy3PqcgRyeXv7SPz2KUG3yue9Wd7e7Rz27WWo/k3fo3/L92JLRUHk5eue65U36jObgIb8nnW8r+05Jo+X16+p48jvATkx9GdZvtbN6vN3+fvqd+umhvgcO96brTLGc+o+e0F1mc90e5/L1+45rZoenlXgkdfo8z1/JIdH/Bz6Pq7HZ9H1/e14/a7TpY35+Y+0fu2RExNdfwz4XPotW99tz4Q/u4GvVY132O8El0cvVr6RAFA7ZQvIaS9PmlAHZnbJB8wm0CRmdtyndyR3r9dcV4++1/L+FZWT3qeODfOtnCljq1duYjCmwwJQW16c/SzaI5jMMG0CDZR8eX3AdHJe/IxMwYocVilaY+hxBVB3WwkPqorqOptAU5WjraOeYhVopHI91W36QYyAwhVArZWF0bPDHAQ0A47N2U/T8za6DHRVrp9W2JGLo3AFUHvuflYPT8Q+q+Zq7kY20sADR939rdxBNAEHZw3w5JNP+tNPP507jMa4f7/498CBvHGgvsghRJA/iCKHpuPatWufuvuXBj2Og7MGePrpp3X16jBT/GEY//W/Fv/+/u/njQP1RQ4hgvxBFDk0HWb2y2EeR+GKpA4dyh0B6o4cQgT5gyhyKK+563Etz0gzzVN9AgAAYArmqnAt53s8owGnZMT07O4WF2Bc5BAiyB9EkUN5zVurQOd5vpEYX3ZEkUOIIH8QRQ7lNTcjruXEv3Mz8fesWl4uLsC4yCFEkD+IIofymovCtTIxOadZAwAAqKm5KFwlve7u53MHAXqDEEcOIYL8QRQ5lFfje1zLGQTGbhG4d0/65BNpoSzx79yRDh6UFheL6zs70tJScel2/e7d4m/bExXfu1f8e/Bg8e/9+1KrtT+9RvsL0f4ZovP63l7xHIcPF9dbreI1jxwprrsXMbavS9Lt28XjzfavLy/nWaZPPmneMjXxc5rlZfr1r4tlWlpqzjI18XOa1WX65JP9GJqyTE38nGZ5mX75y+L60lJzlmlWPqdhzMOI67q7Xx/lD8zslJldNbOrN278dlpxzaVDh5gDDzHkECLIH0SRQ3k1esTVzM5IGrlFoGwrOC9JGxsb/tRTk44MTz6ZOwLUVXuDQQ5hHO0RIvIH4yKH8mps4Wpm65K23f1W7liwb28vdwSoO3IIEeQPosihvBpbuEp6xd3P5g4CDxuljwXohhxCBPmDKHIor0YWruWcredyx4FHtZvBgXGRQ4ggfxBFDuXVuIOzyjlbV9ydOVsBAAAapIkjriclHTOzY13uWy3/fd3MTpf/P0EfbDqtVu4IUHfkECLIH0SRQ3k1rnCtzgjQqZzT9ZKkN9z9YtLAIKmYyw2IIIcQQf4gihzKq3GtAphtR448PKkxMCpyCBHkD/rZ3NyUmfW9/MEfFJdBjzMzbW5u5l6kxmnciOsAK7kDAAAAs2lzc3Ngsfm1r/1bSdLPfvYfpx4PHjUXI65mtmVm1yRdKG+6YGbXzIyZBxJzLy7AuMghRJA/QL3NxYgr87nOjjt3ckeAuiOHEEH+IIqDs/Kai8IVs4PeMkSRQ4ggfxC1MBe/Vc8u3n4AAADUAoUrAAAAaoFWASR1+3buCFB35BAiyB9E0eOaF4UrkuIcz4gihxBB/iCKHte8KFyRlFnuCFB35BAiyB+g3thvAAAAQC0w4oqk6C9DFDmECPIHUfS45kXhiqSWl3NHgLojhxBB/iCKHte8KFyRFF94RJFDiCB/gHrjKwwAAIBaYMQVSXGecESRQ4ggfxBFj2teFK5I6uDB3BGg7sghRJA/iGJKtbwoXJHU4mLuCFB35BAiyB9EUbjmRY8rAAAAaoERVyS1s5M7AtQdOYQI8gdR9LjmReGKpJbIOASRQ4ggfxBFq0BefIWRFBsNRJFDiCB/EEXhmhc9rgAAAKgF9j2RFP1liCKHEEH+TNfT3/l/cocwdf/w8U1J87GsH7/5x7lDeASFK5LiZzpEkUOIIH+AeuMrjKTYaCCKHEIE+YMwelyzoscVAAAAtcC+J5K6ezd3BKg7cggR5A/CPHcA843CFUktMMaPIHIIEeQPUG8UrkjqwIHcEaDuyCFEkD8Io8c1K/Y9AQAAUAuMuCKpe/dyR4C6I4cQQf4gjB7XrBhxBQAAQC0w4oqkDh7MHQHqjhxCBPmDMHpcs2LEFQAAALXAiCuSun8/dwSoO3IIEeQPwuhxzYrCFUm1WrkjQN2RQ4ggf4B6o3BFUocO5Y4AdUcOIYL8QRg9rlnR4woAAIBaYMQVSe3u5o4AdUcOIYL8QRg9rllRuCIpNhqIIocQQf4A9UbhiqSWl3NHgLojhxBB/iCMHtes6HEFAABALTDiiqT4mQ5R5BAiyB+E0eOaFYUrkmKjgShyCBHkD1BvFK5Iiv4yRJFDiCB/EEaPa1b0uAIAAKAWGHFFUnt7uSNA3ZFDiCB/0M+tv/trff6zvxnqsb/c+p8HPubxr/2pVr7+zWhYqKBwRVL37uWOAHVHDiGC/EE/K1//5sBCc/eLot9k6bGdFCGhA4Urkjp8OHcEqDtyCBHkD6JsiWH7nOhxBQAAQC0w4oqkWq3cEaDuyCFEkD8Ic6YVyInCFUnt0BKEIHIIEeQPonyPH6tzonBFUkeO5I4AdUcOIYL8QRQ9rnmx2wAAAIBaYMQVSTnneEYQOYQI8gdx9Ljm1NjC1czWJZ2WtCppXdItSe+4+1tZA5tzd+7kjgB1Rw4hgvxBlO/yY3VOjSxczeyUpBV3P125bV3SBTM7Lel5d7+VLcA5Rn8ZosghRJA/iKLHNa/G7TaY2ZqKovWhkVV3vy7pmKQ1SVdyxAYAAIDxNa5wVdEecL7bHe6+LemipPVyBBYAAAA10cTC9aikj8qR124+qDwOid2+XVyAcZFDiCB/EOW7i/LdxdxhzK0m9rjeUHEw1kqP++ltzYjzhCOKHEIE+YMoW+L0azk1rnB192NmttLn4Kvny3+vD/N89+5Jn3wiLZRj03fuSAcPSovlztbOjrS0VFy6Xb97t/jbAwf2n08qnkOS7t8vTkF46FBxfXe3uCwvd7++t1c8R3vl22oVr9k+4MC9iLF6AMLt28XjzfavLy/nWaYbN4r/373bnGVq4uc0y8t082axTGbNWaYmfk6zukw3b+7H3JRlmqXPafeL5f2Dl9zkewuVg5lMvrvw0MFNvrtYFoK+f32xJVmf6wsuLbS6X99bkEyy6nWpeA5J3lqQfP+6Wgvylu3H1Hm9cxnctPtPh8rr3phl6vU5ffppcUuq3BtGE1sFNGDGgJOSbrn75V4PMLNTZnbVzK7euPHbyQcIAACAkTVuxLUfMzuuooXgRL/Huft5lQd4bWxs+FNPJQhuTrR7y7785bxxoL72ykGBJ5/MGwfqaWen+Pdf/+u8cTTV0mM7I/7F/Qlfn772iOfikV6vXb9l6mUW17NzU7iWB2tdkHTe3S/mjmdetX9SAsZFDiGC/EHUg5/kkcXcFK7aL1pPD3wkpmahkc0pSIkcQgT5gzDjvME5zcVX2MzOSbpK0QoAAFBfjR9xNbMzkkTROhs4TziiyCFEkD+I2p/DdXZ6UedJowtXMzsl6dluReuAKbMwJe1pVoBxkUOIIH8QRY9rXo1tFTCzo+pTtEo6lT4qLC7uz/MGjIMcQgT5gzBz+lwzamThambrko65+9keD9nQkCcgAAAAwGxoXKtAZdqry+VBWZ1WJR3V/hm0kNDOqFP8AR3IIUSQP4iixzWvxhWuKorWNQ1oBXD37TThoGqpiRmHpMghRJA/iLIF2gRyatxX2N0ZSZ1hbDQQRQ4hgvxB2AIHZ+XUyB5XAAAANA/7nkiK/jJEkUOIIH8QRY9rXhSuSIqf6RBFDiGC/EEUPa558RVGUmw0EEUOIYL8QRg9rlnR4woAAIBaYN8TSd29mzsC1B05hAjyB1G+x5hfThSuSGqB7zuCyCFEkD8Is9wBzDcKVyR14EDuCFB35BAiyB9EGT2uWbHvCQAAgFpgxBVJ3buXOwLUHTmECPIHUfS45sW7DwAAgFpgxBVJHTyYOwLUHTmECPIHUbZIj2tOjLgCAACgFhhxRVL3ObUzgsghRJA/iPIWY345UbgiqRa/sCCIHEIE+YMwzx3AfKNwRVKHDuWOAHVHDiGC/EEUPa55Md4NAACAWmDEFUnt7uaOAHVHDiGC/EEYPa5ZUbgiKTYaiCKHEEH+IMpbljuEuUbhiqSWl3NHgLojhxBB/iDKlvZyhzDXGO/GxGxubsrM+l6+9KXiMuhxZqbNzc3ciwQAAGYII66YmM3NzYHF5h/90b+VJL3//n+ccjRoKn7qRQT5gzB6XLOicEVSzvx3CKLwQAT5gyh6XPOicEVSC+yoIogeRUSQP4iixzUvyggAAADUAiOuSIpWAUTtMdiBAPIHYU6rQE4UrkiKwhVR9+7ljgB1Rv4gyvf4sTonClckRY8rog4fzh0B6oz8QRQ9rnlRRgAAAKAWGHEFUCutVu4IUGfkD8Locc2KwhVJsdFA1M5O7ghQZ+QPouhxzYvCFUnR44qoI0dyR4A6I38QRY9rXpQRAAAAqAVGXAHUClOqIYL8QRw9rjlRuCIpelwRdedO7ghQZ+QPonyXH6tzonBFUvS4IooeRUSQP4iixzUvyggAAADUAoUrAAAAaoFWASRFjyuibt/OHQHqjPxBlO8ulv+7nzWOeUXhiqTocUUU55pHBPmDKFtiBCYnClcAtWLMRIMA8gdxzKmWE+NfAAAAqAVGXJEUPa6IokcREeQPouhxzYvCFUnR44qo5eXcEaDOyB9E2SIjMDlRuAKoFXZ+EEH+IMzocc2JrzAAAABqgRFXJEWPK6I41zwiyB9E0eOaF4UrkmIqGkQdPJg7AtQZ+YMoelzzonBFUhSuiFpcHPwYoBfyB2H0uGZFjysAAABqgRFXJEWPK6J2dnJHgDojfxBFj2teFK5IilYBRC2x1kIA+YMoW6BVIKfGfoXNbEXS6+XVzyT9rqQP3f18vqhA4YooCg9EkD8IW+Cnw5wa+RUui9Zrkk64+/XK7WfM7IK7n8gXHQAAAMbR1IOzLki6WC1aJcnd35K0bman8oSFVos+V8Ts7NCniPGRP4jy3cVKnytSa1zhamZrko5KeqfHQy5KOpsuIlSZ0S6AmKUlfu7F+MgfRNmC0+eaUeMKV0nHJalztLXiA0lrZYGLxChcEUXhgQjyB2ELLfpcM2pi4XpM0q0+92+X/x5NEAsAAAAmpIn7nauSbvS5v13UPjvMk927J33yibRQlvh37hSnDGyffWVn5+E9+M7rd+8Wf3vgwP7zSfunHbx/v+j5PHSouL67W1yWl7tf39srnuPw4eJ6q1W85pEjxXX3Isb2dUm6fbt4fHuk8/bt4vlyLNO9e0WMv/pVc5apiZ/TLC/Tb37TvGVq4uc0q8v0m980b5lm6XPa/WJZtrRXLoTJ9xb2r8vku9XrRb+oLbUk+f71xdaDs1N1vb7gD0Y8H7m+tyCZZNXr2j9Nq7cWJK+ctrW1IG/Zfkyd1zuXwU33P18uY27OMvX6nD79tLglVe4No4mF60r0CcqDt05J0u///v8QDghI5YX//fJMrOzaprEC37t9UFpwLf2zu41Zpm6f09//Rfofhb76v/1kP8aabmjben1Ou7eLqmzx0G5jlqnX5/SfznxDqf2n119qXDHeuYPxy18W13/v95qzTIM+p1nSxMJ10IhrW88Ct5zr9bwkbWxs+FNPTSgyPPiiffnLeeNoqsXfuZs7hA6dZ5aJXt8vDBaP5DprzeSXqZsnnxwhpAnZf0+ns0xp9YixLOoezZ8aL1OP66xnp6NdgOb4jqKZPa7hEVcAAADMniaOuPY7MAuZOTOIIKj9Ey0wDvIHUaP0Y2LymvgNvqGiXWAQClwAAIAaaeKI67akfnO0tu/7IEEs6MAcroh6cPALMAbyB1HtYzWQRxNHXK9Lkpn16nVtF66X04QDAACASWhi4Xqu/Hejx/3PS9p2d1oFMnCnzxUx3looph4CxkD+IOr+/eKCPBr37XX3bUkXJZ3o8ZCTks6miwhVFK4Ic7WnsQRGR/4gqNUqLsijcYVr6TVJR81svXqjmW1JuuzuF/OEhYWF/TnwgHHYYos+RYyN/EHUoUP7k/0jvSYenCV3v2Vmz0t63cxekfSZilO8XnN3RlsBAABqqJGFq1QUr6IlYObQJoAw+hMRQf4gaHc3dwTzrbGFK2YThSuivMWcahgf+YMoCte8KFyRFP2tiLKlvdwhoMbIH0QtL+eOYL5RRgAAAKAWGHFFUrQKIIweRUSQPwiiVSAvClckReGKKHoUEUH+IIrCNS8KVyRFjyui6FFEBPmDKHpc86KMAAAAQC0w4oqkaBVAmPNTLwLIHwTtMWifFYUrkqJwRZTv8UMRxkf+IOrevdwRzDcKVyRFjyui6FFEBPmDqMOHc0cw3ygjAAAAUAuMuAKoF3oUEUH+IKjVyh3BfKNwRVJ84RFFjyIiyB9E7ezkjmC+UbgiKXpcEUWPIiLIH0QdOZI7gvlGGQEAAIBaYMQVQM3Qo4gI8gcxTOuYF4UrkqLHFVG+yw9FGB/5g6g7d3JHMN8oXJEUPa6IokcREeQPouhxzYsyAgAAALVA4QoAAIBaoFUASdHjiijfXSz/dz9rHKgn8gdRt2/njmC+UbgiKXpcEWVL7P1gfOQPog4fzh3BfKNwBVAzzEWDCPIHMcaMalkx/gUAAIBaCI+4mtljkl6Q9LikW5KuuvsX0edFM9Hjiih6FBFB/iCKHte8QoWrmf2JpJsqitXPzexxSS+Y2TPu/sOJRIhGoccVUbbI3g/GR/4gank5dwTzrWfhamavSfJeBaiZvezu71Vvc/fPJV2p3P+jSQYLADJ6FBFA/iCIAZi8er797v62pG+Z2Y/N7OkuDxnUnkz7MgAAACZm0H7DCUkXJZ03szc67rtsZu+a2ctm9pyZPV3++5qZvSPp0lQixsza3NyUmfW9vP/+3+r99/924OPMTJubm7kXCTPIdxcrfYrAaMgfRN25U1yQR9/C1d0/kvSZu39D0kdm9oGZvVje97m7n5T0u5K+q6LAfb24y1/hAK35s7m5KXfve/n1r4vLoMe5O4UrurLFFn2KGBv5g6iDB4sL8hj64Cx3P1+OpG6Z2WlJr7r7P5Ymw4/1AAAgAElEQVQtBW9PLUI0yiIDHYiiRxER5A+C2I7lNUyL8YNe1XKU9VuStiT9BzP79tQiAwAAACr6Fq7lHK3XOm939+vuvlE8xD4ws38zrQDRLDs7xQUYFz2KiCB/EMV2LK9BrQJvSfqFmW1L+lzSivbnbf3C3b9vZm+rOHjrM0ln6W1FP0ucZBhBtsBPvRgf+YMotmN59ZvH9UVJW+UBWp33Pd7+v7vfknTSzI5K+qmZfY/5W9ELX3iELXBgDQLIHwSxHcurX6vAE92KVunBiQY6b7tctg8822fuVwAAAGAs/QrXbTP7dtnn+oCZPWZmL/f6I3f/vqRvqWgrAB5CbxCi6FFEBPmDKLZjefUc8Hb3n5uZJF00s+cl3ZC0KuldSWf7PWmvkVqAn1gQRY8iIsgfRLEdy6vv2+/uP5f0jUSxYA7whUcYPYqIIH8QxHYsr2HmcQUAAACyY78BSd29mzsC1J3vsb+N8ZE/iGI7lheFK5JaYJuBKBv8EKAn8gdBbMfyonBFUgcO5I4AdWf0KCKA/EEU27G82G8AAABALTDiiqTu3csdAeqOHkVEkD+IYjuWF99gAAAA1AIjrkjq4MHcEaDubJEeRYyP/EEU27G8GHEFAABALTDiiqTu388dAerOW+xvY3zkD6LYjuVF4YqkWvxKhyhONY8I8gdBbMfyonBFUocO5Y4AdUePIiLIH0SxHcuL30wAAABQC4y4Iqnd3dwRoPboUUQE+YMgtmN5UbgiKb7wiPIWJ5vH+MgfRLEdy4vCFUktL+eOAHVnS3u5Q0CNkT+IYjuWVyMLVzNbl3Ra0qqkdUm3JL3j7m9lDQwAAABja1zhamanJK24++nKbeuSLpjZaUnPu/utbAHOOX5iQRg9ioggfxDEdiyvRn2DzWxNRdH60Miqu1+XdEzSmqQrOWJDYXeXLz1ivGX0KWJs5A+i2I7l1bQR19OS3uh2h7tvm9lFScfNbL0sZge6d0/65BNpoSzx79wpzlO8uFhc39mRlpaKS7frd+8Wf3vgwP7zSfvnOr5/v5jMuD0vXPsL0e6h6by+t1c8x+HDxfVWq3jNI0fay1nE2L4uSbdvF48327++vJxnmf77f9//wjdlmWbpc9r7p0PSQjFPpe8tSCZZ9br257H01oLklXktWwvylu33AHZed5PvLfS+LpPvLjzUQ+i7i7KlltqzvvvuYvF61uf6gu8vQ+f1vQW17i5KC6692wcas0zdPqdPPy1eL2Xu7d0+MNVlmoXPqXW/iGX3i+XGLFOvz+lXv5qP9V7qZfr00+L6p582Z5lm5XMaRqNGXCUdlfRROfLazQeVx/VkZqfM7KqZXb1x47cTDRAAAADjadqI6w0VB2Ot9Lh/qN5Wdz8v6bwkbWxs+FNPTSY4FHt6kvQv/kXeOJpq8Xfu5g6hQ+dJvaPXpb2FYjRp8UiuE4ZPfpm6efLJEUKakP33dDrLlFb/GBf/WecQT/2XqfP6l7881WDmlpenDc7xHUXDCld3P2ZmK30Ovnq+/HeoNgFM3ig/BwDdtH+iBcZB/iCK7VhejSpcJWnAjAEnJd1y98up4sHD2j01wLiYhxMR5A+i2I7l1bjCtRczO66iheBE7lgAAAAwurkoXMuDtS5IOu/uF3PHM89ardwRoPacqYwQQP4giO1YXtkKVzNbkbQReY4RfvJvF62nBz4SU7WzkzsC1B09ioggfxDFdiyvnCOup1TMuzquW2b20qCzYJnZOUlXKVpnQ3VeOGAc9CgigvxBFNuxvLIVruXZrd4a+MAAMztTvhZFKwAAQM019jcTMzsl6dluRWvZpoAM3PfnwAPGY+UFGAf5gxi2Y3k1snA1s6PqX7SeSh8VpOK0cHfu5I4Cdea7C/LdRq66kAD5gyi2Y3k1blYBM1uXdMzdz/Z4yIY4AUE29AYhih5FRJA/iGI7llejCtfKtFeXy4OyOq1KOqr9M2gBAACgJhpVuKooWtc0oBXA3bfThAMAAIBJaVTh6u6MpM6427dzR4C6893F8n/3s8aBeiJ/EMV2LK9GFa6YfZzjGVG2xGlrMD7yB1Fsx/KicEVSxiw0CGMeGkSQP4hhO5YXc4IAAACgFhhxRVL0BiGKHkVEkD+IYjuWF4Urklpezh0B6s4W6VHE+MgfRLEdy4vCFUkt0JyCKKNHEQHkD4LYjuXF2w8AAIBaYMQVSXF+Z0TRo4gI8gdRbMfyonBFUgcP5o4AdUePIiLIH0SxHcuLwhVJLS4OfgzQFz2KiCB/EMR2LC96XAEAAFALjLgiqZ2d3BGg7uhRRAT5gyi2Y3lRuCKpJTIOQbbAT70YH/mDKLZjefH2Iym+8Ahb4OAaBJA/CGI7lhc9rgAAAKgF9huQFL1BiKJHERHkD6LYjuVF4Yqk+IkFUfQoIoL8QRTbsbx4+5EUX3iE0aOICPIHQWzH8qLHFQAAALXAfgOSuns3dwSoO99jfxvjI38QxXYsLwpXJLXANgNRljsA1Br5gyC2Y3lRuCKpAwdyR4C6M3oUEUD+IIrtWF7sNwAAAKAWGHFFUvfu5Y4AdUePIiLIH0SxHcuLbzAAAABqgRFXJHXwYO4IUHe2SI8ixkf+IIrtWF6MuAIAAKAWGHFFUvc5PTiCvMX+NsZH/iCK7VheFK5IqsWvdIjiVPOIIH8QxHYsLwpXJHXoUO4IUHf0KCKC/EEU27G8+M0EAAAAtcCIK5La3c0dAWqPHkVEkD8IYjuWF4UrkuILjyhvcbJ5jI/8QRTbsbwoXJHU8nLuCFB3trSXOwTUGPmDKLZjefGbCQAAAGqBEVckxU8sCKNHET3c+ru/1uc/+5uJPd/jX/tTrXz9mxN7PjQD27G8KFyRFF94RNGjiF5Wvv7NgYXmP/yf35Uk/cv/9XspQkIDsR3Li8IVSdEbhCh6FBHCfg+C2I7lxW9uAAAAqAVGXJHUHoNliHKGzBDAKV8RxHYsLwpXJHXvXu4IUHe+xw9FAPJhO5YXhSuSOnw4dwSoO3pcEcKAPYLYjuXF0AUAAABqgRFXJNVq5Y4AtUePKyLocUUQ27G8KFyR1M5O7ghQd/S4AsiJ7VheFK5I6siR3BGg7uhxRQgD9ghiO5YXQxcAAACoBUZckZTTX4YwhswA5MN2LC8KVyR1507uCFB3vssPRQig6EAQ27G8KFyRFL1BiKLHFSEM2COI7VheDF0AAACgFihcAQAAUAtzU7ia2ZaZHc0dx7y7fbu4AOPy3UX57mLuMFBXLvpcEcJ2LK+56HE1szVJZyR9kDuWecc5nhFlS5y2BgH0uCKI7Vhec1G4StrKHQAKxkYDYQyXAciH7VhejS9czeyUpHckHR/n7+/dkz75RFoomyru3JEOHpQWy18qd3akpaXi0u363bvF3x44sP98UvEcknT/fnHe40OHiuu7u8Vlebn79b294jnae3ytVvGa7aMc3YsYq0c93r5dPL79Zbt9u3i+HMv02WfF/3d2mrNMs/Q57f3TIWmhGJH0vQXJJKtel2SL5fXWguT719VakLds/6j9zutu8r2F3tdl8t2Fh476993FcoTU968vtiTrc33B95eh8/reglo7S9KCN2qZun1On35avF7K3Nu7fWCqyzQTn9Ne8QXb/WK5OcvU43P61a/mY72Xepn+23/bv96UZZqVz2kYje5xNbOV8r/bI/7dKTO7amZXb9z47RQim1937jAHHmLocUWEu8mdITOMj+1YXk0fcX3d3c+a2foof+Tu5yWdl6SNjQ1/6qmpxDaXWuVgBO/pdCz+zt3cIXS4P+HrKkbBJC0eefS+NCa/TN08+eQIIU3I/ns6nWVKq3uM7RHRpcd2hnr8bBntc/jyl6cazNzL8R1FgwvXcgaBd3LHgYctNHqMH0kYPa4IYLAVQWzH8mry27/u7tdzBwEAAIDJaOSIq5mdUflTP2YLfUGI2u9vncWfcjHzGLBHENuxvBpXuJb9rNvufit3LHhU+yhIYFwPjtrGxH385h/nDmHq/uj//b4k6f05WFZMB9uxvLIVruUR/xuR53D3y11ufsXdz0aeF9OzyMHgiKLHFQHMwYkotmN55RxxPSXpdODvb5nZS9WR1XLO1nPhyAAAADBzshWu7v6WpLcm9XzlCO6Ku480ZyvS2umcgQYYET2uiGjRaYIgtmN5NanH9aSkY2Z2rMt9q+W/r5tZe5T3BH2w6S01KeOQRXseV2ActAogiu1YXo15+6snDehUzul6SdIb7n4xaWB4CF949HPr7/5an//sbyb2fI9/7U+18vVvTuz5UH8UrohiO5YXbz+AmbHy9W8OLDT/4f/6riTpX/4v30sREgBghsxL4bqSOwAU6A1CGJ0CCKDHFVFsx/Jq8pmzZGZbZnZN0oXypgtmds3MmHkgk6UlfmYBkI8Z7QKIYTuWV6PfeuZznT182RFG0YEAilZEsR3Lq9EjrgAAAGgO9huQ1N27uSNA7dHjigB6XBHFdiwvClcktcAYP4CMaBVAFNuxvChckdSBA7kjQO1ReCCAwhVRbMfyYr8BAAAAtcCIK5K6dy93BKg9elwR4OQPgtiO5cWIKwAAAGqBEVckdfBg7ghQe/QoIoAeV0SxHcuLEVcAAADUAiOuSOr+/dwRoPboUUQAPa6IYjuWF4UrkmLybwA5Ubgiiu1YXhSuSOrQodwRoPboUUQAk8cjiu1YXnyFAQAAUAuMuCKp3d3cEaD2+KkXAbQKIIrtWF4UrkiKLzyAnChcEcV2LC8KVyS1vJw7AtQePa4IoMcVUWzH8uIrDABohM3NTZlZ38v77/+t3n//bwc+zsy0ubmZe5EAdGDEFUnxEwvC+KkXPWxubg4sNn/96+Lf3/u96ceDZmI7lheFK5LiCw8gJ9ZBiCKH8qJwRVL0BiGMHlcEsA5CFDmUFz2uAAAAqAVGXJHU3l7uCFB79LgigHUQosihvChckdS9e7kjADDPWAchihzKi8IVSR0+nDsC1B49rghgHYQocigvelwBAABQC4y4IqlWK3cEqD16XBHAOghR5FBeFK5IamcndwQA5hnrIESRQ3lRuCKpI0dyR4Dao8cVAayDEEUO5UWPKwAAAGqBEVck5fQnTtXHb/5x7hCm7mv/3/clST+bg2XF5LEOQhQ5lBeFK5K6cyd3BKg7DoxABOsgRJFDeVG4Iil6gxC1QIMTAlgHIYocyotNAAAAAGqBwhUAAAC1QKsAkrp9O3cEqDt6XBHBOghR5FBeFK5IinM8I4oeV0SwDkIUOZQXhSuSMiaPB5AR6yBEkUN5MXYBAACAWmDEFUnRG4QoelwRwToIUeRQXhSuSGp5OXcEqDt6XBHBOghR5FBeFK5IiqIDQE6sgxBFDuXF2w8AAIBaYMQVSXGOZ0TR44oI1kGIIofyonBFUgcP5o4AdcdUNIhgHYQocigvClcktbiYOwLUHYUrIlgHIYocyoseVwAAANQCI65IamcndwSoO3pcEcE6CFHkUF4UrkhqiYxDEK0CiGAdhChyKC/efiTFFx5RFK6IYB2EKHIoL3pcAQAAUAvsNyApeoMQRY8rIlgHIYocyovCFUnxEwuiaBVABOsgRJFDeTX67TezU5JOSLol6Ub57zl3384a2BzjC48oCldEsA5CFDmUVyPffjNbkXRF0mV3P1a5/ZykS5KezRUbAAAAxtPIwlXSNUlb7n6+y32rqYPBvrt3c0eAuqPHFRGsgxBFDuXVuFkFzGxLkroVre5+2t2fSB8V2hYWigswLjPaBTA+1kGIIofyatSIa9kicEbS2Uk957170ief7CfpnTvSwYP75yre2Sn6Xdo9L53X794t/vbAgf3nk4rnkKT794sRpEOHiuu7u8Vlebn79b294jkOHy6ut1rFax45Ulx3L2JsX5ek27eLx7c39rdvF8+XY5m++KL4/95ec5apiZ/TLC/T/fvF8336aXOWqYmf06wu0xdf7L9GU5apiZ/TLC/Tb35TXD9woDnLNCuf0zCats9wsvz3cuRJzOyUmV01s6s3bvx2AmEBAAAgqlEjrpKOSZK7Xzezo5LWVcwksFLe/tYwT1K2GZyXpI2NDX/qqekEO4/ae1X/6l/ljQP11d5Df/LJvHGgnnZ3i39ZB2Fc7RxiHZRH0wrXdUkys3VJK9VC1cyOm9k1SS+5+61cAQIAAGA8TWsVaM8YcNTdL1bvKK/fkPR28qjwwMGD+305wDg4OAsRrIMQRQ7l1bTCdaX893qP+y9JOm5ma4niAQAAwIRkaxUoZwDYiDyHu3cehNXuZ73a40/aBe1RlT2sSOv+/dwRoO7cc0eAOmMdhChyKK+cPa6nJJ0O/P0tM+vsV72hord1UA/r84HXRQCTx6Ofzc1N/cVf/MVQj7Uh+gX+/M//XJubm8Go0CSsgxBFDuWVrXAtD5wa6ij/EVyXNEwbAAdnZdKeZw7oZnNzc2Ch+emnxb8c0YtxsA5CFDmUV9N6XD+QHswq0M1K9XEAAACoj6YVru2+1V69sy+U//Y6eAtT1j6DBzAucggR5A+iyKG8GlW4lr2t59W7d/a4pLfcfTtdVKjiC48ocggR5A+iyKG8GlW4ls5KWjGzM9UbzeyCpG13P5snLEjFuY3b50sGxkEOIYL8QRQ5lFfjCtdy1PV5Sb9rZhfKyyVJH7j7sczhAQAAYExNO+WrpAfFKyOrM4ifVxBFDiGC/EEUOZRXIwtXzC6+8IgihxBB/iCKHMqLwhVJ0ReEKHIIEeQPosihvBrX4woAAIBmYsQVSe3t5Y4AdUcOIYL8QRQ5lBeFK5K6dy93BKg7cggR5A+iyKG8KFyR1OHDuSNA3ZFDiCB/EEUO5UWPKwAAAGqBEVck1WrljgB1Rw4hgvxBFDmUF4UrktrZyR0B6o4cQgT5gyhyKC9z99wxzDQz+62kX+aOo2GelPRp7iBQa+QQIsgfRJFDk/cH7v6lQQ+icEVyZnbV3Tdyx4H6IocQQf4gihzKh4OzAAAAUAsUrgAAAKgFClfkcD53AKg9cggR5A+iyKFM6HEFAABALTDiCgAAgFqgcAUAAEAtULgCABrFzF7MHQOA6aBwRRJm9rSZvWFmr1Zue8nMHssZF4BG2sodAJrFzF40s5dzxwEKVyRgZl+VdFmSSVpp3+7uVyS9YGZP54kMdcLOD0bwvJn9lZm9Sn5gQr4laS13EKBwRRon3f0r7v4dSR9V7yiL1/U8YaEu2PnBiE67+7+TdEHSK2b2bdoHEHTJ3f+y152MxqazlDsAzIWrlf93m39tNVUgqK2T7v4VSTKzP6ne4e5Xyo3GxzkCw+xx97fLfz+X9LYkmdkzZvZnKtZBF93943wRoobeKdcz2+7+913uf0XSjxLHNJcoXJFCtVi1Lvd/JVUgqC12fhDi7h9J+r70oMXkhKSbkt519y+yBoc6+EjlLz5m1rkOMnVfL2EKaBVAClbpS/TKjc+Z2Y8l/SRPWKgRdn4wMe5+xd2/r6KV4JSZvWNmz+WOCzPtI0nPu/uCuy92XBYkvZc7wHlB4Yqpc/f3JD1hZjckvW1m/8XMPpN0RdIFd/9p3ghRA+z8YKLKntfzkt6SdEzS0bwRYca9Vo7aP6Ry8N8bieOZW5zyFcmY2eOSNlQcmbkt6WrZgwYMVPYnvq6icL2h/faAs+7+w2yBoTbKg/hOSzql4iC/9ySdKw/yA0ZS2aatSHJ3p8c1AQpXTF05srHClxpR7PxgGGb2dPvgq3JE7KSKgnVdxU++5ySdJ3cwqjKfOnvqn5D0HXd/JUNIc4eDs5DCtyT959xBoL46dn6ulBegly0zO6eiWD0u6XNJ70o65e4/zxoZaqncab6goqXEVeSUVIy2XpN0NlNoc4ceV6TA/HeIYvJvjOKEpEsqRsJOuvuqu3+LohUB31HRlrSg/ZxaLa9/R0X7EhKgcEUK75jZy32O2uXnFQzCzg9GsS1p1d2/UR4cCkRdrez4PFG9o+yRZkq+RGgVQArMf4coJv/GKLboX8WEVbdT18zs5Y7jNlY6/wDTQeGKFD6SdKLbVCKSZGbvJo4H9cPOD4bWPnMWMEFmZs9IelNFa8B3zewJFX2vq2LnORkKV6TQdf67Cua/wyDs/GBk5fRX7flZOUMWxubu75Wnm74p6TMVM1X8RMUphV3FXMBIgOmwkEw5jchRSS9I+lBsSDAkM/tqvwNrBt2P+VPO+7tVucklHXX3/5ApJDSQmT1OW0paHJyFJMzsNUkfS/qupOdVHCV+08z+fc64UA/totTMHisP9HvDzF5tn7WGohVVZvaSip9uny+P+n5C0v8k6a3KmY6AkZjZ0+11T+Xm58mptChcMXXlzysr5dQhG+WRvhvuvijpSxwRjmGw84MRnJL0UnuHxt0/d/fLKn7ePZU1MtSSmX1V0mWVvfbt28tTlr9QtqUgAQpXpLDq7t/vdoe7f0fSs4njQc2w84MR3ez2823ZI20Z4kH9nXT3r5TbrId67cvpsNbzhDV/KFyRwmcD7r+ZJArUGTs/GMWtPvdxYAfGcbXy/245xDyuiVC4IoVBX+gnBtwPsPODUfQrTruOuJanFQZ6qeZUtxz6SqpA5h2FK1L4qGxo/+fVG8sDbf5KxXmegX7Y+cEo+k0G36uoPT2NQNAYVjkoyys3PmdmP1YxNRYSYDosJGFmxyWd18MjZ2uSTrv7D/NEhboojxI/Kul77v6PldsfUzHl0YXyIAlAZtZS71H4FT3aSrAiSWXPNNBVOcXa6yoK1xva36E+y3YsHQpXJFUWIGsqziV+lfnvMCx2fjAsM/uFHp7DdeCfSPozd//DKYWEhjCzxyVtiO1YNhSuyM7MXmS0DMNi5weDmNmb5UF7U/0boM3MnnP3v88dxzygcEUyZvZcl5tXJW25+wup40FzsPMDICcze8fdX8kdxzxYyh0Amq+cg/OCitO8djsa85m0EaGu+u38qDiVMACMrTzRwNWBD+z4MzHNWjIUrkjhhfK0i12Z2Q9SBoP6YecHQCLbkq64+zdG+SMze3dK8aADhStS+GDA/WeTRIE6Y+cHwNS5++dmNs7UaGzHEmEeV8wCRsswCDs/AJIoTw38CDN7pvP00uVtT/f6G0wehStSuGRmL5cTNT9WvaO8/nqmuNAc7PwAmJqyv35d0g+rvfZlwfpEj/57TAGzCmBiBjS1V/sSO0+d50z8jX7KHZyjKvrPtt39i4773uaIXgDTYmav9psv2sxedvcfpYxpXtHjikmiqR0hw+78mNkjOz/TjAsABhh0WmpMCK0CmJhyInia2hHR3vlZ7HJZqFweul3Se7kDB9BoXwnejwmhcMVEdWtQN7PHzOzpan+rmb1qZm+UP6/Q1A5J7PwAmFnvmNmPzezfVG80sxfN7ANJP8kU19yhxxVTV05V5JIuufuPzOwdSSuSvqPi55XH6Q1CP+VOz6qkG+3+VjN7VdKzkj4gfwBMm5kdlfQDPXww6C1Jp9ydX30SoXDF1JnZn7S/1Gb2jKRfSHqiUoD8CV969MPOD4BZYWZrKorXbX4xTI+Ds5DCzcr/j0r6efWocHFgDQa71LHzc1wdOz85gwMwP9x9W0U//gODZh3A5FC4IrXjkv7vjtu6ncITqGLnB0AWZavSWp+HrKros6dwTYDCFSk8YWYvSnpe0guSTkgPRs7OSDqXMTbUDzs/AFJ6VtI1FTvQNzvuW5P0oYpeVyRA4Yqpc/f3zOwlFV/sZ9z9i3K+zlckfS5pQ9Lf54wRM4+dHwC5bEs67+7f6nZnuX27kTak+cXBWcjOzF5095/mjgOzwcx+LOlEx9mxHlexg7Mm6V13/7yy8yNJv6C/DMC0mNnj5XR9ve7nzFmJMOKKZHqcy3lV0paKUTRAki539K9K0nfc/XVJV9o3uPvPJf1cKnZ+EsYHYM70K1qRFoUrpq484vuCij6gbr2Iz3S5DfPrlJm96+6/HOFvTkhi1B5AUpUDt16QxIhrAhSuSOGF8rScXZVzdAJtz0raNrPqwQ4rZnaqx+NN0uOS/t3UIwMwd8q2pKt9HnJd0muJwpl7FK5I4YMB93O6TlSdV9E+0j7YwSS9qd55YpLeTRAXgPm0Lek9dz+ZOxBQuGI2PCNmFcC+S51nozGzmwMOjGDnB8BUlAeDso6ZET1/vgUm6JKZvWhmz5X9QA+U11/PFBdm0xNdbhs0T2vn3IoAMDGc2nV2ULgihVuSLqvoA7plZnvtS3nf8azRYdaYmb3acdugefu2phUMgPnSZf2DGcI8rpg6M7sq6aVeP/WWR5DTO4QHzOxNSadUHHQ18OGS3N0XpxsVgHlgZv9FxUwlo5wN60aXafwwBRSumDoz+2o552av+5/hZxj0Y2Zvuvt3+tzPzg+AiTCzGyrOyNdvu+QqpsHakrQi6a1yrmlMGQdnYeraRWvZz3pUxXx3H6o4A9IXFK0YwqCZKd5IEgWAeXB+0Jn4yl+FzqhogzvNdiwdRlyRhJm9pmLPdFvFNEerkr4q6Yy7/x85Y0N99Nr5yRsVgHlhZi9LelvFduxb7n5lwJ9gwjg4C1NXnjlrxd1X3X3D3b9R/rso6UvligDoq9z5+VjSdyU9L+lbkm6a2b/PGReA5jOzp8vjNS5IetPd/5CiNQ8KV6Sw6u7f73ZH2bf4bOJ4UDPs/ADIwcweM7O/UvELz7b6bM+QBoUrUvhswP3MwYlB2PkBkFQ5LdbHko5J+oa7n+x3IhSkQeGKFFYH3N9twnmgip0fAEmUJ8u5quL002fd/SuD2gLM7MU00YHCFSl8ZGZvmNk/r95Y+QnmWqa4UB/s/ABI5bqKmUyecPe3Bz3YzB4XJ0FJhumwMHXufsXMnpD0SzOrjpytqZhG5KeZQkN9fGRmb0j6nrv/Y/vGcpaBLRUHTADAJFxXMaBywsyk8iQnfR7/FUnrCeKCKFyRiLtflHTRzF5SUbBuS7pKvxCGwc4PgIQuD5rHtZOZrUwrGDyMeVwB1GMxif8AAAU7SURBVAo7PwAwvyhcAQAAUAscnAUAAIBaoHAFAABALVC4AgAAoBYoXAEAAFALFK7IjvPMAwCAYTCrACbKzJ4e8U9WJF1w9z+cfDSYF2b2srv/KHccAIDponDFxJjZV1WcbeSmHj13/DOSOufbbE/YfNPdf3fK4aEm2PkBAPTCmbMwSduSLrr7yeqNZUG76u5XOv+gnEz+RqL4MOMiOz9TDg0AMAMYccVEmdnjnWcyGvQzLj/zos3MHpf09jg7P+7+80RhAgAy4eAsTNSYp9+8NfFAUEtl/rzW5a5nuhWt5d9cUTEaCwBoOApXpPDsgPvXk0SBWmDnBwDQC4UrUrhsZj82s//RzB6TJDN7zMyeM7N3JF3PHB9mHzs/AAAKV0xf2Xv4fUlvS7ppZnsqDqa5Iukdd/9pzvhQC+z8AAA4OAtpmdmain7EbXf/KHc8qA8zOyrpB3q4n/WWpNc4uA8A5gOFK7IzsxcZdcWw2PkBgPlF4YpkzOy5LjevStpy9xdSx4PmYOcHAOYDJyDA1JnZn0i6IOlDSdblIUxlhKH02/mRxM4PADQchStSeMHdex4IaGY/SBkM6oedHwCAROGKND4YcP/ZJFGgztj5AQAwHRZmAqNlGISdHwAAhSuSuGRmL5Zzbj5WvaO8/nqmuNAc7PwAwBxgVgFMnZm1Om6qJp1JcndfTBgSaqbcwdmQdEPFNFhfdNz3tru/kis+AEAa9LgiheuSXup1DnozezdxPKifW9UrZvbIzk/acAAAOdAqgBRe61W0luhPxCDXJT3h7gvlZbFyWZD0Xu4AAQDTR6sAsjOzp93949xxYHaZ2Vfd/ed97n+Gs2gBQPMx4opZsJU7AMy2fkVr+yFJAgEAZEXhiokys1+Y2RuV6y+Z2V6fS0vS8YwhoxnY+QGAOUDhikk7K6l6sNUNSe919CTSn4ie2PkBAPRCjyumzswe73dwFv2JqCpP77rdbg8ws69Ket3dT/b5m3f73Q8AaAYKV0yUmX3b3f8ydxxoFnZ+AAASrQKYvNfN7MXcQaC+zOzbnbcNmE5NFK0AMB8YccVEmdkNFf2Gz0r6TNItd/9p3qhQJ2b2maQT5A0AoBOFKybKzF5y9yuV649LOqpiuiKKWAzEzg8AoBcKVyRTKWKlopC9XD3nPCCx8wMA6I3CFVmUR4qfL6+ec/cf5owH9cDODwDMNw7OQjJm9qKZ/VXZw3hV0hOSrki6ljcy1IW7f+7u77n7e5I+knTFzD4ws1dzxwYAmL6l3AGgWczsxepPuWb2sqRXVIySPSHpuqQ3JV3kSHCMqpyx4oSkk5JWVBSvF8XODwDMBVoFMFFm9oGkcyqKi6OSTNJlSRckvTtoWiNgyJ2fd8TODwDMHQpXTFR5+k1J2lZRsJ6lWMUo2PkBAPRC4YqJMrOfuPs3yv9zNDhGxs4PAKAXCldMVOdURpXbORocQ2HnBwDQC4UrsigPsjmmYoL5i+7+cd6IMCvY+QEA9ELhiqTM7DkVB9qckLSm4ufgH7j7X2YNDLXDzg8AzB+mw8JEmdljnaNgHVMYtY8KPyeOCscYeuz8SBI7PwDQcIy4YqLM7B1Jr6oYCXtFxTnnpeJEAxwVjoFG2PlhSiwAmDMUrpio8ohwVzGF0UUVxcVlilUMi50fAEAvFK6YKDP7haTT3Q6uAYbBzg8AoBd6XDFp5yhaEbQtdn4AAF0w4gpgppjZn7n793PHAQCYPRSuAAAAqIWF3AEAAAAAw6BwBQAAQC1QuAIAAKAWKFwBAABQCxSuAAAAqIX/H3W9ZdZqHsghAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "exclude=5   #remove rooftop and fossil fuels\n",
    "exclude=5   #remove rooftop, coal extend and OCGT\n",
    "x2 = np.arange(ntech-exclude)\n",
    "bardata=np.zeros(ntech-exclude)\n",
    "errordata=np.zeros(ntech-exclude)\n",
    "keynames2=[]\n",
    "pos=0\n",
    "for j in range(ntech-4):\n",
    "    #if (keynames[j+2]!=\"PV rooftop\" and keynames[j+2]!=\"Coal extend\" and keynames[j+2]!=\"Natural gas OCGT\" and keynames[j+2]!=\"Natural gas CCGT\" and keynames[j+2]!=\"Coal\"):        \n",
    "    if (keynames[j+2]!=\"Natural gas CCGT\" and keynames[j+2]!=\"Coal\" and keynames[j+2]!=\"PV rooftop\" and keynames[j+2]!=\"Coal extend\" and keynames[j+2]!=\"Natural gas OCGT\"  and keynames[j+2]!=\"Coal existing\"):\n",
    "    #if (keynames[j+2]!=\"PV rooftop\" and keynames[j+2]!=\"Coal extend\" and keynames[j+2]!=\"Natural gas OCGT\"  and keynames[j+2]!=\"Coal existing\"):\n",
    "        print(ntech,keynames[j+2],meanIRR[j]*100,stdIRR[j]*100)        \n",
    "        bardata[pos]=meanIRR[j]*100\n",
    "        errordata[pos]=stdIRR[j]*100\n",
    "        #keynames2[pos]=keynames[j+2]\n",
    "        keynames2.append(keynames[j+2])\n",
    "        pos=pos+1\n",
    "\n",
    "print(bardata)\n",
    "print(errordata)\n",
    "x = np.arange(ntech)\n",
    "fig = plt.figure(figsize=(10,8))\n",
    "#fig, ax = plt.subplots()\n",
    "plt.rc('text', usetex=True)\n",
    "plt.rc('font', family='serif')\n",
    "plt.rc('ytick',labelsize=28)\n",
    "plt.rc('xtick',labelsize=28)\n",
    "#ax.yaxis.set_major_formatter(formatter)\n",
    "#plt.bar(x, meanIRR*100)\n",
    "plt.bar(x2, bardata,yerr=errordata,align='center',capsize=10)\n",
    "#plt.xticks(x, keynames[2:], rotation='vertical', fontsize=20)\n",
    "plt.xticks(x2, keynames2, rotation='vertical', fontsize=20)\n",
    "plt.title(\"Sisäinen korkokanta (LUT/Suomi, 30\\% tuulivoiman osuus)\", fontsize=20)\n",
    "#plt.title(\"Sisäinen korkokanta (ATB/USA)\", fontsize=20)\n",
    "plt.ylabel(\"\\%\", fontsize=20)\n",
    "plt.grid(color='b', linestyle='--', linewidth=0.25)\n",
    "plt.tight_layout()\n",
    "filenamepng= \"./IRR_LUT_Suomi_30percent.png\"\n",
    "#filenamepng= \"./IRR_ATB_USA.png\"\n",
    "#filenamepdf= \"./sample\" + str(i+1)+ \".pdf\"    \n",
    "plt.savefig(filenamepng,dpi=300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [],
   "source": [
    "bardata.shape\n",
    "ntech=8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wind onshore\n",
      "Wind offshore\n",
      "PV\n",
      "Nuclear\n",
      "Natural gas CCGT\n",
      "Coal\n",
      "Wind onshore\n",
      "Wind offshore\n",
      "PV\n",
      "Nuclear\n",
      "Natural gas CCGT\n",
      "Coal\n",
      "[ 3.55718036 -4.12139822  3.01680065  3.60910291 12.89142113  1.13955617]\n",
      "[2.65591687 1.535406   3.12245408 0.89595627 4.37382951 0.90822276]\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"1000\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Just different plotting commands...no real computations here anymore\n",
    "exclude=4   #remove rooftop and fossil fuels\n",
    "exclude=2   #remove rooftop, coal extend and OCGT\n",
    "exclude2=5 \n",
    "exclude2=3 \n",
    "x2 = np.arange(ntech-exclude)\n",
    "bardata=np.zeros(ntech-exclude)\n",
    "errordata=np.zeros(ntech-exclude)\n",
    "bardata2=np.zeros(ntech-exclude)\n",
    "errordata2=np.zeros(ntech-exclude)\n",
    "keynames2=[]\n",
    "pos=0\n",
    "for j in range(ntech):\n",
    "    #if (keynames[j+2]!=\"PV rooftop\" and keynames[j+2]!=\"Coal extend\" and keynames[j+2]!=\"Natural gas OCGT\" and keynames[j+2]!=\"Natural gas CCGT\" and keynames[j+2]!=\"Coal\"):        \n",
    "    if (keynames[j+2]!=\"PV rooftop\" and keynames[j+2]!=\"Coal extend\" and keynames[j+2]!=\"Natural gas OCGT\"):\n",
    "        print(keynames[j+2])\n",
    "        bardata[pos]=meanIRR[j]*100\n",
    "        errordata[pos]=stdIRR[j]*100\n",
    "        #keynames2[pos]=keynames[j+2]\n",
    "        keynames2.append(keynames[j+2])\n",
    "        pos=pos+1\n",
    "\n",
    "keynames3=[]\n",
    "pos=0\n",
    "for j in range(ntech):\n",
    "    #if (keynames[j+2]!=\"PV rooftop\" and keynames[j+2]!=\"Coal extend\" and keynames[j+2]!=\"Natural gas OCGT\" and keynames[j+2]!=\"Natural gas CCGT\" and keynames[j+2]!=\"Coal\"):        \n",
    "    if (keynames[j+2]!=\"PV rooftop\" and keynames[j+2]!=\"Coal extend\" and keynames[j+2]!=\"Natural gas OCGT\"):\n",
    "        print(keynames[j+2])\n",
    "        bardata2[pos]=meanIRR_LUT[j]*100\n",
    "        errordata2[pos]=stdIRR_LUT[j]*100\n",
    "        #keynames2[pos]=keynames[j+2]\n",
    "        keynames3.append(keynames[j+2])\n",
    "        pos=pos+1\n",
    "print(bardata)\n",
    "print(errordata)\n",
    "x = np.arange(ntech)\n",
    "width = 0.27 \n",
    "\n",
    "fig = plt.figure(figsize=(10,8))\n",
    "plt.rc('text', usetex=True)\n",
    "plt.rc('font', family='serif')\n",
    "plt.rc('ytick',labelsize=28)\n",
    "plt.rc('xtick',labelsize=28)\n",
    "bar1=plt.bar(x2, bardata,width,yerr=errordata,align='center',capsize=10,color='green',label='USA')\n",
    "plt.xticks(x2, keynames2, rotation='vertical', fontsize=20)\n",
    "colorv=['cornflowerblue','royalblue','darkorange','orange','green','chocolate','saddlebrown','darkgray','dimgray']\n",
    "bar2 = plt.bar(x2+width, bardata2, width,yerr=errordata2,align='center',capsize=10,color='cornflowerblue',label='Suomi')\n",
    "#plt.title(\"Cost reduction when discounting with 10\\% removed\", fontsize=16)\n",
    "plt.title(\"Sisäinen korkokanta (ATB/USA \\& LUT/Suomi)\", fontsize=20)\n",
    "plt.ylabel(\"\\%\", fontsize=20)\n",
    "plt.grid(color='b', linestyle='--', linewidth=0.25)\n",
    "plt.legend(loc='upper right', prop={'size': 20})\n",
    "plt.tight_layout()\n",
    "#filenamepng= \"./IRR_ATB_LUT_only_Low_C.png\"\n",
    "filenamepng= \"./IRR_ATB_LUT.png\"\n",
    "#filenamepdf= \"./sample\" + str(i+1)+ \".pdf\"    \n",
    "plt.savefig(filenamepng,dpi=300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['Roughly LUT parameters', 'Units', 'Wind onshore', 'Wind offshore',\n",
      "       'PV', 'PV rooftop', 'Nuclear', 'Natural gas CCGT', 'Natural gas OCGT',\n",
      "       'Coal', 'Coal extend'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "print(keynames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#bar plot of the difference betweeb 0% and 10% discount: (1-cost0/cost10)*100 cost reduction in % from 10%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[74.15484629 78.82301702 73.91639775 77.04171237 82.33269991 24.0850179\n",
      " 13.30023845 35.91740563  6.80445287  2.14435334]\n"
     ]
    }
   ],
   "source": [
    "change_in_cost=np.zeros(ntech)\n",
    "for i in range(ntech):\n",
    "    change_in_cost[i]=100*(1-meanLCOE[0,i]/meanLCOE[loopsamples-1,i])    \n",
    "print(change_in_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.arange(ntech)\n",
    "fig = plt.figure(figsize=(10,8))\n",
    "#fig, ax = plt.subplots()\n",
    "plt.rc('text', usetex=True)\n",
    "plt.rc('font', family='serif')\n",
    "plt.rc('ytick',labelsize=28)\n",
    "plt.rc('xtick',labelsize=28)\n",
    "#ax.yaxis.set_major_formatter(formatter)\n",
    "plt.bar(x, change_in_cost)\n",
    "plt.xticks(x, keynames[2:], rotation='vertical', fontsize=20)\n",
    "#plt.title(\"Cost reduction when discounting with 10\\% removed\", fontsize=16)\n",
    "plt.title(\"Hinnanalennus, kun 10\\% korko poistetaan (LUT/Suomi)\", fontsize=20)\n",
    "plt.grid(color='b', linestyle='--', linewidth=0.25)\n",
    "plt.tight_layout()\n",
    "filenamepng= \"./costreduction_no_discount_Suomi.png\"\n",
    "#filenamepdf= \"./sample\" + str(i+1)+ \".pdf\"    \n",
    "plt.savefig(filenamepng,dpi=300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.animation as mplanimation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "    \n",
    "#Function that generates the plots comparing two different technologies for net present value\n",
    "def animate_NPV_compare_two(i):\n",
    "    ti1=0\n",
    "    ti2=4\n",
    "    ti=ti1\n",
    "    plt.clf()\n",
    "    mpl.rcParams.update({'font.size': 22})\n",
    "    fig = plt.figure(figsize=(10,6))\n",
    "    minval1=NPV_techv[:,i,ti].min()\n",
    "    maxval1=NPV_techv[:,i,ti].max()\n",
    "    minval2=NPV_techv[:,i,ti2].min()\n",
    "    maxval2=NPV_techv[:,i,ti2].max()\n",
    "    minval=min(minval1,minval2)\n",
    "    maxval=max(maxval1,maxval2)\n",
    "    bins_fixed = np.linspace(minval,maxval, 250)\n",
    "    colorv=['cornflowerblue','royalblue','darkorange','orange','green','chocolate','saddlebrown','dimgray']\n",
    "    plt.rc('text', usetex=True)\n",
    "    plt.rc('font', family='serif')\n",
    "    CO2taxv=np.zeros(1)\n",
    "    colorh=colorv[ti]\n",
    "    colorh2=colorv[ti2]\n",
    "    yn, xp, _ =plt.hist(NPV_techv[:,i,ti], bins_fixed,alpha=0.5,density=True,label=keynames[ti+2],color=colorh)\n",
    "    yn2, xp, _ =plt.hist(NPV_techv[:,i,ti2], bins_fixed,alpha=0.4,density=True,label=keynames[ti2+2],color=colorh2)\n",
    "    ymax1=yn.max()\n",
    "    ymax2=yn2.max()\n",
    "    ymax=max(ymax1,ymax2)\n",
    "    xmin1=np.min(NPV_techv[:,:,ti1])\n",
    "    xmin2=np.min(NPV_techv[:,:,ti2])\n",
    "    xmax1=np.max(NPV_techv[:,:,ti1])\n",
    "    xmax2=np.max(NPV_techv[:,:,ti2])\n",
    "    xmin=min(xmin1,xmin2)\n",
    "    xmax=max(xmax1,xmax2)\n",
    "    xv=np.ones(2)*np.mean(NPV_techv[:,i,ti])\n",
    "    yv=np.zeros(2)\n",
    "    yv[1]=ymax*1.1\n",
    "    plt.plot(xv,yv,color=colorh, linewidth=4)\n",
    "    xv2=np.ones(2)*np.mean(NPV_techv[:,i,ti2])\n",
    "    plt.plot(xv2,yv,color=colorh2, linewidth=4)\n",
    "    plt.legend(loc='upper right', prop={'size': 20})\n",
    "    CO2taxv=np.zeros(loopsamples)\n",
    "    plt.title(\"NPV: discount rate=\"+str(round(rminv[i]*100,2))+\" $\\%$\",fontsize=32)\n",
    "    #plt.title(\"LCOE: CO$_{2}$=\"+str(round(CO2taxv[i],1))+\" €/MWh\")\n",
    "    plt.xlabel(\"NPV/Investment\")\n",
    "    plt.xlim(xmin,xmax)\n",
    "    plt.ylim((0,yv[1]))\n",
    "    plt.yticks([])\n",
    "    plt.grid(color='b', linestyle='--', linewidth=0.25)\n",
    "    plt.tight_layout()\n",
    "    filenamepng= \"./compare_NPV\"+str(ti)+\"_\"+str(ti2)+\"_\" + str(i+1)+ \".png\"\n",
    "    #filenamepdf= \"./sample\" + str(i+1)+ \".pdf\"    \n",
    "    plt.savefig(filenamepng,dpi=300)\n",
    "    #plt.savefig(filenamepdf)\n",
    "    im=plt.show()\n",
    "    return(plt)\n",
    "    #ims.append([im])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Function that generates the plots comparing two different technologies for LCOE\n",
    "def animate_IRR_compare_two(i):\n",
    "    ti1=0\n",
    "    ti2=0\n",
    "    ti=ti1\n",
    "    plt.clf()\n",
    "    mpl.rcParams.update({'font.size': 22})\n",
    "    fig = plt.figure(figsize=(10,6))\n",
    "    minval1=100*internal_rate_techv[:,ti].min()-0.0\n",
    "    maxval1=100*internal_rate_techv[:,ti].max()+2\n",
    "    minval2=100*internal_rate_techv_LUT[:,ti2].min()-0.0\n",
    "    maxval2=100*internal_rate_techv_LUT[:,ti2].max()+2\n",
    "    minval=min(minval1,minval2)\n",
    "    maxval=max(maxval1,maxval2)\n",
    "    minval=-10\n",
    "    maxval=20\n",
    "    bins_fixed = np.linspace(minval,maxval, 250)\n",
    "    colorv=['cornflowerblue','green','chocolate','saddlebrown','dimgray']\n",
    "    plt.rc('text', usetex=True)\n",
    "    plt.rc('font', family='serif')\n",
    "    colorh=colorv[0]\n",
    "    colorh2=colorv[1]\n",
    "    yn, xp, _ =plt.hist(100*internal_rate_techv[:,ti], bins_fixed,alpha=0.7,density=True,label='USA',color=colorh)\n",
    "    yn2, xp, _ =plt.hist(100*internal_rate_techv_LUT[:,ti2], bins_fixed,alpha=0.6,density=True,label='Suomi',color=colorh2)\n",
    "    plt.legend(loc='upper right', prop={'size': 20})\n",
    "    plt.title(\"Sisäinen korkokanta: tuulivoima USA vs. Suomi\",fontsize=32)\n",
    "    #plt.title(\"LCOE: CO$_{2}$=\"+str(round(CO2taxv[i],1))+\" €/MWh\")\n",
    "    plt.xlabel(\"IRR [\\%]\")\n",
    "    xmin=-5\n",
    "    xmax=15\n",
    "    plt.xlim(xmin,xmax)\n",
    "    plt.ylim((0,0.25))\n",
    "    plt.yticks([])\n",
    "    plt.grid(color='b', linestyle='--', linewidth=0.25)\n",
    "    plt.tight_layout()\n",
    "    filenamepng= \"./IRR_compare_distributions_wind.png\"\n",
    "    #filenamepdf= \"./sample\" + str(i+1)+ \".pdf\"    \n",
    "    plt.savefig(filenamepng,dpi=300)\n",
    "    #plt.savefig(filenamepdf)\n",
    "    im=plt.show()\n",
    "    return(plt)\n",
    "    #ims.append([im])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Function that generates the plots comparing two different technologies for LCOE\n",
    "def animate_IRR_compare_two_techs(i):\n",
    "    ti1=0\n",
    "    ti2=4\n",
    "    #ti1=4\n",
    "    #ti2=5\n",
    "    ti=ti1\n",
    "    plt.clf()\n",
    "    mpl.rcParams.update({'font.size': 22})\n",
    "    fig = plt.figure(figsize=(10,6))\n",
    "    minval1=100*internal_rate_techv_LUT[:,ti].min()-0.0\n",
    "    maxval1=100*internal_rate_techv_LUT[:,ti].max()+2\n",
    "    minval2=100*internal_rate_techv_LUT[:,ti2].min()-0.0\n",
    "    maxval2=100*internal_rate_techv_LUT[:,ti2].max()+2\n",
    "    minval=min(minval1,minval2)\n",
    "    maxval=max(maxval1,maxval2)\n",
    "    minval=0\n",
    "    maxval=11\n",
    "    #maxval=25    \n",
    "    bins_fixed = np.linspace(minval,maxval, 250)\n",
    "    colorv=['cornflowerblue','green','chocolate','saddlebrown','dimgray']\n",
    "    plt.rc('text', usetex=True)\n",
    "    plt.rc('font', family='serif')\n",
    "    colorh=colorv[0]\n",
    "    colorh2=colorv[1]\n",
    "    yn, xp, _ =plt.hist(100*internal_rate_techv_LUT[:,ti], bins_fixed,alpha=0.7,density=True,label='Wind (low penetration)',color=colorh)\n",
    "    yn2, xp, _ =plt.hist(100*internal_rate_techv_LUT[:,ti2], bins_fixed,alpha=0.6,density=True,label='Nuclear',color=colorh2)\n",
    "    plt.legend(loc='upper right', prop={'size': 20})\n",
    "    plt.title(\"Sisäinen korkokanta: tuulivoima \\& ydinvoima (Suomi)\",fontsize=24)\n",
    "    #yn, xp, _ =plt.hist(100*internal_rate_techv_LUT[:,ti], bins_fixed,alpha=0.7,density=True,label='Nuclear',color=colorh)\n",
    "    #yn2, xp, _ =plt.hist(100*internal_rate_techv_LUT[:,ti2], bins_fixed,alpha=0.6,density=True,label='Natural gas CCGT',color=colorh2)\n",
    "    #plt.legend(loc='upper right', prop={'size': 20})\n",
    "    #plt.title(\"Sisäinen korkokanta: ydinvoima \\& maakaasu (Suomi, 80€/MWh sähkö, 20€/tCO2)\",fontsize=16)\n",
    "    #plt.title(\"LCOE: CO$_{2}$=\"+str(round(CO2taxv[i],1))+\" €/MWh\")\n",
    "    plt.xlabel(\"IRR [\\%]\")\n",
    "    xmin=0\n",
    "    xmax=10\n",
    "    #xmax=24\n",
    "    plt.xlim(xmin,xmax)\n",
    "    plt.ylim((0,0.70))\n",
    "    plt.yticks([])\n",
    "    plt.grid(color='b', linestyle='--', linewidth=0.25)\n",
    "    plt.tight_layout()\n",
    "    filenamepng= \"./IRR_distributions.png\"\n",
    "    #filenamepdf= \"./sample\" + str(i+1)+ \".pdf\"    \n",
    "    plt.savefig(filenamepng,dpi=300)\n",
    "    #plt.savefig(filenamepdf)\n",
    "    im=plt.show()\n",
    "    return(plt)\n",
    "    #ims.append([im])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<module 'matplotlib.pyplot' from '/u/33/martikj2/unix/.local/lib/python3.7/site-packages/matplotlib/pyplot.py'>"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "animate_IRR_compare_two_techs(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}