Assets.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.stats\n",
    "import numpy as np\n",
    "import scipy.stats as ss\n",
    "from matplotlib import pyplot as plt\n",
    "import math \n",
    "import plotly.graph_objects as go\n",
    "import pandas as pd "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Petroleum_asset(object):\n",
    "    def __init__(self, location, hc_type, phase, res_est, well_max_rate, well_cap_pot, n, init_year, period):\n",
    "        \n",
    "        self.location = location            #asset location (onshore or offshore)\n",
    "        self.hc_type = hc_type              #asset hydrocarbon type (oil or gas)\n",
    "        self.phase = phase                  #asset life cycle phase (exploration or development)\n",
    "        self.res_est = res_est              #asset estimated recoverable reserves (mode value)\n",
    "        self.well_max_rate = well_max_rate  #asset average maximum well rate (mode value)\n",
    "        self.well_cap_pot = well_cap_pot    #asset well capacity potential \n",
    "        self.n = n                          #number of iterations\n",
    "        self.init_year = init_year          #asset initial year to start the project \n",
    "        self.period = period                #project period (years)\n",
    "        \n",
    "        oil_price, gas_price = og_price(self.period, self.n)\n",
    "        if self.hc_type == 'oil':\n",
    "            self.price = oil_price\n",
    "        else:\n",
    "            self.price = gas_price\n",
    "        \n",
    "    def asset_evaluation(self):\n",
    "        \n",
    "        def pert(self, n, min, max, mode):\n",
    "\n",
    "            # Calculating Beta-distribution parameters, based on the PERT parameters\n",
    "            alpha = 2 * (max + 4 * mode - 5 * min) / (3 * (max - min)) * \\\n",
    "            (1 + 4 * (mode - min) * (max - mode) / (max - min)**2)\n",
    "\n",
    "            beta = 2 * (5 * max - 4 * mode - min) / (3 * (max - min)) * \\\n",
    "            (1 + 4 * (mode - min) * (max - mode) / (max - min)**2)\n",
    "\n",
    "            # Generating Beta-distribution (scipy.stats package)\n",
    "            my_beta_distr = scipy.stats.beta.rvs(a = alpha, b = beta, size=n)\n",
    "\n",
    "            # Converting Beta into PERT (scaling)\n",
    "            pert = my_beta_distr * (max - min) + min\n",
    "\n",
    "            return(pert)\n",
    "        \n",
    " \n",
    "        ##Function that estimates the reserves and total project capacity for each O&G asset \n",
    "        def fac_model (self):\n",
    "\n",
    "            ###Reserves Estimates \n",
    "            res_m_on, res_m_off = 1.0, 2.0 #Mstb \n",
    "            res_min_fac_dev, res_max_fac_dev = 0.85, 1.5 #Mstb\n",
    "            res_min_fac_exp, res_max_fac_exp = 0.2, 2 #Mstb\n",
    "             \n",
    "\n",
    "            #reserves in MM Boe\n",
    "            if self.phase == 'exploration':\n",
    "                if self.hc_type == 'oil':\n",
    "                    if self.location == 'onshore':\n",
    "                        res_mode = res_m_on*self.res_est\n",
    "                    elif self.location == 'offshore':\n",
    "                        res_mode = res_m_off*self.res_est\n",
    "\n",
    "                if self.hc_type == 'gas':\n",
    "                    if self.location == 'onshore':\n",
    "                        res_mode = (res_m_on*self.res_est)\n",
    "                    elif self.location == 'offshore':\n",
    "                        res_mode = (res_m_off*self.res_est)\n",
    "\n",
    "                res_min = res_min_fac_exp*res_mode\n",
    "                res_max = res_max_fac_exp*res_mode\n",
    "                reserves=pert(self, n=self.n, min=res_min, max=res_max, mode=res_mode)\n",
    "\n",
    "            elif self.phase =='development':\n",
    "                if self.hc_type == 'oil':\n",
    "                    if self.location == 'onshore':\n",
    "                        res_mode = res_m_on*self.res_est\n",
    "                    elif self.location == 'offshore':\n",
    "                        res_mode = res_m_off*self.res_est\n",
    "\n",
    "                if self.hc_type == 'gas':\n",
    "                    if self.location == 'onshore':\n",
    "                        res_mode = (res_m_on*self.res_est)\n",
    "                    elif self.location == 'offshore':\n",
    "                        res_mode = (res_m_off*self.res_est)\n",
    "\n",
    "                res_min = res_min_fac_dev*res_mode\n",
    "                res_max = res_max_fac_dev*res_mode\n",
    "                reserves=pert(self, n=self.n, min=res_min, max=res_max, mode=res_mode)\n",
    "\n",
    "            ###Maximum capacity of the facility of the field \n",
    "            w_max_prod = (365/1000)* self.well_max_rate #well maximum production in Mb/y\n",
    "            total_max_cap = w_max_prod * self.well_cap_pot / 2  #total asset maximum processing capacity in Mb/y, BSCF/y\n",
    "\n",
    "            return (reserves, total_max_cap)\n",
    "        \n",
    "        #locd,bbd = fac_model (self)\n",
    "        #print(locd)\n",
    "        \n",
    "        ##Function that estimates the years to start exploration - development - production\n",
    "        def years_phase (self):\n",
    "            if self.phase == 'exploration':\n",
    "                expl_fac = np.array([1 for i in range(0, self.n)])  #if project is in exploration phase\n",
    "                dev_fac = np.array([0 for i in range(0, self.n)])  #if project is in exploration phase\n",
    "            elif self.phase == 'development':\n",
    "                expl_fac = np.array([0 for i in range(0, self.n)]) #if project is in development phase\n",
    "                dev_fac = np.array([1 for i in range(0, self.n)])  #if project is in development phase\n",
    "\n",
    "            #length of exploration period \n",
    "            year_array = [2,3,4,5] \n",
    "            expl_prob1 = [0.2 for i in range (0,self.n)] \n",
    "            expl_prob2 = [0.2 for i in range (0,self.n)] \n",
    "            expl_prob3 = [0.3 for i in range (0,self.n)]\n",
    "            expl_prob4 = [0.3 for i in range (0,self.n)]\n",
    "            prob_array = [[expl_prob1[:][-1], expl_prob2[:][-1], expl_prob3[:][-1], expl_prob4[:][-1]]\n",
    "                          for i in range(0, self.n)]\n",
    "            expl_len = [int(np.random.choice(size = 1, a = year_array, p = prob_array[i])) \n",
    "                    for i in range(0, self.n)] * expl_fac \n",
    "            #print(expl_len)\n",
    "\n",
    "            y_start_exp = self.init_year*expl_fac\n",
    "\n",
    "            #years to start development \n",
    "            y_start_dev = self.init_year + expl_len \n",
    "            #print (y_start_dev)\n",
    "\n",
    "            #length of development period \n",
    "            year_array1 = [1,2,3]\n",
    "            dev_prob1 = [0.5 for i in range (0,self.n)] \n",
    "            dev_prob2 = [0.3 for i in range (0,self.n)] \n",
    "            dev_prob3 = [0.2 for i in range (0,self.n)] \n",
    "            prob_array1 = [[dev_prob1[:][-1], dev_prob2[:][-1], dev_prob3[:][-1]]for i in range(0, self.n)]\n",
    "            dev_len = [int(np.random.choice(size = 1, a = year_array1, p = prob_array1[i])) \n",
    "                   for i in range(0, self.n)] \n",
    "\n",
    "            #years to start production \n",
    "            y_start_prod = y_start_dev + dev_len\n",
    "            #print(y_start_prod)\n",
    "\n",
    "            return (y_start_prod, y_start_exp, y_start_dev, expl_len)\n",
    "        \n",
    "\n",
    "        ##Production Forecast Model\n",
    "        def production (self, fac_factors=1):\n",
    "            ###Production forecast\n",
    "            #n=10 #iterations\n",
    "            #period = 31 #years \n",
    "            fac_factors = fac_model (self)\n",
    "            #reserves = (2*10**6) * fac_factors[0] #Mstb\n",
    "            #reserves = fac_factors[0] #MBoe\n",
    "            reserves = (5*10**5)*fac_factors[0] #Mstb\n",
    "            #reserves = (1*10**3)*fac_factors[0] #Mstb\n",
    "            #prod_init = np.random.triangular(4.5,5,6,n) #initial production in Mbbls/d \n",
    "            #qi = reserves*(0.02)\n",
    "            qi = reserves*(0.06)\n",
    "            #qi = prod_init * (365/1000) #initial production in Mb/y \n",
    "            #t_to_plateau = np.random.uniform(0,54/12,self.n) #length of delay period, when production rate equals to 0\n",
    "            t_to_plateau = np.random.uniform(24/12,36/12,self.n) \n",
    "            t_plateau = np.random.uniform(84/12,90/12,self.n) #length of development, when production rate rises from 0 to qi\n",
    "            t_delay = np.random.uniform(0,2/12,self.n) #length of production plateau period, when production stays at qi\n",
    "            a_factor = np.random.uniform(0.1,0.2,self.n) \n",
    "            production = np.array([[0 for i in range(0, self.n)] for k in range(0, self.period)])\n",
    "            #diff = np.array([0 for i in range (0,n)])\n",
    "            diff = np.zeros(self.n)\n",
    "            years= years_phase (self)\n",
    "            start_year = years[0]\n",
    "            #N = int(np.mean(start_year))\n",
    "            #production = 0\n",
    "            for i in range (0,self.n):\n",
    "                N=start_year[i]\n",
    "                #j=1\n",
    "                j=N\n",
    "                total_prod = 0\n",
    "                while (j<=t_delay[i]):\n",
    "                    production [j,i] = 0\n",
    "                    total_prod = total_prod + production [j,i] \n",
    "                    j=j+1\n",
    "                while ((j-t_delay[i])<=t_to_plateau[i]):\n",
    "                    rand = 0\n",
    "                    production [j,i] = (qi[i]/t_to_plateau[i])*(j-t_delay[i])+rand \n",
    "                    total_prod = total_prod + production [j,i] \n",
    "                    j=j+1\n",
    "                while ((j-t_delay[i]-t_to_plateau[i])<=t_plateau[i]):\n",
    "                    rand = 0\n",
    "                    production [j,i] = qi[i]+rand \n",
    "                    total_prod = total_prod + production [j,i] \n",
    "                    j=j+1\n",
    "                #diff = reserves[i] - total_prod \n",
    "                diff[i]=reserves[i]-total_prod\n",
    "                #total_max_cap = (fac_factors[1])*(10)\n",
    "                total_max_cap = (fac_factors[1])*10\n",
    "                while (diff[i]>total_max_cap):\n",
    "                    rand = 0\n",
    "                    dt = j-t_delay[i]-t_to_plateau[i]-t_plateau[i]\n",
    "                    production [j,i]=qi[i]*math.exp(-a_factor[i]*dt) + rand \n",
    "                    total_prod = total_prod + production [j,i]\n",
    "                   # diff = reserves[i] - total_prod\n",
    "                    diff[i]=reserves[i]-total_prod\n",
    "\n",
    "                    if j==30:\n",
    "                        percent_prod = 100*total_prod/reserves[i] \n",
    "                        break \n",
    "                    j=j+1\n",
    "                if i==self.n:\n",
    "                    break \n",
    "\n",
    "            #prod_plot=np.transpose(production)\n",
    "            prod_plot=np.transpose(production/(5*10**5))\n",
    "            #years= years_phase (self)\n",
    "            #start_year = years[0]\n",
    "            #N = int(np.mean(start_year))\n",
    "            #shape=np.shape(prod_plot)\n",
    "            #padded_array = np.zeros((self.n,self.period+N))\n",
    "            #padded_array[:shape[0], N:shape[1]+N] = prod_plot\n",
    "            #modified_prod = np.array([padded_array[i][:-N] for i in range (0,self.n)])\n",
    "            \n",
    "            #prod_plot=np.transpose(production)\n",
    "            #start_year= years_phase (self)\n",
    "            #modified_prod = []\n",
    "            #for i in range (0,self.n):\n",
    "            #    N=start_year[i]-1\n",
    "            #    prod_mod1 = np.pad(prod_plot[i], (N,0), 'constant')\n",
    "            #    prod_mod = prod_mod1[:-N]\n",
    "             #   modified_prod.append(prod_mod)\n",
    "            return (prod_plot)\n",
    "        \n",
    "        prod = production(self)\n",
    "        prod_mean = np.array([np.mean(prod.T[i]) \\\n",
    "                     for i in range(len(prod.T))])\n",
    "        total_prod = np.sum(prod_mean)\n",
    "        #print(total_prod)\n",
    "        \n",
    "        ##Reserves in MM Boe and total max capacity in Mb/year or BSCF/year\n",
    "        reserves, capacity = fac_model (self)\n",
    "\n",
    "        ##Number of injection and production wells (as a function of reserves)\n",
    "        wells = np.array([\n",
    "        [3, 5, 10, 15, 20, 25, 25, 40],\n",
    "        [3, 4, 2, 4, 10, 15, 15, 30]\n",
    "        ])\n",
    "        res_vctr = [100, 200, 500, 1000, 2000, 5000, 10000, 20000]  #reserves limits in MM Boe\n",
    "        n_inj_wells = [0 for i in range(0, self.n)]\n",
    "        n_prod_wells = [0 for i in range(0, self.n)]\n",
    "        for i in range (0,self.n):\n",
    "            for k in range (0, 6):\n",
    "                if reserves[i]>=res_vctr[k] and reserves[i]<=res_vctr[k+1]:\n",
    "                    n_inj_wells[i] = wells[1][k]\n",
    "                    n_prod_wells[i] = wells[0][k]\n",
    "\n",
    "        ##Number of exploration and appraisal wells (constant for all projects)\n",
    "        n_exp_wells = [3 for i in range(0, self.n)]\n",
    "        n_app_wells = [2 for i in range(0, self.n)] #appraisal wells only if exploration was successful\n",
    "        \n",
    "        ##Capex Calculation\n",
    "        years = years_phase (self)\n",
    "        y_start_prod = years[0]\n",
    "        y_start_exp = years[1]\n",
    "        y_start_dev = years[2]\n",
    "        expl_len = years [3]\n",
    "        init_year = self.init_year\n",
    "\n",
    "        q1 = np.percentile(reserves,20)\n",
    "        q2 = np.percentile(reserves,50)\n",
    "        \n",
    "\n",
    "        unc_vctr = [0.5, 3]\n",
    "        #fixed opex (onshore) = 0.005 - fixed opex(offshore) = 0.015\n",
    "        #variable opex(onshore) = - variable opex (offshore) = \n",
    "        opex_sc = 6\n",
    "        opex_vctr = pert(self, n=self.n, min=opex_sc*0.7, max=opex_sc*1.6, mode=opex_sc)\n",
    "\n",
    "\n",
    "        ###CO2 Emission Model\n",
    "        modified_prod = production(self)\n",
    "        co2_base = 30 #kgCO2/toe\n",
    "        emission_int = np.array([[0 for i in range(0, self.period)] for k in range(0, 1)])\n",
    "        #emission_int = np.array([[0 for i in range(0, period)]])\n",
    "        for i in range (0,self.n):\n",
    "            peak_prod = max(modified_prod[i])\n",
    "            share_prod = np.array([(modified_prod[i][k]/peak_prod) for k in range (0,self.period)]) \n",
    "            emission_share = np.array([(1.0096*(share_prod[k])**-0.65) for k in range(0,self.period)])\n",
    "            emission_share = np.where(emission_share == float('inf'), 0, emission_share)\n",
    "            emission = np.array([emission_share[k]*co2_base for k in range (0,self.period)])\n",
    "            emission_int = np.append(emission_int,[emission], axis=0)\n",
    "        #print(emission_int)\n",
    "        co2_emission = np.delete(emission_int, 0, 0) #kgCO2/toe\n",
    "\n",
    "        co2 = np.array([[0 for i in range(0, self.n)] for k in range(0, 1)])\n",
    "        for k in range (0,self.period-1):\n",
    "            total = np.array([modified_prod[i][k]*co2_emission[i][k]*136 for i in range (0,self.n)])\n",
    "            co2 = np.append(co2, [total], axis=0) #tCO2 per year\n",
    "        #print(new)\n",
    "        co2_price = 20 #$tC02\n",
    "        co2_tax_mean = np.array([np.mean(co2[i])*co2_price*10**-6 \\\n",
    "                             for i in range(len(co2))])\n",
    "        #print(co2_tax_mean)\n",
    "\n",
    "\n",
    "\n",
    "        if self.phase == 'exploration':\n",
    "            expl_fac = np.array([1 for i in range(0, self.n)]) \n",
    "        else:\n",
    "            expl_fac = np.array([0 for i in range(0, self.n)]) \n",
    "        dev_fac = np.array([1 for i in range(0, self.n)])\n",
    "\n",
    "        \n",
    "        capex_seis = np.random.triangular(8, 10, 15, self.n)\n",
    "        if self.location == 'offshore':\n",
    "            cap_fact = 2\n",
    "        else:\n",
    "            cap_fact = 1\n",
    "        cap1 = np.random.triangular(130, 160, 190, self.n)\n",
    "        cap2 = np.random.triangular(120, 150, 190, self.n)\n",
    "        capex_exp = np.array([cap_fact*cap1[i]*n_exp_wells[i] for i in range (0,self.n)])\n",
    "        capex_inj = np.array([cap1[i]*n_inj_wells[i] for i in range (0,self.n)])\n",
    "        capex_app = np.array([cap2[i]*n_app_wells[i] for i in range (0,self.n)])\n",
    "        capex_prod = np.array([cap_fact*cap2[i]*n_prod_wells[i] for i in range (0,self.n)])\n",
    "        #fixed_opex = np.random.triangular(1.3, 1.5, 1.8, self.n)\n",
    "        #fixed_opex = np.random.triangular(13, 15, 18, self.n)\n",
    "        fix_opex = np.random.triangular(10, 12, 15, self.n)\n",
    "        if self.hc_type == 'gas':\n",
    "            uplift_fac = 1.5\n",
    "            GOR = 9\n",
    "        else:\n",
    "            uplift_fac = 1\n",
    "            GOR = 1\n",
    "        fixed_opex = np.array([uplift_fac*fix_opex[i]*(n_prod_wells[i]+n_app_wells[i]) for i in range (0,self.n)])\n",
    "        var_opex = np.random.triangular(10, 15, 20, self.n)\n",
    "\n",
    "        #import length of exploration phase (expl_len) from years function\n",
    "        capex_sc = 1\n",
    "        capex2_time = np.array([0 for i in range(0, self.n)])\n",
    "        capex2 = np.array([0 for i in range(0, self.n)])\n",
    "        capex3 = np.array([0 for i in range(0, self.n)])\n",
    "        hc_price = np.array([50 for i in range(0, self.period)])\n",
    "\n",
    "        for i in range (0,self.n):\n",
    "            #capex1[i] = capex_seis[i]*expl_fac[i]\n",
    "            capex2_time [i] = self.init_year + (expl_len[i]/2)\n",
    "            if (reserves [i])<q1:\n",
    "                capex2[i] = 0\n",
    "                #seis_succ = 0\n",
    "                #dril_succ = 0\n",
    "            else:\n",
    "                capex2[i] = capex_exp[i]*expl_fac[i]\n",
    "                if (reserves[i])<q2: \n",
    "                    capex3[i] = 0\n",
    "                else:\n",
    "                    capex3[i] = capex_prod[i] + capex_inj[i]+capex_app[i]\n",
    "\n",
    "        time = [0 + i for i in range(0, self.period)]\n",
    "        capex = np.array([[0 for i in range(0, self.n)] for k in range(0, 1)])\n",
    "        btcf = np.array([[0 for i in range(0, self.n)] for k in range(0, 1)])\n",
    "        discount_factors=np.zeros(self.period)\n",
    "        revenues = np.array([[0 for i in range(0, self.n)] for k in range(0, 1)])\n",
    "        opex = np.array([[0 for i in range(0, self.n)] for k in range(0, 1)])\n",
    "        total = np.array([1 / ((1 + 0.45)**(time[i] - 0.5)) for i in range(0, self.period)])\n",
    "        cc1=np.array([[0 for i in range(0, self.n)] for k in range(0, 1)])\n",
    "        for k in range (0, self.period-1): \n",
    "            expl_cap1 = np.array(\n",
    "                [\n",
    "                    0 \n",
    "                    if (time[k] < y_start_exp[i]) or (time[k]>y_start_dev[i])\n",
    "                    else (capex_seis[i])\n",
    "                    for i in range (0,self.n)\n",
    "                    ] * expl_fac\n",
    "                )\n",
    "\n",
    "            expl_cap2 = np.array(\n",
    "                [\n",
    "                    0 \n",
    "                    if (time[k] < y_start_exp[i]) or (time[k]>capex2_time[i])\n",
    "                    else (capex2[i])\n",
    "                    for i in range (0,self.n)\n",
    "                    ] * expl_fac\n",
    "                )\n",
    "\n",
    "\n",
    "            dril_cap = np.array(\n",
    "                [\n",
    "                    0 \n",
    "                    if (time[k] < y_start_dev[i]) or (time[k]>y_start_prod[i])\n",
    "                    else (capex3[i] / (y_start_prod[i] - y_start_dev[i]))\n",
    "                    for i in range (0,self.n)\n",
    "                    ] * dev_fac\n",
    "                )\n",
    "            cc1 = np.append(cc1, [dril_cap], axis=0)\n",
    "\n",
    "            total = expl_cap1 + expl_cap2 + dril_cap\n",
    "            #total=expl_cap1 + expl_cap2 \n",
    "            capex = np.append(capex, [total], axis = 0)\n",
    "\n",
    "\n",
    "            #total2 = np.array([modified_prod[i][k]* (hc_price[k]) for i in range (0,self.n)])\n",
    "            total2 = np.array([GOR*modified_prod[i][k]* (self.price[k][i]) for i in range (0,self.n)])\n",
    "            revenues = np.append(revenues, [total2], axis=0)\n",
    "            #total3 = np.array([modified_prod[i][k]* (var_opex[i]) for i in range (0,self.n)])\n",
    "            total3 = np.array([modified_prod[i][k]* (var_opex[i])+fixed_opex[i] for i in range (0,self.n)])\n",
    "            opex = np.append(opex, [total3], axis=0)\n",
    "\n",
    "            cash_flow = - capex[k+1] + revenues[k+1] - opex[k+1]\n",
    "            btcf = np.append(btcf, [cash_flow], axis=0)\n",
    "\n",
    "        tax_rate = 0.56 \n",
    "        int_rate = 0.08\n",
    "        atcf = btcf*(1-tax_rate)\n",
    "        discount_factors=np.zeros(self.period)\n",
    "        PW = np.array([[0 for i in range(0, self.n)] for k in range(0, 1)])\n",
    "        for k in range (1,self.period):\n",
    "            discount_factors[k]= 1/((1+int_rate)**(k))\n",
    "            total = atcf[k,:]*discount_factors[k] \n",
    "            PW = np.append(PW, [total], axis=0)\n",
    "\n",
    "        npv = np.array([np.sum(PW[:,i]) for i in range (0,self.n)])\n",
    "        npv_mean = np.mean(npv)\n",
    "\n",
    "        #print(npv_mean)\n",
    "    \n",
    "\n",
    "    ###Storing the simulation results \n",
    "        annual_prod = modified_prod.T\n",
    "        trye = co2_emission.T\n",
    "        project_data = [self.hc_type, self.phase, self.location,\n",
    "                        reserves, annual_prod, co2, capex, opex, revenues, PW, npv, btcf]\n",
    "        self.result = project_data \n",
    "        self.reserves = Petroleum_asset.data_tables(self, data_type = project_data, col = 3)\n",
    "        self.annual_prod = Petroleum_asset.data_tables(self, data_type = project_data, col = 4)\n",
    "        self.co2_emission = Petroleum_asset.data_tables(self, data_type = project_data, col = 5)\n",
    "        self.capex = Petroleum_asset.data_tables(self, data_type = project_data, col = 6)\n",
    "        self.opex = Petroleum_asset.data_tables(self, data_type = project_data, col = 7)\n",
    "        self.revenues = Petroleum_asset.data_tables(self, data_type = project_data, col = 8)\n",
    "        self.PW = Petroleum_asset.data_tables(self, data_type = project_data, col = 9)\n",
    "        self.npv = Petroleum_asset.data_tables(self, data_type = project_data, col = 10)\n",
    "        self.btcf = Petroleum_asset.data_tables(self, data_type = project_data, col = 11)\n",
    "        \n",
    "    def data_tables(self, data_type, col):\n",
    "        table = pd.DataFrame(data_type[col])\n",
    "        return table\n",
    "    \n",
    "    def asset_results(self, data=False):\n",
    "        if data:\n",
    "            #return(self.PW, self.revenues, self.opex, self.capex, self.co2_emission, self.annual_prod, self.npv)\n",
    "            return(self.result)\n",
    "        else:\n",
    "            val = int(input(\"Simulation Results:\\n\"\n",
    "                            \"\\n\"\n",
    "                            \"1    All Results \\n\"\n",
    "                            \"2    Present Worth \\n\"\n",
    "                            \"3    Revenues \\n\"\n",
    "                            \"4    Opex \\n\"\n",
    "                            \"5    Capex \\n\"\n",
    "                            \"6    CO2 Emission \\n\"\n",
    "                            \"7    Annual Production \\n\"\n",
    "                            \"8    NPV \\n\"\n",
    "                            \"9    Reserves \\n\"\n",
    "                            \"10   Undiscounted Net Cash Flow \\n\"\n",
    "                            \"\\n\"\n",
    "                            \"Enter Data Type Needed: \"))\n",
    "            \n",
    "            if val == 1:\n",
    "                return self.result\n",
    "            elif val == 2:\n",
    "                return self.PW\n",
    "            elif val == 3:\n",
    "                return self.revenues\n",
    "            elif val == 4:\n",
    "                return self.opex\n",
    "            elif val == 5:\n",
    "                return self.capex\n",
    "            elif val == 6:\n",
    "                return self.co2_emission\n",
    "            elif val == 7:\n",
    "                return self.annual_prod\n",
    "            elif val == 8:\n",
    "                return self.npv\n",
    "            elif val == 9:\n",
    "                return self.reserves\n",
    "            elif val == 10:\n",
    "                return self.btcf\n",
    "         \n",
    "    def asset_plot(self):\n",
    "        val = int(input(\"Plot Type:\\n\"\n",
    "                        \"\\n\"\n",
    "                        \"1    Production Profile \\n\"\n",
    "                        \"2    Cash Flow (annual mean) \\n\"\n",
    "                        \"3    Undiscounted Net Cash Flow (P90-P10-Mean) \\n\"\n",
    "                        \"4    CO2 Emission (annual mean) \\n\"\n",
    "                        \"5    Present Worth (P90-P10-Mean) \\n\"\n",
    "                        \"6    NPV Distribution \\n\"\n",
    "                        \"7    Reserves Distribution \\n\"\n",
    "                        \"8    Cash Flow Distribution of Year X  \\n\"\n",
    "                        \"\\n\"\n",
    "                        \"Enter Plot Needed: \"))\n",
    "        \n",
    "        if val == 1:\n",
    "            fig_f2 = go.Figure()\n",
    "            for i in range (0,self.n):\n",
    "                fig_f2.add_scatter(y=self.annual_prod[i])\n",
    "                fig_f2.update_layout(title=\"Production Profile Distribution\",\n",
    "                                  yaxis_title=\"Annual Oil/Gas Production (Mstb or Bscf)\",\n",
    "                                  xaxis_title=\"Years\",\n",
    "                                  legend_title=\"Iteration\",\n",
    "                                  font=dict(family=\"Courier New, monospace\",size=12,color=\"RebeccaPurple\")\n",
    "                                 )\n",
    "            fig_f2.show()\n",
    "            \n",
    "            fig_f1 = go.Figure()\n",
    "            fig_f1.add_scatter(y=self.annual_prod.T.quantile(0.1), name = 'P10')\n",
    "            fig_f1.add_scatter(y=self.annual_prod.mean(axis=1), name = 'Mean')\n",
    "            fig_f1.add_scatter(y=self.annual_prod.T.quantile(0.9), name = 'P90')\n",
    "            fig_f1.update_layout(title=\"Production Profile\",\n",
    "                              yaxis_title=\"Annual Oil/Gas Production (Mstb or Bscf)\",\n",
    "                              xaxis_title=\"Years\",\n",
    "                              font=dict(family=\"Courier New, monospace\",size=12,color=\"RebeccaPurple\")\n",
    "                             )\n",
    "            fig_f1.show()\n",
    "        \n",
    "        if val == 2:\n",
    "            capex_mean = self.capex.mean(axis=1)\n",
    "            revenues_mean = self.revenues.mean(axis=1)\n",
    "            opex_mean = self.opex.mean(axis=1)\n",
    "            x1=-opex_mean\n",
    "            x2=-capex_mean\n",
    "            x3= revenues_mean\n",
    "            # lists to dict\n",
    "            my_dict = {'opex': x1, 'capex': x2, 'revenues':x3}\n",
    "            # dict to df\n",
    "            result_df = pd.DataFrame(my_dict)\n",
    "            result_df\n",
    "\n",
    "            fig, ax = plt.subplots(1, figsize=(16, 8))\n",
    "            plt.bar(result_df.index, result_df['revenues'], color = '#337AE3', width =0.5)\n",
    "            #plt.bar(result_df.index, result_df['co2 tax'], color = '#5E96E9', width =0.5)\n",
    "            plt.bar(result_df.index, result_df['capex'], bottom = result_df['opex'], color = '#DB4444', width =0.5)\n",
    "            plt.bar(result_df.index, result_df['opex'], color = '#E17979', width =0.5)\n",
    "            # remove spines\n",
    "            ax.spines['right'].set_visible(False)\n",
    "            ax.spines['left'].set_visible(False)\n",
    "            ax.spines['top'].set_visible(False)\n",
    "            ax.spines['bottom'].set_visible(False)\n",
    "            #grid\n",
    "            ax.set_axisbelow(True)\n",
    "            ax.yaxis.grid(color='gray', linestyle='dashed', alpha=0.7)\n",
    "            # x ticks\n",
    "            years = [0 + i for i in range(0, self.period)]\n",
    "            plt.xticks(result_df.index , labels = years)\n",
    "            # title and legend\n",
    "            legend_label = ['revenues', 'capex', 'opex']\n",
    "            plt.legend(legend_label, ncol = 4, bbox_to_anchor=([1, 1.05, 0, 0]), frameon = False)\n",
    "            plt.title('Cash Flow Analysis', loc='left')\n",
    "            plt.xlabel('years')\n",
    "            plt.ylabel('USD (millions)')\n",
    "            plt.show()\n",
    "            \n",
    "        if val == 3: \n",
    "            fig_f3 = go.Figure()\n",
    "            fig_f3.add_scatter(y=self.btcf.T.quantile(0.1), name = 'P10')\n",
    "            fig_f3.add_scatter(y=self.btcf.mean(axis=1), name = 'Mean')\n",
    "            fig_f3.add_scatter(y=self.btcf.T.quantile(0.9), name = 'P90')\n",
    "            fig_f3.update_layout(title=\"Undiscounted Net Cash Flow\",\n",
    "                              yaxis_title=\"USD (million)\",\n",
    "                              xaxis_title=\"Years\",\n",
    "                              font=dict(family=\"Courier New, monospace\",size=12,color=\"RebeccaPurple\")\n",
    "                             )\n",
    "            fig_f3.show()\n",
    "            \n",
    "        if val == 4:\n",
    "            fig_f4 = go.Figure()\n",
    "            fig_f4.add_scatter(y=self.co2_emission.T.quantile(0.1), name = 'P10')\n",
    "            fig_f4.add_scatter(y=self.co2_emission.mean(axis=1), name = 'Mean')\n",
    "            fig_f4.add_scatter(y=self.co2_emission.T.quantile(0.9), name = 'P90')\n",
    "            fig_f4.update_layout(title=\"CO2 Emission\",\n",
    "                              yaxis_title=\"t CO2\",\n",
    "                              xaxis_title=\"Years\",\n",
    "                              font=dict(family=\"Courier New, monospace\",size=12,color=\"RebeccaPurple\")\n",
    "                             )\n",
    "            fig_f4.show()\n",
    "            \n",
    "            \n",
    "            ### production and emission intensity graph\n",
    "            ## should put trye instead of co2 above \n",
    "            annual_prod_mean = self.annual_prod.mean(axis=1)\n",
    "            x1=annual_prod_mean*0.136\n",
    "            my_dict = {'production': x1}\n",
    "            # dict to df\n",
    "            result_df = pd.DataFrame(my_dict)\n",
    "            result_df\n",
    "            \n",
    "        if val == 4.1: \n",
    "\n",
    "            ### (not part of the code - just maybe show the graph in thesis)\n",
    "            #fig, ax = plt.subplots(1, figsize=(16, 8))\n",
    "            plt.bar(result_df.index, result_df['production'], color = '#337AE3', width =0.5)\n",
    "            ax.spines['right'].set_visible(False)\n",
    "            ax.spines['left'].set_visible(False)\n",
    "            ax.spines['top'].set_visible(False)\n",
    "            ax.spines['bottom'].set_visible(False)\n",
    "            #grid\n",
    "            ax.set_axisbelow(True)\n",
    "            ax.yaxis.grid(color='gray', linestyle='dashed', alpha=0.7)\n",
    "            # x ticks\n",
    "            years = [0 + i for i in range(0, self.period)]\n",
    "            plt.xticks(result_df.index , labels = years)\n",
    "            # title and legend\n",
    "            legend_label = ['production']\n",
    "            plt.legend(legend_label, ncol = 4, bbox_to_anchor=([1, 1.05, 0, 0]), frameon = False)\n",
    "            plt.title('Production and emission per unit', loc='left')\n",
    "            plt.xlabel('years')\n",
    "            plt.ylabel('Million toe')\n",
    "            #plt.show()\n",
    "            \n",
    "            re = self.co2_emission.mean(axis=1).plot(secondary_y=True, label = 'Emission per unit', color = 'green')\n",
    "            re.legend(fontsize=12, frameon=False, bbox_to_anchor=([1, 1.05, 0, 0.05]))\n",
    "            re.legend('emission per unit', fontsize=12)\n",
    "            #re.set_ylim(30,70)\n",
    "            re.set_ylabel('kg CO2/toe', fontsize=16)\n",
    "            fig = re.get_figure()\n",
    "        \n",
    "            #plt.show()\n",
    "            \n",
    "        if val == 5:\n",
    "            fig_f3 = go.Figure()\n",
    "            fig_f3.add_scatter(y=self.PW.T.quantile(0.1), name = 'P10')\n",
    "            fig_f3.add_scatter(y=self.PW.mean(axis=1), name = 'Mean')\n",
    "            fig_f3.add_scatter(y=self.PW.T.quantile(0.9), name = 'P90')\n",
    "            fig_f3.update_layout(title=\"Net Cash Flow\",\n",
    "                              yaxis_title=\"USD (million)\",\n",
    "                              xaxis_title=\"Years\",\n",
    "                              font=dict(family=\"Courier New, monospace\",size=12,color=\"RebeccaPurple\")\n",
    "                             )\n",
    "            fig_f3.show()\n",
    "            \n",
    "        \n",
    "        if val == 6:\n",
    "            import plotly.express as px\n",
    "            hist_reserves = px.histogram(self.npv, histnorm='probability', nbins=20)\n",
    "            #hist_reserves = px.histogram(self.npv, nbins=10)\n",
    "            hist_reserves.update_layout(xaxis_title=\"NPV (USD million)\", yaxis_title=\"Normalized Frequency\")\n",
    "            hist_reserves.show()\n",
    "            \n",
    "        if val == 7:\n",
    "            import plotly.express as px\n",
    "            hist_reserves = px.histogram(self.reserves, histnorm='probability')\n",
    "            hist_reserves.update_layout(xaxis_title=\"Reserves (Mstb)\", yaxis_title=\"Normalized Frequency\")\n",
    "            hist_reserves.show()\n",
    "\n",
    "\n",
    "\n",
    "#define a function that calculates the oil and gas prices \n",
    "def og_price (period, n):\n",
    "    #Mean reverting parameters derived from historical HC prices \n",
    "    dt = 1 #time step for oil and gas in years  \n",
    "    oil_floor = 8 #oil price floor in USD/bbl\n",
    "    gas_floor = 0.8 #gas price floor in USD/Mscf\n",
    "    oil_sd = 3   #oil volatility in USD/bbl\n",
    "    gas_sd = 0.7 #gas volatility in USD/Mscf\n",
    "    oil_half = 4 #oil half-life in years \n",
    "    gas_half = 8 #gas half-life in years \n",
    "    oil_ini_price = 40 #oil initial price in USD/bbl\n",
    "    gas_ini_price = 2.3 #gas initial price in USD/Mscf\n",
    "    oil_mean_price = 70 #oil long term mean price in USD/bbl\n",
    "    gas_mean_price = 5 #gas long term mean price in USD/Mscf \n",
    "    \n",
    "    \n",
    "    def hc_price (period, dt, floor, sd, life_half, ini_price, mean_price):\n",
    "        speed = math.log(2) / (life_half * dt) #mean reversion rate\n",
    "        price_og = np.zeros(period+1) #zeros array to store the price generated \n",
    "        price_og[0] = ini_price #set the first input to the array to be equal to the initial oil or gas price\n",
    "        #epsilon = np.random.normal (0,1,101) #random variable with standard normal distribution \n",
    "        \n",
    "        #Correlation between oil and gas prices using Cholesky decomposition\n",
    "        x_uncor = np.random.normal(0, 1, (2, 101))\n",
    "        cov = np.array([[ 1.0, 0.63], \n",
    "                        [ 0.63, 1.0]])  #oil and gas correlation matrix \n",
    "        L = np.linalg.cholesky(cov)\n",
    "        x_cor = np.dot(L, x_uncor)\n",
    "        corr_simulated = pd.DataFrame(x_cor).T.corr()\n",
    "        std_ = np.sqrt(np.diag(cov))\n",
    "        corr_empirical = cov / np.outer(std_, std_)\n",
    "        \n",
    "        for i in range(1, period+1):\n",
    "            price_og[i] = max(floor, price_og[i-1] +(mean_price - price_og[i-1]) * dt * speed + \n",
    "                              sd * math.sqrt(dt) * x_cor[1][i])\n",
    "        return (price_og)\n",
    "    \n",
    "    \n",
    "    #Calculate the oil price using the hydrocarbon price function (hc_price)\n",
    "    oil_price = np.array([hc_price(period, dt, oil_floor, oil_sd, oil_half, oil_ini_price, oil_mean_price) \n",
    "                          for i in range(0, n)])\n",
    "    oil_price = np.transpose(oil_price)\n",
    "    \n",
    "    #Calculate the gas price using the hydrocarbon price function (hc_price)\n",
    "    gas_price = np.array([hc_price(period, dt, gas_floor, gas_sd, gas_half, gas_ini_price, gas_mean_price) \n",
    "                          for i in range(0, n)])\n",
    "    gas_price = np.transpose(gas_price)\n",
    "\n",
    "    return (oil_price, gas_price)\n",
    "\n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-65-82108be07725>:194: RuntimeWarning:\n",
      "\n",
      "overflow encountered in long_scalars\n",
      "\n",
      "<ipython-input-65-82108be07725>:274: RuntimeWarning:\n",
      "\n",
      "divide by zero encountered in double_scalars\n",
      "\n"
     ]
    }
   ],
   "source": [
    "ij=Petroleum_asset(location='onshore', hc_type='oil', phase='exploration', \n",
    "                res_est=100, well_max_rate=40, well_cap_pot=0.5, n=10, init_year=0, period=31)\n",
    "ij.asset_evaluation()\n",
    "#ij.asset_results(data=False)\n",
    "#ij.asset_plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Wind_farm_asset(object):\n",
    "    def __init__(self, location, n_turbine, const_sc, perc_subs, period, n):\n",
    "        \n",
    "        self.location = location            #asset location (onshore or offshore)\n",
    "        self.n_turbine = n_turbine          #asset number of turbines (30 or 60)\n",
    "        self.const_sc = const_sc            #asset construction sceheme (10/80/10 or 30/60/10)\n",
    "        self.perc_subs = perc_subs          #asset government percentage of subsidies \n",
    "        self.n = n                          #number of iterations\n",
    "        self.period = period                #project period (years)\n",
    "        \n",
    "        \n",
    "    def asset_evaluation(self):\n",
    "        \n",
    "        def pert(self, n, min, max, mode):\n",
    "\n",
    "            # Calculating Beta-distribution parameters, based on the PERT parameters\n",
    "            alpha = 2 * (max + 4 * mode - 5 * min) / (3 * (max - min)) * \\\n",
    "            (1 + 4 * (mode - min) * (max - mode) / (max - min)**2)\n",
    "\n",
    "            beta = 2 * (5 * max - 4 * mode - min) / (3 * (max - min)) * \\\n",
    "            (1 + 4 * (mode - min) * (max - mode) / (max - min)**2)\n",
    "\n",
    "            # Generating Beta-distribution (scipy.stats package)\n",
    "            my_beta_distr = scipy.stats.beta.rvs(a = alpha, b = beta, size=n)\n",
    "\n",
    "            # Converting Beta into PERT (scaling)\n",
    "            pert = my_beta_distr * (max - min) + min\n",
    "\n",
    "            return(pert)\n",
    "        \n",
    "        wacc=0.08\n",
    "\n",
    "        #Installed capacity (MW) - 2.3 MW turbines \n",
    "        inst_cap = self.n_turbine*2.3 \n",
    "\n",
    "\n",
    "        #Yearly production degradation (%)\n",
    "        #energy_prod_deg = 0.005\n",
    "\n",
    "        #Volume of capital cost (Y1-Y2-Y3)\n",
    "        if self.const_sc == '10/80/10':\n",
    "            cap_cons_1 = 0.1 \n",
    "            cap_cons_2 = 0.8\n",
    "            cap_cons_3 = 0.1 \n",
    "\n",
    "        elif self.const_sc == '30/60/10':\n",
    "            cap_cons_1 = 0.3 \n",
    "            cap_cons_2 = 0.6\n",
    "            cap_cons_3 = 0.1 \n",
    "            \n",
    "\n",
    "        #Capex and Opex \n",
    "        if self.location == 'onshore':\n",
    "            opex = pert (self, n=self.n ,min=0.01, max=0.035, mode=0.015) #($/kWh)\n",
    "            capex_var = 1000000*inst_cap * pert (self, n=self.n, min=1.2, max=2.29, mode=1.8)      #(m$/MW)\n",
    "            capex_fix = pert(self, self.n, min=36, max=75, mode=50)\n",
    "            capex = 0.73*capex_var + 0.27*capex_fix\n",
    "\n",
    "        elif self.location == 'offshore':\n",
    "            opex = pert (self, self.n, min=0.015, max=0.048, mode=0.03) #($/kWh)\n",
    "            capex_var = 1000000*inst_cap*pert (self, n.self, min=2.29, max=5.42, mode=3.5)    #(m$/MW) \n",
    "            capex_fix = pert(self, self.n, min=43.2, max=90, mode=72)\n",
    "            capex = 0.73*capex_var + 0.27*capex_fix\n",
    "\n",
    "        #Annual subsidies and Capex \n",
    "        total_subs = capex*self.perc_subs\n",
    "        annual_cap = np.zeros((self.n,self.period))\n",
    "        annual_subs = np.zeros((self.n,self.period))\n",
    "        repower = np.array([0.88*10**6]*self.n)\n",
    "        for j in range (0,self.n):\n",
    "            for i in range (0,3):\n",
    "                annual_subs[j,i] = total_subs[j]/3\n",
    "            annual_cap[j,0] = capex[j]*cap_cons_1\n",
    "            annual_cap[j,1] = capex[j]*cap_cons_2\n",
    "            annual_cap[j,2] = capex[j]*cap_cons_3\n",
    "            annual_cap[j,21] = inst_cap*repower[j]\n",
    "\n",
    "        #Annual energy production \n",
    "        purch_price = pert(self, self.n, min=0.08, max=0.14, mode=0.1068) #Purchase price of energy ($/kWh)\n",
    "        energy_cap = pert(self, (self.n, self.period), min=0.5, max=0.85, mode=0.65) #Energy production capacity (%)\n",
    "        energy_prod_theo = (self.n_turbine)*pert(self, (self.n, self.period), \n",
    "                                                 min=6500, max=10000, mode=8000) #Annual theoretical production (MWh)\n",
    "        annual_ener_prod = energy_prod_theo*energy_cap #(in MWh)\n",
    "        for i in range (0,3):\n",
    "            annual_ener_prod[:,i] = 0\n",
    "\n",
    "        #Annual revenues and Opex from energy production \n",
    "        purch_price_inc = 0.03  #purchase price yearly increment\n",
    "        opex_inc = 0.015  #Annual increment in Opex\n",
    "        annual_purch_price = np.zeros((self.n, self.period))\n",
    "        annual_opex = np.zeros((self.n, self.period))\n",
    "        for j in range (0,self.n):\n",
    "            annual_purch_price[j,3]=purch_price[j]\n",
    "            annual_opex[j,3]=opex[j]\n",
    "            for i in range (4,self.period):\n",
    "                annual_purch_price[j,i] = annual_purch_price[j,i-1]*(1+purch_price_inc)\n",
    "                annual_opex[j,i] = annual_opex[j,i-1]*(1+opex_inc)\n",
    "        annual_rev = annual_purch_price*annual_ener_prod*1000\n",
    "        annual_cost_opex = annual_opex*annual_ener_prod*1000\n",
    "\n",
    "\n",
    "        #Annual depreciation \n",
    "        annual_dep = np.zeros((self.n, self.period))\n",
    "        for j in range (0,self.n): \n",
    "            for i in range (4,self.period):\n",
    "                annual_dep [j,i] = capex[j]/(self.period-3)\n",
    "\n",
    "        #BTCF and ATCF\n",
    "        sv=pert(self, self.n, min=500000, max=1000000, mode=750000)\n",
    "        BTCF=np.zeros((self.n, self.period))\n",
    "        BTCF = annual_subs + annual_rev - annual_cost_opex - annual_cap\n",
    "        BTCF[:,-1]+=sv\n",
    "\n",
    "        TI=BTCF-annual_dep                            \n",
    "        TI[:,0]=[0]     \n",
    "        tax_rate = 0.4\n",
    "        T=-tax_rate*TI      \n",
    "\n",
    "        ATCF=BTCF+T  \n",
    "        discount_factors=np.zeros(self.period)\n",
    "        for k in range (0,self.period):\n",
    "            discount_factors[k]= 1/((1+wacc)**(k))\n",
    "        PW = sum((ATCF * discount_factors).T)\n",
    "        PW = PW*(10**-6)\n",
    "\n",
    "        ATCF_array = []\n",
    "        for k in range (0,self.period):\n",
    "            mean_ATCF = np.mean(ATCF[:,k])\n",
    "            ATCF_array.append(mean_ATCF) #Annual Cash Flow \n",
    "\n",
    "        #CO2 Emission from Wind Farms\n",
    "        co2_coef = pert (self, self.n, min=0.005, max=0.0082, mode=0.006) #(kg/kWh)\n",
    "        co2_emission = np.zeros((self.n, self.period))\n",
    "        for k in range (0,self.n):\n",
    "            co2_emission[k,:]=co2_coef[k]\n",
    "        annual_co2_emission = co2_emission*annual_ener_prod*10**-3\n",
    "        \n",
    "        ###Storing the simulation results \n",
    "        project_data = [self.n_turbine, self.location,\n",
    "                        annual_co2_emission.T, PW, BTCF.T, (annual_cap*10**-6).T, (annual_ener_prod*10**-6).T]\n",
    "        self.result = project_data \n",
    "        self.co2_emission = Wind_farm_asset.data_tables(self, data_type = project_data, col = 2)\n",
    "        self.npv = Wind_farm_asset.data_tables(self, data_type = project_data, col = 3)\n",
    "        self.btcf = Wind_farm_asset.data_tables(self, data_type = project_data, col = 4)\n",
    "        self.capex = Wind_farm_asset.data_tables(self, data_type = project_data, col = 5)\n",
    "        self.energy_prod = Wind_farm_asset.data_tables(self, data_type = project_data, col = 6)\n",
    "        \n",
    "    def data_tables(self, data_type, col):\n",
    "        table = pd.DataFrame(data_type[col])\n",
    "        return table\n",
    "    \n",
    "    def asset_results(self, data=False):\n",
    "        if data:\n",
    "            return(self.result)\n",
    "        else:\n",
    "            val = int(input(\"Simulation Results:\\n\"\n",
    "                            \"\\n\"\n",
    "                            \"1    All Results \\n\"\n",
    "                            \"2    NPV \\n\"\n",
    "                            \"3    Capex \\n\"\n",
    "                            \"4    CO2 Emission \\n\"\n",
    "                            \"5    Annual Energy Production \\n\"\n",
    "                            \"\\n\"\n",
    "                            \"Enter Data Type Needed: \"))\n",
    "            \n",
    "            if val == 1:\n",
    "                return self.result\n",
    "            elif val == 2:\n",
    "                return self.npv\n",
    "            elif val == 3:\n",
    "                return self.capex\n",
    "            elif val == 4:\n",
    "                return self.co2_emission\n",
    "            elif val == 5:\n",
    "                return self.energy_prod"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "ik=Wind_farm_asset(location='onshore', n_turbine=60, const_sc='10/80/10', \n",
    "                   perc_subs=0.45, period=30, n=10)\n",
    "ik.asset_evaluation()\n",
    "#ik.asset_results(data=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class "
   ]
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}