Model2_PostProcessing.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "# Post-Processing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### (Static) Parameters for post-processing (can be changed to alter design and KPI performance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Primary data parameters of our scenarios\n",
    "pv_price= 80                #https://data.nrel.gov/submissions/53 in EUR/kW\n",
    "bess_price= 200             #https://doi.org/10.1016/j.solener.2018.08.061 in EUR/kWh, adjusted for price decreases\n",
    "bess_bos= 250               #https://www.energy-storage.news/li-ion-bess-costs-could-fall-47-by-2030-nrel-says-in-long-term-forecast-update/ in EUR/kW\n",
    "## Also see: https://www.nrel.gov/grid/assets/pdfs/second_grid_sim_zagoras.pdf\n",
    "# pv_opex= 17                 #EUR/kWh ->reference in excel\n",
    "# bess_opex= 0.125            #EUR/kWh ->reference in excel\n",
    "pv_opex= 3\n",
    "bess_opex= 6\n",
    "\n",
    "pv_co2=             33      #kgCO2eq/kW_powerDC ->reference in excel\n",
    "bess_co2=           100     #kgCO2eq/kWh_capacity ->reference in excel\n",
    "pv_opex_co2=        0       #kgCO2eq/kW_powerDC ->assumption\n",
    "bess_opex_co2=      0       #kgCO2eq/kW_powerDC ->assumption\n",
    "discount_rate=      0.0485  #assumption\n",
    "degradation_rate=   0.025   #assumption (based on reaching 80% SoH in 8 years)\n",
    "lifetime_project=   32      #for the project lifetime\n",
    "lifetime_bess=      8       #for the BESS lifetime\n",
    "\n",
    "params = {\n",
    "    'pv_price':         pv_price,\n",
    "    'bess_price':       bess_price,\n",
    "    'bess_bos':         bess_bos,\n",
    "    'pv_opex':          pv_opex,\n",
    "    'bess_opex':        bess_opex,\n",
    "    'pv_co2':           pv_co2,\n",
    "    'bess_co2':         bess_co2,\n",
    "    'pv_opex_co2':      pv_opex_co2,\n",
    "    'bess_opex_co2':    bess_opex_co2,\n",
    "    'discount_rate':    discount_rate,\n",
    "    'lifetime_project': lifetime_project,\n",
    "    'lifetime_bess':    lifetime_bess,\n",
    "    'degradation_rate': degradation_rate\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setting functions for calculating KPIs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "## General LCOE function\n",
    "def calc_lcoe(annual_output, capital_cost, annual_operating_cost, eol_burden, discount_rate, degradation_rate, lifetime):\n",
    "    discount_factor_annualised = ( (1 - ( 1/( ( 1 + discount_rate ) **lifetime ) ) ) * ( 1 + discount_rate )) / ( ( 1 + discount_rate ) -1 )\n",
    "    degradation_factor_annualised = ( (1 - ( 1/( ( 1 + degradation_rate ) **lifetime ) ) ) * ( 1 + degradation_rate )) / ( ( 1 + degradation_rate ) -1 )\n",
    "    result = ( capital_cost + annual_operating_cost * discount_factor_annualised + eol_burden) / ( annual_output * degradation_factor_annualised )\n",
    "    return result\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "## Main function for KPIs in the model\n",
    "### Future update - separate smaller functions\n",
    "def get_KPIs(\n",
    "        profile,\n",
    "        solar_factor,   # solar_factor=   pv_scale\n",
    "        PessCH,         # PessCH=         p_bess\n",
    "        EnESS,          # EnESS=          e_bess\n",
    "        load,\n",
    "        region\n",
    "    ):\n",
    "    '''\n",
    "    Base columns when profile is loaded:\n",
    "\n",
    "    'Hour',\n",
    "    'P_PV_to_Load',\n",
    "    'P_PV_to_BESS',\n",
    "    'P_PV_curtailment',\n",
    "    'P_PV_to_Grid',\n",
    "    'P_BESS_to_Load',\n",
    "    'P_BESS_to_Grid',\n",
    "    'P_Grid_to_Load',\n",
    "    'P_Grid_to_BESS',\n",
    "    'SoC',\n",
    "    'sum_power_flows'\n",
    "    '''\n",
    "\n",
    "\n",
    "    price_curve=    data_dict[region]['Price']/1000\n",
    "    co2_curve=      data_dict[region]['CO_2_eq']\n",
    "\n",
    "    t_bess= EnESS/PessCH\n",
    "\n",
    "    ## Add profits equation, other factors\n",
    "    savings= 0\n",
    "    for i in range(8760):\n",
    "        #savings += ((price_curve.Grid_Price[i]) * (profile.P_PV_to_Load[i] + profile.P_BESS_to_Load[i]))\n",
    "        savings += ((price_curve[i]) * (profile.P_PV_to_Load[i] + profile.P_BESS_to_Load[i]))\n",
    "    \n",
    "    energy_procurement_costs= 0\n",
    "    for i in range(8760):\n",
    "        #energy_procurement_costs += ((price_curve.Grid_Price[i]) * (profile.P_Grid_to_Load[i] + profile.P_Grid_to_BESS[i]))\n",
    "        energy_procurement_costs += ((price_curve[i]) * (profile.P_Grid_to_Load[i] + profile.P_Grid_to_BESS[i]))\n",
    "    \n",
    "    energy_procurement_costs_load= 0\n",
    "    for i in range(8760):\n",
    "        #energy_procurement_costs_load += ((price_curve.Grid_Price[i]) * (profile.P_Grid_to_Load[i]))\n",
    "        energy_procurement_costs_load += ((price_curve[i]) * (profile.P_Grid_to_Load[i]))\n",
    "    \n",
    "    energy_procurement_costs_bess= 0\n",
    "    for i in range(8760):\n",
    "        #energy_procurement_costs_bess += ((price_curve.Grid_Price[i]) * (profile.P_Grid_to_BESS[i]))\n",
    "        energy_procurement_costs_bess += ((price_curve[i]) * (profile.P_Grid_to_BESS[i]))\n",
    "\n",
    "    profit= 0\n",
    "    for i in range(8760):\n",
    "        #profit += ((price_curve.Grid_Price[i]) * (profile.P_BESS_to_Grid[i] + profile.P_PV_to_Grid[i]))\n",
    "        profit += ((price_curve[i]) * (profile.P_BESS_to_Grid[i] + profile.P_PV_to_Grid[i]))\n",
    "    \n",
    "    profit_pv= 0\n",
    "    for i in range(8760):\n",
    "        #profit_pv += ((price_curve.Grid_Price[i]) * (profile.P_PV_to_Grid[i]))\n",
    "        profit_pv += ((price_curve[i]) * (profile.P_PV_to_Grid[i]))\n",
    "    \n",
    "    profit_bess= 0\n",
    "    for i in range(8760):\n",
    "        #profit_bess += ((price_curve.Grid_Price[i]) * (profile.P_BESS_to_Grid[i]))\n",
    "        profit_bess += ((price_curve[i]) * (profile.P_BESS_to_Grid[i]))\n",
    "    \n",
    "    co2avoided= 0\n",
    "    for i in range(8760):\n",
    "        #co2avoided += ((co2_curve.carbon_intensity_production_avg[i] - 12) * (profile.P_PV_to_Load[i] + profile.P_BESS_to_Load[i]))\n",
    "        #co2avoided += ((co2_curve.carbon_intensity_production_avg[i]) * (profile.P_PV_to_Load[i] + profile.P_BESS_to_Load[i]))\n",
    "        co2avoided += ((co2_curve[i]) * (profile.P_PV_to_Load[i] + profile.P_BESS_to_Load[i]))\n",
    "    \n",
    "    co2burden= 0\n",
    "    for i in range(8760):\n",
    "        #co2burden += ((co2_curve.carbon_intensity_production_avg[i]) * (profile.P_Grid_to_Load[i] + profile.P_Grid_to_BESS[i]))\n",
    "        co2burden += ((co2_curve[i]) * (profile.P_Grid_to_Load[i] + profile.P_Grid_to_BESS[i]))\n",
    "    \n",
    "    co2burden_load= 0\n",
    "    for i in range(8760):\n",
    "        #co2burden_load += ((co2_curve.carbon_intensity_production_avg[i]) * (profile.P_Grid_to_Load[i]))\n",
    "        co2burden_load += ((co2_curve[i]) * (profile.P_Grid_to_Load[i]))\n",
    "    \n",
    "    co2burden_bess= 0\n",
    "    for i in range(8760):\n",
    "        #co2burden_bess += ((co2_curve.carbon_intensity_production_avg[i]) * (profile.P_Grid_to_BESS[i]))\n",
    "        co2burden_bess += ((co2_curve[i]) * (profile.P_Grid_to_BESS[i]))\n",
    "\n",
    "    co2abatement= 0\n",
    "    for i in range(8760):\n",
    "        #co2abatement += ((co2_curve.carbon_intensity_production_avg[i]) * (profile.P_BESS_to_Grid[i] + profile.P_PV_to_Grid[i]))\n",
    "        co2abatement += ((co2_curve[i]) * (profile.P_BESS_to_Grid[i] + profile.P_PV_to_Grid[i]))\n",
    "    \n",
    "    co2abatement_pv= 0\n",
    "    for i in range(8760):\n",
    "        #co2abatement_pv += ((co2_curve.carbon_intensity_production_avg[i]) * (profile.P_PV_to_Grid[i]))\n",
    "        co2abatement_pv += ((co2_curve[i]) * (profile.P_PV_to_Grid[i]))\n",
    "    \n",
    "    co2abatement_bess= 0\n",
    "    for i in range(8760):\n",
    "        #co2abatement_bess += ((co2_curve.carbon_intensity_production_avg[i]) * (profile.P_BESS_to_Grid[i]))\n",
    "        co2abatement_bess += ((co2_curve[i]) * (profile.P_BESS_to_Grid[i]))\n",
    "    \n",
    "    \n",
    "\n",
    "    pv2load=    profile['P_PV_to_Load'].sum()\n",
    "    pv2bess=    profile['P_PV_to_BESS'].sum()\n",
    "    pv2curtail= profile['P_PV_curtailment'].sum()\n",
    "    pv2grid=    profile['P_PV_to_Grid'].sum()\n",
    "    bess2load=  profile['P_BESS_to_Load'].sum()\n",
    "    bess2grid=  profile['P_BESS_to_Grid'].sum()\n",
    "    grid2load=  profile['P_Grid_to_Load'].sum()\n",
    "    grid2bess=  profile['P_Grid_to_BESS'].sum()\n",
    "\n",
    "    annual_energy= pv2load + bess2load + pv2grid + bess2grid\n",
    "    annual_energy_enduser= pv2load + bess2load + grid2load\n",
    "\n",
    "    if EnESS == 0:\n",
    "        cycles= int(0)\n",
    "    else:\n",
    "        cycles= int((int(bess2load) + int(bess2grid)) / (EnESS * 1000))\n",
    "\n",
    "\n",
    "\n",
    "    ## Re-check capex equations and make corrections (e.g. add BOS, BOP, EoL)\n",
    "    ## If need be, reference specific equations for LCOE, or parts of LCOE, calculations\n",
    "    capex= solar_factor * params['pv_price'] * 1000 + EnESS * 1000 * params['bess_price'] + PessCH * 1000 * params['bess_bos']\n",
    "    capex_pv= solar_factor * params['pv_price'] * 1000\n",
    "    capex_bess= EnESS * 1000 * params['bess_price'] + PessCH * 1000 * params['bess_bos']\n",
    "    opex= solar_factor * params['pv_opex'] * 1000 + EnESS * 1000 * params['bess_opex']\n",
    "    opex_pv= solar_factor * params['pv_opex'] * 1000\n",
    "    opex_bess= EnESS * 1000 * params['bess_opex']\n",
    "    opex_investor= opex + energy_procurement_costs_bess\n",
    "    if EnESS == 0:\n",
    "        opex_enduser= opex + energy_procurement_costs_load\n",
    "    elif EnESS == 0.0:\n",
    "        opex_enduser= opex + energy_procurement_costs_load\n",
    "    else:\n",
    "        opex_enduser= opex + energy_procurement_costs_load + energy_procurement_costs_bess * (bess2load/(bess2load + bess2grid))\n",
    "    eol_capex= capex * 0.3\n",
    "    capex_co2= solar_factor * params['pv_co2'] * 1000 + EnESS * 1000 * params['bess_co2']\n",
    "    capex_co2_pv= solar_factor * params['pv_co2'] * 1000\n",
    "    capex_co2_bess= EnESS * 1000 * params['bess_co2']\n",
    "    opex_co2= solar_factor * params['pv_opex_co2'] * 1000 + EnESS * 1000 * params['bess_opex_co2']\n",
    "    opex_co2_pv= solar_factor * params['pv_opex_co2'] * 1000\n",
    "    opex_co2_bess= EnESS * 1000 * params['bess_opex_co2']\n",
    "    opex_co2_investor= opex_co2 + co2burden_bess\n",
    "    if EnESS == 0:\n",
    "        opex_co2_enduser= opex_co2 + co2burden_load\n",
    "    elif EnESS == 0.0:\n",
    "        opex_co2_enduser= opex_co2 + co2burden_load\n",
    "    else:\n",
    "        opex_co2_enduser= opex_co2 + co2burden_load + co2burden_bess * (bess2load/(bess2load + bess2grid))\n",
    "    eol_co2= capex_co2 * 0.3\n",
    "\n",
    "    ## Get LCOE and LCO2 for the system\n",
    "    if annual_energy == 0:\n",
    "        lcoe_revenue=   0\n",
    "        lcoe_investor=  0\n",
    "        lco2_abatement= 0\n",
    "        lco2_investor=  0\n",
    "    elif annual_energy == 0.0:\n",
    "        lcoe_revenue=   0\n",
    "        lcoe_investor=  0\n",
    "        lco2_abatement= 0\n",
    "        lco2_investor=  0\n",
    "    else:\n",
    "        lcoe_revenue= calc_lcoe(\n",
    "            annual_output= annual_energy,\n",
    "            capital_cost= capex,\n",
    "            annual_operating_cost= (opex + energy_procurement_costs_bess - profit),\n",
    "            eol_burden= eol_capex,\n",
    "            discount_rate= discount_rate,\n",
    "            degradation_rate= degradation_rate,\n",
    "            lifetime= 32\n",
    "        )\n",
    "        lcoe_investor= calc_lcoe(\n",
    "            annual_output= annual_energy,\n",
    "            capital_cost= capex,\n",
    "            annual_operating_cost= opex_investor,\n",
    "            eol_burden= eol_capex,\n",
    "            discount_rate= discount_rate,\n",
    "            degradation_rate= degradation_rate,\n",
    "            lifetime= 32\n",
    "        )\n",
    "        lco2_abatement= calc_lcoe(\n",
    "            annual_output= annual_energy,\n",
    "            capital_cost= capex_co2,\n",
    "            annual_operating_cost= (opex_co2 + co2burden_bess - co2abatement),\n",
    "            eol_burden= eol_co2,\n",
    "            discount_rate= discount_rate,\n",
    "            degradation_rate= degradation_rate,\n",
    "            lifetime= 32\n",
    "        )\n",
    "        lco2_investor= calc_lcoe(\n",
    "            annual_output= annual_energy,\n",
    "            capital_cost= capex_co2,\n",
    "            annual_operating_cost= opex_co2_investor,\n",
    "            eol_burden= eol_co2,\n",
    "            discount_rate= discount_rate,\n",
    "            degradation_rate= degradation_rate,\n",
    "            lifetime= 32\n",
    "        )\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    lcoe_enduser= calc_lcoe(\n",
    "        annual_output= annual_energy_enduser,\n",
    "        capital_cost= capex,\n",
    "        annual_operating_cost= opex_enduser,\n",
    "        eol_burden= eol_capex,\n",
    "        discount_rate= discount_rate,\n",
    "        degradation_rate= degradation_rate,\n",
    "        lifetime= 32\n",
    "    )\n",
    "    \n",
    "    lco2_enduser= calc_lcoe(\n",
    "        annual_output= annual_energy_enduser,\n",
    "        capital_cost= capex_co2,\n",
    "        annual_operating_cost= opex_co2_enduser,\n",
    "        eol_burden= eol_co2,\n",
    "        discount_rate= discount_rate,\n",
    "        degradation_rate= degradation_rate,\n",
    "        lifetime= 32\n",
    "    )\n",
    "\n",
    "\n",
    "\n",
    "    ## SS = how much of the load was covered by the PV system\n",
    "    self_sufficiency= ((pv2load + bess2load) / (loads_selected[load].sum() * 1000)) * 100\n",
    "    #self_sufficiency= ((pv2load + pv2bess) / data.Load.sum()) * 100\n",
    "    \n",
    "    if EnESS == 0:\n",
    "        ress= (pv2load / (loads_selected[load].sum() * 1000)) * 100\n",
    "    elif EnESS == 0.0:\n",
    "        ress= (pv2load / (loads_selected[load].sum() * 1000)) * 100\n",
    "    elif solar_factor == 0:\n",
    "        ress = 0\n",
    "    elif solar_factor == 0.0:\n",
    "        ress = 0\n",
    "    else:\n",
    "        ress= ((pv2load + bess2load * (pv2bess / (pv2bess + grid2bess))) / (loads_selected[load].sum() * 1000)) * 100\n",
    "\n",
    "    ## SC = 1 - curtailment factor?\n",
    "    if solar_factor == 0:\n",
    "        self_consumption = 0\n",
    "    else:\n",
    "        self_consumption= ((pv2load + pv2bess) / (data_dict[region].solar_pv.sum() * (solar_factor / 100))) * 100\n",
    "    \n",
    "    \n",
    "    \n",
    "    parameters = (\n",
    "        solar_factor,\n",
    "        PessCH,\n",
    "        EnESS,\n",
    "        t_bess,\n",
    "        pv2load,\n",
    "        pv2bess,\n",
    "        pv2curtail,\n",
    "        pv2grid,\n",
    "        bess2load,\n",
    "        bess2grid,\n",
    "        grid2load,\n",
    "        grid2bess,\n",
    "        annual_energy,\n",
    "        capex,\n",
    "        capex_pv,\n",
    "        capex_bess,\n",
    "        opex,\n",
    "        opex_pv,\n",
    "        opex_bess,\n",
    "        capex_co2,\n",
    "        capex_co2_pv,\n",
    "        capex_co2_bess,\n",
    "        opex_co2,\n",
    "        opex_co2_pv,\n",
    "        opex_co2_bess,\n",
    "        lcoe_investor,\n",
    "        lcoe_enduser,\n",
    "        lcoe_revenue,\n",
    "        lco2_investor,\n",
    "        lco2_enduser,\n",
    "        lco2_abatement,\n",
    "        savings,\n",
    "        energy_procurement_costs,\n",
    "        energy_procurement_costs_load,\n",
    "        energy_procurement_costs_bess,\n",
    "        profit,\n",
    "        profit_pv,\n",
    "        profit_bess,\n",
    "        co2avoided,\n",
    "        co2burden,\n",
    "        co2burden_load,\n",
    "        co2burden_bess,\n",
    "        co2abatement,\n",
    "        co2abatement_pv,\n",
    "        co2abatement_bess,\n",
    "        cycles,\n",
    "        self_sufficiency,\n",
    "        ress,\n",
    "        self_consumption,\n",
    "        load,\n",
    "        region\n",
    "    )\n",
    "    return parameters\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setting DataFrame for results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "columns=[\n",
    "        'P_PV',\n",
    "        'P_BESS',\n",
    "        'E_BESS',\n",
    "        'T_BESS',\n",
    "        'pv2load',\n",
    "        'pv2bess',\n",
    "        'pv2curtail',\n",
    "        'pv2grid',\n",
    "        'bess2load',\n",
    "        'bess2grid',\n",
    "        'grid2load',\n",
    "        'grid2bess',\n",
    "        'annual_energy',\n",
    "        'capex',\n",
    "        'capex_pv',\n",
    "        'capex_bess',\n",
    "        'opex',\n",
    "        'opex_pv',\n",
    "        'opex_bess',\n",
    "        'capex_co2',\n",
    "        'capex_co2_pv',\n",
    "        'capex_co2_bess',\n",
    "        'opex_co2',\n",
    "        'opex_co2_pv',\n",
    "        'opex_co2_bess',\n",
    "        'lcoe_investor',\n",
    "        'lcoe_enduser',\n",
    "        'lcoe_revenue',\n",
    "        'lco2_investor',\n",
    "        'lco2_enduser',\n",
    "        'lco2_abatement',\n",
    "        'savings',\n",
    "        'energy_procurement_costs',\n",
    "        'energy_procurement_costs_load',\n",
    "        'energy_procurement_costs_bess',\n",
    "        'profit',\n",
    "        'profit_pv',\n",
    "        'profit_bess',\n",
    "        'co2avoided',\n",
    "        'co2burden',\n",
    "        'co2burden_load',\n",
    "        'co2burden_bess',\n",
    "        'co2abatement',\n",
    "        'co2abatement_pv',\n",
    "        'co2abatement_bess',\n",
    "        'cycles',\n",
    "        'self_sufficiency',\n",
    "        'ress',\n",
    "        'self_consumption',\n",
    "        'load_source',\n",
    "        'region'\n",
    "    ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "results_econ=            pd.DataFrame(\n",
    "    columns= columns\n",
    ")\n",
    "results_env=             pd.DataFrame(\n",
    "    columns= columns\n",
    ")\n",
    "\n",
    "\n",
    "\n",
    "results_econ_old=            pd.DataFrame(\n",
    "    columns= columns\n",
    ")\n",
    "results_env_old=             pd.DataFrame(\n",
    "    columns= columns\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Specifying ranges of profiles for post-processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "### A bit of an awkward solution for now\n",
    "## Import resindential and industrial loads\n",
    "loads_residential= pd.read_csv(\n",
    "    'Data/LoadProfiles_SE_Residential.csv',\n",
    ")\n",
    "\n",
    "loads_to_use_residential= [\n",
    "    'residential1',\n",
    "    'residential2',\n",
    "    'residential3',\n",
    "    'residential4',\n",
    "    'residential5'\n",
    "]\n",
    "\n",
    "\n",
    "\n",
    "loads_industrial= pd.read_csv(\n",
    "    'Data/LoadProfiles_SE_Industrial.csv',\n",
    ")\n",
    "\n",
    "loads_to_use_industrial= [\n",
    "    'industrial1',\n",
    "    'industrial2',\n",
    "]\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "## Create a common DataFrame for the loads\n",
    "loads_selected= pd.merge(\n",
    "    loads_residential[['Hour', 'residential1', 'residential2', 'residential3', 'residential4','residential5']],\n",
    "    loads_industrial[['Hour', 'industrial1', 'industrial2']]\n",
    ")\n",
    "\n",
    "loads_to_read= [\n",
    "    'residential1',\n",
    "    'residential2',\n",
    "    'residential3',\n",
    "    'residential4',\n",
    "    'residential5',\n",
    "    'industrial1',\n",
    "    'industrial2',\n",
    "]\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "solar_multiples=    [0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5]\n",
    "bess_multiples=     [0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5]\n",
    "bess_capacities=    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "optimise_for=       ['Price', 'CO_2_eq']\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "data_de=    pd.read_csv('Data/data_de.csv', sep= ';', index_col= False)\n",
    "data_es=    pd.read_csv('Data/data_es.csv', sep= ';', index_col= False)\n",
    "data_it=    pd.read_csv('Data/data_it.csv', sep= ';', index_col= False)\n",
    "data_pl=    pd.read_csv('Data/data_pl.csv', sep= ';', index_col= False)\n",
    "data_se=    pd.read_csv('Data/data_se.csv', sep= ';', index_col= False)\n",
    "data_se1=   pd.read_csv('Data/data_se1.csv', sep= ';', index_col= False)\n",
    "data_se2=   pd.read_csv('Data/data_se2.csv', sep= ';', index_col= False)\n",
    "data_se3=   pd.read_csv('Data/data_se3.csv', sep= ';', index_col= False)\n",
    "data_se4=   pd.read_csv('Data/data_se4.csv', sep= ';', index_col= False)\n",
    "\n",
    "data_dict= {\n",
    "    'DE': data_de,\n",
    "    'ES': data_es,\n",
    "    'IT': data_it,\n",
    "    'PL': data_pl,\n",
    "    'SE': data_se,\n",
    "    'SE1': data_se1,\n",
    "    'SE2': data_se2,\n",
    "    'SE3': data_se3,\n",
    "    'SE4': data_se4,\n",
    "}\n",
    "\n",
    "regions= [\n",
    "    'DE',\n",
    "    'ES',\n",
    "    'IT',\n",
    "    'PL',\n",
    "    'SE',\n",
    "    'SE1',\n",
    "    'SE2',\n",
    "    'SE3',\n",
    "    'SE4',\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialising the postprocessor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "start_time= time.time()\n",
    "\n",
    "\n",
    "for bess_capacity in bess_capacities:\n",
    "    for solar_multiple in solar_multiples:\n",
    "        for bess_multiple in bess_multiples:\n",
    "            for load in loads_to_read:\n",
    "                for curve in optimise_for:\n",
    "                    for region in regions:\n",
    "                        try:\n",
    "                            solar_factor= solar_multiple# * 3\n",
    "                            PessCH= bess_multiple# * 3\n",
    "                            EnESS= PessCH * bess_capacity\n",
    "\n",
    "\n",
    "                            profile = (pd.read_csv(f'RESULTS/{curve}_{region}_{load}_{solar_multiple}pv_{bess_multiple}bess_{bess_capacity}hr.csv')).fillna(value= 0)\n",
    "                            profile['P_PV_to_Load']=        profile['P_PV_to_Load'].astype('int')\n",
    "                            profile['P_PV_to_BESS']=        profile['P_PV_to_BESS'].astype('int')\n",
    "                            profile['P_PV_curtailment']=    profile['P_PV_curtailment'].astype('int')\n",
    "                            profile['P_PV_to_Grid']=        profile['P_PV_to_Grid'].astype('int')\n",
    "                            profile['P_BESS_to_Load']=      profile['P_BESS_to_Load'].astype('int')\n",
    "                            profile['P_BESS_to_Grid']=      profile['P_BESS_to_Grid'].astype('int')\n",
    "                            profile['P_Grid_to_Load']=      profile['P_Grid_to_Load'].astype('int')\n",
    "                            profile['P_Grid_to_BESS']=      profile['P_Grid_to_BESS'].astype('int')\n",
    "                            #print(profile.info())\n",
    "\n",
    "                            if curve == 'Price':\n",
    "                                results_econ.loc[len(results_econ)] = (get_KPIs(profile, solar_factor= solar_factor, PessCH= PessCH, EnESS= EnESS, load= load, region= region))\n",
    "                            elif curve == 'CO_2_eq':\n",
    "                                results_env.loc[len(results_env)] = (get_KPIs(profile, solar_factor= solar_factor, PessCH= PessCH, EnESS= EnESS, load= load, region= region))\n",
    "                        except FileNotFoundError:\n",
    "                            continue\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "end_time= time.time()\n",
    "execution_time= end_time - start_time\n",
    "\n",
    "# Convert execution time to hours, minutes, and seconds\n",
    "hours, remainder = divmod(execution_time, 3600)\n",
    "minutes, seconds = divmod(remainder, 60)\n",
    "\n",
    "\n",
    "\n",
    "to_read=(len(loads_to_read) * len(solar_multiples) * len(bess_multiples) * len(bess_capacities) * len(regions) * len(optimise_for))\n",
    "been_read=   (len(results_econ) + len(results_env))\n",
    "# Print the execution time in the format hh:mm:ss\n",
    "print('Postprocessing PaperA-selected dispatch profiles')\n",
    "print(\"Execution time: {:02}:{:02}:{:02}\".format(int(hours), int(minutes), int(seconds)))\n",
    "print(f'Cases to read: {to_read}')\n",
    "print(f'Cases Read: {been_read}')\n",
    "print(f'Scenarios Generated: {100 * round((been_read/to_read), 4)}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "results_econ.to_csv('RESULTS/Results_econ.csv', index= False)\n",
    "results_env.to_csv('RESULTS/Results_env.csv', index= False)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv_PaperB",
   "language": "python",
   "name": "venv_paperb"
  },
  "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.10.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}