Online_Algo_EV_ASAP_real.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from utility import utility as util\n",
    "from utility import utils as utils\n",
    "import yaml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy.random as rand"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "from real_funcOnlineAlgo import create_ev_dict_from_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import latest_deterministic_solver_ev_penetration\n",
    "import generate_expected_EV_values as E_ev_generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ev_data_sampler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_ev_dict(seed):\n",
    "    \n",
    "    rng = np.random.default_rng(seed)\n",
    "\n",
    "    FINAL_SOC = 0.97\n",
    "    ALPHA_C = 11\n",
    "    B_CAP = 80\n",
    "    ETA_C = 0.98\n",
    "\n",
    "    ev_dict = {}\n",
    "    ev_outer_keys = ['init_soc','ev_stay_t','ev_laxity']\n",
    "\n",
    "    for key in ev_outer_keys:\n",
    "        ev_dict[key] = {}\n",
    "\n",
    "    for key in ev_outer_keys:\n",
    "        for h in range(24):\n",
    "            ev_dict[key]['hour_{}'.format(str(h))] = []\n",
    "                 \n",
    "    for hour in range(24):\n",
    "        num_arrived_ev = ev_data_sampler.sample_num_EV_arrivals(rng, hour)\n",
    "\n",
    "        for _ in range(num_arrived_ev):\n",
    "            stay_t = ev_data_sampler.sample_ev_stay_time(rng, hour)\n",
    "            init_soc = ev_data_sampler.sample_init_soc(seed)\n",
    "            seed += 1\n",
    "            depart_time = hour + stay_t\n",
    "            if(depart_time > 23):\n",
    "                depart_time = 23\n",
    "                stay_t = depart_time - hour\n",
    "            laxity = stay_t - (FINAL_SOC - init_soc)*B_CAP/(ALPHA_C * ETA_C)\n",
    "            if(laxity >= 0):\n",
    "                ev_dict['ev_stay_t']['hour_{}'.format(hour)].append(stay_t)\n",
    "                ev_dict['init_soc']['hour_{}'.format(hour)].append(init_soc)\n",
    "                ev_dict['ev_laxity']['hour_{}'.format(hour)].append(laxity)\n",
    "                \n",
    "    return ev_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_forecast_ev_dict(seed, sample_no):\n",
    "    \n",
    "    rng = np.random.default_rng(seed)\n",
    "    ev_rng = np.random.default_rng(seed+sample_no)\n",
    "\n",
    "    \n",
    "    DAY_HRS = 24\n",
    "    FINAL_SOC = 0.97\n",
    "    ALPHA_C = 11\n",
    "    B_CAP = 80\n",
    "    ETA_C = 0.98\n",
    "    NOISE_STD = 0.1\n",
    "\n",
    "    ev_dict = {}\n",
    "    ev_outer_keys = ['init_soc','ev_stay_t','ev_laxity']\n",
    "\n",
    "    for key in ev_outer_keys:\n",
    "        ev_dict[key] = {}\n",
    "\n",
    "    for key in ev_outer_keys:\n",
    "        for h in range(DAY_HRS):\n",
    "            ev_dict[key]['hour_{}'.format(str(h))] = []\n",
    "                 \n",
    "    for hour in range(DAY_HRS):\n",
    "        num_arrived_ev = ev_data_sampler.sample_num_EV_arrivals(rng, hour)\n",
    "        \n",
    "#         print('in forecast ', num_arrived_ev)\n",
    "        \n",
    "        num_arrived_ev_noise = ev_rng.normal(0, (num_arrived_ev*NOISE_STD))\n",
    "        \n",
    "        num_arrived_ev += num_arrived_ev_noise\n",
    "#         if(num_arrived_ev_noise > 0):\n",
    "#             num_arrived_ev = np.ceil(num_arrived_ev)\n",
    "        num_arrived_ev = int(num_arrived_ev)\n",
    "        \n",
    "        if(num_arrived_ev <= 0):\n",
    "            num_arrived_ev = 0\n",
    "        \n",
    "        for _ in range(num_arrived_ev):\n",
    "            stay_t = ev_data_sampler.sample_ev_stay_time(rng, hour)\n",
    "            stay_t_noise = ev_rng.normal(0, (stay_t*NOISE_STD))\n",
    "            stay_t += stay_t_noise\n",
    "            if(stay_t_noise > 0):\n",
    "                stay_t = np.ceil(stay_t)\n",
    "            stay_t = int(stay_t)\n",
    "\n",
    "            \n",
    "            if(stay_t >= (DAY_HRS-1)):\n",
    "                stay_t = DAY_HRS-1\n",
    "            elif(stay_t < 0):\n",
    "                stay_t = 0\n",
    "            \n",
    "            init_soc = ev_data_sampler.sample_init_soc(seed)\n",
    "            init_soc_noise = ev_rng.normal(0, (init_soc*NOISE_STD))\n",
    "            init_soc += init_soc_noise\n",
    "            seed += 1\n",
    "\n",
    "            depart_time = hour + stay_t\n",
    "            if(depart_time > 23):\n",
    "                depart_time = 23\n",
    "                stay_t = depart_time - hour\n",
    "                \n",
    "            if(init_soc >= FINAL_SOC):\n",
    "                init_soc = FINAL_SOC\n",
    "            elif(init_soc < 0):\n",
    "                init_soc = 0\n",
    "                                \n",
    "            laxity = stay_t - (((FINAL_SOC - init_soc)*B_CAP)/(ALPHA_C * ETA_C))\n",
    "            if(laxity >= 0):\n",
    "                ev_dict['ev_stay_t']['hour_{}'.format(hour)].append(stay_t)\n",
    "                ev_dict['init_soc']['hour_{}'.format(hour)].append(init_soc)\n",
    "                ev_dict['ev_laxity']['hour_{}'.format(hour)].append(laxity)\n",
    "                \n",
    "    return ev_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class EV:\n",
    "    \n",
    "    def __init__(self, arrival_time, stay_time, soc_init, laxity):\n",
    "        self.arrival_time = arrival_time\n",
    "        self.stay_time = stay_time\n",
    "        self.departure_time = self.arrival_time + self.stay_time\n",
    "        self.soc_final = 0.97\n",
    "        self.soc_init = soc_init\n",
    "        self.soc_t = soc_init\n",
    "        self.laxity = laxity\n",
    "        self.battery_cap = 80 #kW\n",
    "        self.alpha_c = 11 #kW\n",
    "        self.eta_c = 0.98\n",
    "        self.alpha_d = -11 #kW\n",
    "        self.eta_d = 0.98\n",
    "        self.allow_discharge = False\n",
    "        self.priority_charge = False\n",
    "        self.bool_c_d = False\n",
    "        self.completed = False\n",
    "        self.time_to_full_soc = 0\n",
    "        self.incentive_valuation = 0\n",
    "        self.actual_payback = 0\n",
    "        self.discharge_threshold = 1.25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_connected_ev(ev_dict, hour): \n",
    "    \n",
    "    just_arrived_ev_lst = []\n",
    "\n",
    "    if(len(ev_dict['init_soc']['hour_{}'.format(str(hour))]) != 0):\n",
    "        for ev_num in range(len(ev_dict['init_soc']['hour_{}'.format(str(hour))])):\n",
    "            just_arrived_ev_lst.append(EV(hour,\n",
    "                                         ev_dict['ev_stay_t']['hour_{}'.format(str(hour))][ev_num],\n",
    "                                         ev_dict['init_soc']['hour_{}'.format(str(hour))][ev_num],\n",
    "                                          ev_dict['ev_laxity']['hour_{}'.format(str(hour))][ev_num]\n",
    "                                         ))\n",
    "        return just_arrived_ev_lst\n",
    "    else:\n",
    "        return [-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def surplus_pv_gen(current_time, pv_diff, available_ev_lst, im_price_lst):\n",
    "\n",
    "    imbalance_sell = 0\n",
    "    e_extra = pv_diff\n",
    "    \n",
    "    charge_e_dict = {}\n",
    "\n",
    "    for ev in available_ev_lst:\n",
    "        if(ev.bool_c_d == False and ev.soc_t < ev.soc_final):\n",
    "            charge_e_dict[ev] = ev.laxity\n",
    "\n",
    "\n",
    "    # sort based on ascending order of Laxity. Smaller lax => more urgent to charge!\n",
    "    if(len(charge_e_dict) != 0):\n",
    "        charge_e_dict = sorted(charge_e_dict.items(), key=lambda x: x[1], reverse=False)\n",
    "\n",
    "        for ev in charge_e_dict:\n",
    "            if(e_extra > 0):\n",
    "                e_charging = charge_EV(ev[0], e_extra)\n",
    "                e_extra -= e_charging\n",
    "#                 if(im_price_lst[current_time] > 0):\n",
    "#                     imbalance_sell += e_charging * im_price_lst[current_time]\n",
    "    \n",
    "    # Sell remaining surplus energy to imbalance market after EV charging complete!\n",
    "    if(e_extra > 0 and im_price_lst[current_time] > 0):\n",
    "        imbalance_sell += e_extra  * im_price_lst[current_time]\n",
    "    return imbalance_sell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def charge_EV(ev, e_charging):\n",
    "    \n",
    "    ETA_C = 0.98\n",
    "    \n",
    "    e_required = (ev.soc_final - ev.soc_t) * ev.battery_cap\n",
    "    \n",
    "    if(e_charging >= e_required):\n",
    "        e_charging = e_required\n",
    "        e_required = 0\n",
    "\n",
    "    if(e_charging >= ev.alpha_c):\n",
    "        e_charging = ev.alpha_c\n",
    "    \n",
    "    ev.soc_t =  ev.soc_t + (e_charging*ETA_C)/ev.battery_cap\n",
    "    ev.stay_time -= 1\n",
    "    ev.laxity = ev.stay_time - ((ev.soc_final - ev.soc_t) * ev.battery_cap)/(ev.alpha_c * ETA_C)\n",
    "    if(ev.laxity == 0):\n",
    "        ev.laxity = 0\n",
    "    ev.bool_c_d = True\n",
    "    \n",
    "    return e_charging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def shortage_pv_gen(current_time, pv_diff, available_ev_lst, da_price_lst, im_price_lst):\n",
    "    \n",
    "    imbalance_buy = 0\n",
    "    DISCHRG_THRESH = 0\n",
    "    \n",
    "    e_short = np.abs(pv_diff)\n",
    "\n",
    "    discharge_e_dict = {}\n",
    "    sum_disch_E = 0\n",
    "    \n",
    "    #print(\"BEFOREEE DISCHRGG E-short \", e_short)\n",
    "    \n",
    "    # Obtain the EVs that have POSITIVE LAXITY and ALLOW DISCHARGE\n",
    "    for ev in available_ev_lst:\n",
    "        if(ev.laxity > DISCHRG_THRESH and ev.allow_discharge == True and ev.bool_c_d == False):\n",
    "            # storing the EV obj address in the dict as \"key\" and the available discharge energy as the \"item\"\n",
    "            discharge_e_dict[ev] = get_available_discharge_energy(ev)\n",
    "    #print('discharge_e_dict ', discharge_e_dict)\n",
    "    if(len(discharge_e_dict) != 0):\n",
    "        # Descending sort\n",
    "        discharge_e_dict = sorted(discharge_e_dict.items(), key=lambda x: x[1], reverse=True)\n",
    "\n",
    "        for ev in discharge_e_dict:\n",
    "            sum_disch_E += ev[1]\n",
    "            \n",
    "        e_short_orig = e_short\n",
    "        for ev in discharge_e_dict:\n",
    "            if (e_short > 0 and ev[1] != 0):\n",
    "                if(sum_disch_E > e_short):\n",
    "                    e_discharged = discharge_EV(ev[0], (ev[1]/sum_disch_E)*e_short_orig, e_short)\n",
    "                    #ev[0].dsch_revenue_contrib += e_discharged * im_price_lst[current_time]\n",
    "                else:    \n",
    "                    e_discharged = discharge_EV(ev[0], ev[1], e_short)    \n",
    "                e_short -= e_discharged\n",
    "                #print('EEE_DISCCC ', e_discharged)\n",
    "                #revenue_from_ev_dischrg += e_discharged * im_price_lst[current_time]\n",
    "        \n",
    "        #print('SSORRRTT ',e_short)\n",
    "    return e_short\n",
    "\n",
    "\n",
    "def get_available_discharge_energy(ev):\n",
    "    \n",
    "    e_required = (ev.soc_final - ev.soc_t) * ev.battery_cap\n",
    "    look_ahead_e_required = ev.alpha_c * ev.eta_c * (ev.stay_time - 1)\n",
    "    e_discharge = look_ahead_e_required - e_required\n",
    "    \n",
    "    if(e_discharge < 0):\n",
    "        e_discharge = 0\n",
    "        \n",
    "    elif(e_discharge >= np.abs(ev.alpha_d)):\n",
    "        e_discharge = np.abs(ev.alpha_d)\n",
    "    \n",
    "    return e_discharge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def discharge_EV(ev, e_discharge_available, e_short):\n",
    "    \n",
    "    ETA_D = 0.98\n",
    "    \n",
    "    if(e_discharge_available > np.abs(ev.alpha_d)):\n",
    "        e_discharge_available = np.abs(ev.alpha_d)\n",
    "    elif(e_discharge_available <= 0):\n",
    "        e_discharge_available = 0\n",
    "    \n",
    "#     if(e_discharge_available != 0):       \n",
    "#         if(e_short <= e_discharge_available):\n",
    "#             e_discharge_available = e_short\n",
    "#             e_short = 0\n",
    "#         else:\n",
    "#             e_short -= e_discharge_available\n",
    "\n",
    "        ev.soc_t = ev.soc_t - (e_discharge_available/ETA_D)/ev.battery_cap\n",
    "        ev.stay_time -= 1\n",
    "        ev.laxity = ev.stay_time - ((ev.soc_final - ev.soc_t) * ev.battery_cap)/(ev.alpha_c * ETA_C)\n",
    "        \n",
    "        if(ev.laxity == 0):\n",
    "            ev.laxity = 0\n",
    "        ev.bool_c_d = True\n",
    "        \n",
    "    return e_discharge_available"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_ev_dict_allowed_discharge_evs(seed, ev_dict, ratio):\n",
    "        \n",
    "    rng = np.random.default_rng(seed)\n",
    "    \n",
    "    total_evs = 0\n",
    "    for h in range(24):\n",
    "        total_evs += len(ev_dict['init_soc']['hour_{}'.format(str(h))])\n",
    "    \n",
    "    ev_allowed_discharge = rng.choice(total_evs, size=round(total_evs*(ratio/100)), replace=False)\n",
    "    \n",
    "    ev_dict['ev_allowed_discharge'] = ev_allowed_discharge\n",
    "    return ev_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def solve_stage_1_w_expected_vals(seed, date, ratio_EV_discharge):\n",
    "    \n",
    "    m = date.month\n",
    "    \n",
    "    if(m >= 1 and m <= 3):\n",
    "        season = 'Winter'\n",
    "    elif(m >= 4 and m <= 6):\n",
    "        season = 'Spring'\n",
    "    elif(m >= 7 and m <= 9):\n",
    "        season = 'Summer'  \n",
    "    elif(m >= 10 and m <= 12):\n",
    "        season = 'Autumn' \n",
    "         \n",
    "    E_PV_gen = util.load_result(r'J:\\Thesis_code\\thesis_code_saidur\\Thesis Code August 2021\\new_expected_values\\E_PV_{}'.format(season))\n",
    "    E_im_price = util.load_result(r'J:\\Thesis_code\\thesis_code_saidur\\Thesis Code August 2021\\new_expected_values\\E_price_imbalance')\n",
    "    E_da_price = util.load_result(r'J:\\Thesis_code\\thesis_code_saidur\\Thesis Code August 2021\\new_expected_values\\E_price_da')\n",
    "    E_EV_dict = util.load_result(r'J:\\Thesis_code\\thesis_code_saidur\\Thesis Code August 2021\\new_expected_values\\E_EV_dict')\n",
    "    \n",
    "    _, bids, _ = latest_deterministic_solver_ev_penetration.main(seed, E_PV_gen, E_da_price, E_im_price, E_EV_dict, ratio_EV_discharge)\n",
    "    \n",
    "    return bids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_online_alg_result_mc_simul(seed, day_no, current_date, unique_dates, sampling_unique_dates, orig_ev_dict, ratio_EV_discharge, pv_gen_df, price_df, sampling_pv_gen_df, sampling_price_df, num_samples, all_bids_sample_paths):\n",
    "\n",
    "    # ++++++++++++++++++++++++++++++++++++++++++++++++ STAGE - 1 ++++++++++++++++++++++++++++++++++++++++++\n",
    "    \n",
    "    # Load the cached bids using forecasts for stochastic vals.\n",
    "    \n",
    "    #all_bids_sample_paths = util.load_result(('hist_mc_sample_paths/{}_perc'.format(ratio_EV_discharge)+'/bid_sample_path_'+str(ratio_EV_discharge)+'_perc'))   \n",
    "    \n",
    "    #using 1K\n",
    "    #all_bids_sample_paths = util.load_result('sample_path_1K/hist_mc_sample_paths/{}_perc'.format(ratio_EV_discharge)+'/bid_sample_path_'+str(ratio_EV_discharge)+'_perc')\n",
    "    \n",
    "    # ++++++++++++++++++++++++++++++++++++++++++++++++ STAGE - 2 ++++++++++++++++++++++++++++++++++++++++++\n",
    "    # Using actual data for online algorithm\n",
    "    \n",
    "    DAY_HRS = 24\n",
    "    \n",
    "    revenue_sample_paths = []\n",
    "    im_buy_sample_paths = []\n",
    "    im_sell_sample_paths = []\n",
    "    da_revenue_sample_paths = []\n",
    "    retail_revenue_sample_paths = []\n",
    "\n",
    "    time_to_soc_sample_paths = []\n",
    "        \n",
    "    for b in range(1):\n",
    "    \n",
    "        #bids = np.mean(np.array(all_bids_sample_paths)[day_no][0:100], axis=0)\n",
    "        \n",
    "        bids = np.mean(all_bids_sample_paths[day_no][0:num_samples], axis=0)\n",
    "\n",
    "        da_revenue_lst =  np.zeros(DAY_HRS)\n",
    "        retail_revenue_lst = np.zeros(DAY_HRS)\n",
    "        imbalance_buy_lst = np.zeros(DAY_HRS)\n",
    "        imbalance_sell_lst = np.zeros(DAY_HRS)\n",
    "\n",
    "        revenue_lst = np.zeros(DAY_HRS)\n",
    "\n",
    "        #_, bids = perform_monte_carlo_simul(seed, date, unique_dates, ratio_EV_discharge, pv_gen_df, price_df)\n",
    "        ev_dict = update_ev_dict_allowed_discharge_evs(seed, orig_ev_dict, ratio_EV_discharge)\n",
    "\n",
    "        available_ev_lst = []\n",
    "        ev_history_lst = []\n",
    "        avg_time_to_full_soc = []\n",
    "\n",
    "        pv_gen_lst = np.array(list(pv_gen_df.loc[(pv_gen_df.index == current_date)]['PV_Vol']))\n",
    "        \n",
    "        # We do not consider solar gen. so setting it to ZERO\n",
    "        # ==========================================================================\n",
    "        #  FIRST CHANGE\n",
    "        # ==========================================================================\n",
    "        pv_gen_lst = pv_gen_lst * np.zeros(DAY_HRS)\n",
    "        \n",
    "        da_price_lst = np.array(list(price_df.loc[(price_df.index == current_date)]['price_da']))\n",
    "        im_price_lst = np.array(list(price_df.loc[(price_df.index == current_date)]['price_imbalance']))\n",
    "    \n",
    "    \n",
    "        for idx, p in enumerate(im_price_lst):\n",
    "            if p < 0:\n",
    "                im_price_lst[idx] = 0\n",
    "    \n",
    "    \n",
    "        for idx, p in enumerate(da_price_lst):\n",
    "            if p < 0:\n",
    "                da_price_lst[idx] = 0\n",
    "    \n",
    "        for current_time in range(DAY_HRS):\n",
    "\n",
    "            revenue = 0\n",
    "            da_revenue = 0\n",
    "            im_buy_revenue = 0\n",
    "            im_sell_revenue = 0\n",
    "            retail_revenue = 0\n",
    "\n",
    "            # Get the EVs\n",
    "            found_evs_lst = get_connected_ev(ev_dict, current_time)\n",
    "\n",
    "            # Form available_ev_lst\n",
    "            if(found_evs_lst[0] != -1):\n",
    "                for found_ev in found_evs_lst:\n",
    "                    ev_history_lst.append(found_ev)\n",
    "                    if(ev_history_lst.index(found_ev) in ev_dict['ev_allowed_discharge']):\n",
    "                        found_ev.allow_discharge = True\n",
    "                    else:\n",
    "                        found_ev.allow_discharge = False    \n",
    "                    available_ev_lst.append(found_ev)\n",
    "\n",
    "            # Find EVs with Low laxity\n",
    "            ac_lst = []\n",
    "            for ev in available_ev_lst:\n",
    "                ev.bool_c_d = False #Reset for all EVs on every hour\n",
    "                if(current_time >= ev.departure_time or ev.stay_time == 0 or ev.soc_t >= ev.soc_final):\n",
    "                    ev.bool_c_d = True\n",
    "                    ev.completed = True\n",
    "                elif(ev.soc_t < ev.soc_final): #if(round(ev.soc_t,2) != ev.soc_final):\n",
    "                    ac_lst.append(charge_EV(ev, ev.alpha_c))\n",
    "\n",
    "            # Total charging demand\n",
    "            x_t = np.array(bids[current_time]) + np.sum(np.array(ac_lst))\n",
    "\n",
    "            bid_amt = np.array(bids[current_time])\n",
    "            total_chrg_demand =  np.sum(np.array(ac_lst))\n",
    "\n",
    "    #         im_buy_revenue += (-1 * total_chrg_demand * im_price_lst[current_time])\n",
    "            da_revenue += bid_amt * da_price_lst[current_time]\n",
    "            \n",
    "            # Adding the revenue by getting money from EV owners for charging their batteries\n",
    "            EV_PWR_RETAIL = 0.13\n",
    "            \n",
    "            retail_revenue += total_chrg_demand * EV_PWR_RETAIL\n",
    "            #da_revenue += total_chrg_demand * EV_PWR_RETAIL\n",
    "\n",
    "            # Get the surplus/deficit   \n",
    "#             if(pv_gen_lst[current_time] >= x_t):\n",
    "#                 # Surplus\n",
    "#                 pv_diff = pv_gen_lst[current_time] - x_t\n",
    "#                 im_sell_revenue += surplus_pv_gen(current_time, pv_diff, available_ev_lst, im_price_lst)\n",
    "\n",
    "\n",
    "#             elif (x_t > pv_gen_lst[current_time]):\n",
    "#                 # Deficit\n",
    "#                 pv_diff = pv_gen_lst[current_time] - x_t\n",
    "#                 e_short = shortage_pv_gen(current_time, pv_diff, available_ev_lst, da_price_lst, im_price_lst)\n",
    "#                 if(e_short > 0):\n",
    "#                     im_buy_revenue += -1 * e_short * im_price_lst[current_time]\n",
    "#                 e_short = 0\n",
    "                \n",
    "            # Get the surplus/deficit  \n",
    "            # NEW for the case W/0 SOLAR\n",
    "            # ==========================================================================\n",
    "            #  THIRD CHANGE\n",
    "            # ==========================================================================\n",
    "            if (x_t < 0):\n",
    "                # Surplus\n",
    "                im_sell_revenue += -1 * x_t * im_price_lst[current_time] #surplus_pv_gen(current_time, pv_diff, available_ev_lst, im_price_lst)\n",
    "                x_t = 0\n",
    "\n",
    "            elif (x_t > 0):\n",
    "                # Deficit\n",
    "                im_buy_revenue += -1 * x_t * im_price_lst[current_time]\n",
    "                x_t = 0\n",
    "\n",
    "\n",
    "            revenue = da_revenue + im_sell_revenue + im_buy_revenue + retail_revenue\n",
    "\n",
    "            revenue_lst[current_time] = revenue\n",
    "            da_revenue_lst[current_time] = da_revenue\n",
    "            imbalance_buy_lst[current_time] = im_buy_revenue\n",
    "            imbalance_sell_lst[current_time] = im_sell_revenue\n",
    "            retail_revenue_lst[current_time] = retail_revenue\n",
    "\n",
    "\n",
    "            for ev in available_ev_lst:                   \n",
    "                if(ev.bool_c_d == False):\n",
    "                    # For EVs not charged or discharged, ONLY Laxity update\n",
    "                    e_required = (ev.soc_final - ev.soc_t) * ev.battery_cap\n",
    "                    ev.stay_time -= 1 \n",
    "                    ev.laxity = ev.stay_time - (e_required/(ev.alpha_c * ev.eta_c))    \n",
    "\n",
    "\n",
    "            for ev in available_ev_lst: \n",
    "                if(current_time == ev.departure_time or ev.soc_t >= ev.soc_final or ev.stay_time == 0):\n",
    "                    if(ev.completed == False):\n",
    "                        avg_time_to_full_soc.append(1+(current_time - ev.arrival_time))\n",
    "                    ev.completed = True\n",
    "                    ev.bool_c_d = True\n",
    "            \n",
    "        revenue_sample_paths.append(np.sum(revenue_lst))\n",
    "        im_buy_sample_paths.append(np.sum(imbalance_buy_lst))\n",
    "        im_sell_sample_paths.append(np.sum(imbalance_sell_lst))\n",
    "        da_revenue_sample_paths.append(np.sum(da_revenue_lst))\n",
    "        retail_revenue_sample_paths.append(np.sum(retail_revenue_lst))\n",
    "        time_to_soc_sample_paths.append(0)\n",
    "                        \n",
    "    return np.average(revenue_sample_paths), np.average(im_buy_sample_paths), np.average(im_sell_sample_paths), np.average(time_to_soc_sample_paths), np.average(da_revenue_sample_paths), np.average(retail_revenue_sample_paths)\n",
    "    #return np.sum(revenue_lst), np.sum(imbalance_buy_lst), np.sum(imbalance_sell_lst), np.mean(avg_time_to_full_soc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# def get_online_alg_result_acc_preds(seed, day_no, date, ratio_EV_discharge, pv_gen_lst, da_price_lst, im_price_lst, orig_ev_dict, use_expected_stage_1):\n",
    "\n",
    "    \n",
    "#     # ++++++++++++++++++++++++++++++++++++++++++++++++ STAGE - 1 ++++++++++++++++++++++++++++++++++++++++++\n",
    "        \n",
    "#     DAY_HRS = 24\n",
    "\n",
    "#     da_revenue_lst =  np.zeros(DAY_HRS)\n",
    "#     imbalance_buy_lst = np.zeros(DAY_HRS)\n",
    "#     imbalance_sell_lst = np.zeros(DAY_HRS)\n",
    "    \n",
    "#     revenue_lst = np.zeros(DAY_HRS)    \n",
    "#  #     all_bids_lst = util.load_result(('hist_acc_bids/{}_perc'.format(ratio_EV_discharge)+'/accurate_bid_'+str(ratio_EV_discharge)+'_perc'))        \n",
    "# #     bids = all_bids_lst[day_no]\n",
    "    \n",
    "# #     ev_dict = update_ev_dict_allowed_discharge_evs(seed, orig_ev_dict, ratio_EV_discharge)\n",
    "\n",
    "#     if(use_expected_stage_1 == True):\n",
    "#     # Using Expected values to place bids\n",
    "#         bids = solve_stage_1_w_expected_vals(seed, date, ratio_EV_discharge)\n",
    "#         ev_dict = update_ev_dict_allowed_discharge_evs(seed, ev_dict, ratio_EV_discharge)\n",
    "#     else:\n",
    "#     # Using Actual values to place bids\n",
    "#         _, bids, ev_dict = latest_deterministic_solver_ev_penetration.main(seed, pv_gen_lst, da_price_lst, im_price_lst, orig_ev_dict, ratio_EV_discharge)\n",
    " \n",
    "#     # ++++++++++++++++++++++++++++++++++++++++++++++++ STAGE - 2 ++++++++++++++++++++++++++++++++++++++++++\n",
    "#     # Using actual data for online algorithm\n",
    "    \n",
    "#     available_ev_lst = []\n",
    "#     ev_history_lst = []\n",
    "#     avg_time_to_full_soc = []\n",
    "    \n",
    "#     for current_time in range(DAY_HRS):\n",
    "\n",
    "#         revenue = 0\n",
    "#         da_revenue = 0\n",
    "#         im_buy_revenue = 0\n",
    "#         im_sell_revenue = 0\n",
    "\n",
    "#         # Get the EVs\n",
    "#         found_evs_lst = get_connected_ev(ev_dict, current_time)\n",
    "                \n",
    "#         # Form available_ev_lst\n",
    "#         if(found_evs_lst[0] != -1):\n",
    "#             for found_ev in found_evs_lst:\n",
    "#                 ev_history_lst.append(found_ev)\n",
    "#                 if(ev_history_lst.index(found_ev) in ev_dict['ev_allowed_discharge']):\n",
    "#                     found_ev.allow_discharge = True\n",
    "#                 else:\n",
    "#                     found_ev.allow_discharge = False    \n",
    "#                 available_ev_lst.append(found_ev)\n",
    "                             \n",
    "#         # Find EVs with Low laxity\n",
    "#         ac_lst = []\n",
    "#         for ev in available_ev_lst:\n",
    "#             ev.bool_c_d = False #Reset for all EVs on every hour\n",
    "#             if(current_time >= ev.departure_time or ev.stay_time == 0 or ev.soc_t >= ev.soc_final):\n",
    "#                 ev.bool_c_d = True\n",
    "#                 ev.completed = True\n",
    "#             elif(ev.soc_t < ev.soc_final): #if(round(ev.soc_t,2) != ev.soc_final):\n",
    "#                 ac_lst.append(charge_EV(ev, ev.alpha_c))\n",
    "\n",
    "#         # Total charging demand\n",
    "#         x_t = np.array(bids[current_time]) + np.sum(np.array(ac_lst))\n",
    "\n",
    "#         bid_amt = np.array(bids[current_time])\n",
    "#         total_chrg_demand =  np.sum(np.array(ac_lst))\n",
    "        \n",
    "# #         im_buy_revenue += (-1 * total_chrg_demand * im_price_lst[current_time])\n",
    "#         da_revenue += bid_amt * da_price_lst[current_time]\n",
    "        \n",
    "#         # Get the surplus/deficit   \n",
    "#         if(pv_gen_lst[current_time] >= x_t):\n",
    "#             # Surplus\n",
    "#             pv_diff = pv_gen_lst[current_time] - x_t\n",
    "#             im_sell_revenue += surplus_pv_gen(current_time, pv_diff, available_ev_lst, im_price_lst)\n",
    "                            \n",
    "            \n",
    "#         elif (x_t > pv_gen_lst[current_time]):\n",
    "#             # Deficit\n",
    "#             pv_diff = pv_gen_lst[current_time] - x_t\n",
    "#             e_short = shortage_pv_gen(current_time, pv_diff, available_ev_lst, da_price_lst, im_price_lst)\n",
    "#             if(e_short > 0):\n",
    "#                 im_buy_revenue += -1 * e_short * im_price_lst[current_time]\n",
    "#             e_short = 0\n",
    "        \n",
    "\n",
    "#         revenue = da_revenue + im_sell_revenue + im_buy_revenue\n",
    "         \n",
    "#         revenue_lst[current_time] = revenue\n",
    "#         da_revenue_lst[current_time] = da_revenue\n",
    "#         imbalance_buy_lst[current_time] = im_buy_revenue\n",
    "#         imbalance_sell_lst[current_time] = im_sell_revenue\n",
    "        \n",
    " #         for ev in available_ev_lst:                   \n",
    "#             if(ev.bool_c_d == False):\n",
    "#                 # For EVs not charged or discharged, ONLY Laxity update\n",
    "#                 e_required = (ev.soc_final - ev.soc_t) * ev.battery_cap\n",
    "#                 ev.stay_time -= 1 \n",
    "#                 ev.laxity = ev.stay_time - (e_required/(ev.alpha_c * ev.eta_c))    \n",
    "    \n",
    "    \n",
    "#         for ev in available_ev_lst: \n",
    "#             if(current_time == ev.departure_time or ev.soc_t >= ev.soc_final or ev.stay_time == 0):\n",
    "# #                 print(\"Done mama wot SoC \", ev.soc_t)\n",
    "# #                 print('Removed the ev with dept time ', ev.departure_time)\n",
    "#                 if(ev.completed == False):\n",
    "#                     avg_time_to_full_soc.append(1+(current_time - ev.arrival_time))\n",
    "# #                     print(\"TIME TAKEN TO SOC MAMA \", (1+(current_time - ev.arrival_time)))\n",
    "#                 ev.completed = True\n",
    "#                 ev.bool_c_d = True\n",
    "                        \n",
    "\n",
    "#     return np.sum(revenue_lst), np.sum(imbalance_buy_lst), np.sum(imbalance_sell_lst), np.mean(avg_time_to_full_soc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████| 365/365 [00:06<00:00, 54.25it/s]\n"
     ]
    }
   ],
   "source": [
    "sampling_pv_gen_df = pd.read_csv('sampling_pv_data.csv', index_col='Date')\n",
    "sampling_pv_gen_df.index = pd.to_datetime(sampling_pv_gen_df.index)\n",
    "\n",
    "# Javier chages to 2019\n",
    "pv_gen_test_df = pd.read_csv('real_data/2019_test_data_pv.csv', index_col='Date')\n",
    "pv_gen_test_df.index = pd.to_datetime(pv_gen_test_df.index)\n",
    "\n",
    "sampling_price_df = pd.read_csv('sampling_price_data.csv', index_col='Date')\n",
    "sampling_price_df.index = pd.to_datetime(sampling_price_df.index)\n",
    "\n",
    "# Javier changes to 2019\n",
    "price_test_df = pd.read_csv('real_data/2019_test_data_price.csv', index_col='Date')\n",
    "price_test_df.index = pd.to_datetime(price_test_df.index)\n",
    "\n",
    "# Javier df_ev\n",
    "df_ev = pd.read_csv(\"real_data/df_elaad_preproc.csv\", parse_dates = [\"starttime_parking\", \"endtime_parking\"])\n",
    "\n",
    "\n",
    "\n",
    "unique_dates = pv_gen_test_df.index.unique()\n",
    "sampling_unique_dates = sampling_pv_gen_df.index.unique()\n",
    "\n",
    "baseline_revenue_dict = {}\n",
    "online_algo_revenue_dict = {}\n",
    "\n",
    "seed_lst = [777]\n",
    "perc_allow_EV_discharge = [0]\n",
    "#perc_allow_EV_discharge = [0]\n",
    "\n",
    "for perc in (perc_allow_EV_discharge):\n",
    "\n",
    "    baseline_revenue_dict = {}\n",
    "    online_algo_revenue_dict = {}\n",
    "    \n",
    "    #all_bids_sample_paths = util.load_result(('hist_mc_sample_paths/{}_perc'.format(perc)+'/bid_sample_path_'+str(perc)+'_perc'))   \n",
    "    \n",
    "    all_bids_sample_paths = util.load_result(('bids_no_solar_2019/{}_perc'.format(perc)+'/bid_sample_path_'+str(perc)+'_perc'))\n",
    "    \n",
    "    #using 1K    \n",
    "    #all_bids_sample_paths = np.array(util.load_result('sample_path_1K/hist_mc_sample_paths/{}_perc'.format(perc)+'/bid_sample_path_'+str(perc)+'_perc'))\n",
    "\n",
    "    \n",
    "    \n",
    "    #for num_samples in range(105, 305, 5):\n",
    "    for _ in range(1):\n",
    "        \n",
    "        num_samples = 100\n",
    "\n",
    "        for run, seed in enumerate(seed_lst):\n",
    "            baseline_revenue_lst = []\n",
    "\n",
    "            total_revenue_lst_E_stage_1 = []\n",
    "            im_buy_revenue_lst_E_stage_1 = []\n",
    "            im_sell_revenue_lst_E_stage_1 = []\n",
    "            time_to_full_soc_lst_E_stage_1 = []\n",
    "            da_revenue_lst_E_stage1 = [] \n",
    "            retail_revenue_lst_E_stage1 = []\n",
    "\n",
    "            total_revenue_lst_R_stage_1 = []\n",
    "            im_buy_revenue_lst_R_stage_1 = []\n",
    "            im_sell_revenue_lst_R_stage_1 = []\n",
    "            time_to_full_soc_lst_R_stage_1 = []\n",
    "            \n",
    "            for day_no, date in enumerate(tqdm(unique_dates, total=len(unique_dates))):\n",
    "\n",
    "                pv_gen_lst = np.array(list(pv_gen_test_df.loc[(pv_gen_test_df.index == date)]['PV_Vol']))\n",
    "                da_price_lst = np.array(list(price_test_df.loc[(price_test_df.index == date)]['price_da']))\n",
    "                im_price_lst = (np.array(list(price_test_df.loc[(price_test_df.index == date)]['price_imbalance'])))\n",
    "\n",
    "                for idx, p in enumerate(im_price_lst):\n",
    "                    if p < 0:\n",
    "                        im_price_lst[idx] = 0\n",
    "\n",
    "\n",
    "                for idx, p in enumerate(da_price_lst):\n",
    "                    if p < 0:\n",
    "                        da_price_lst[idx] = 0\n",
    "                        \n",
    "                #ev_dict = create_ev_dict(seed+run)\n",
    "                ev_dict = create_ev_dict_from_df(df_ev, day_no)\n",
    "\n",
    "                # ONLY IF YOU NEED TO RUN THE OFFLINE ALG\n",
    "#                 _, bids, _ = latest_deterministic_solver_ev_penetration.main(seed+run, pv_gen_lst, da_price_lst, im_price_lst, ev_dict, perc)\n",
    "#                 baseline_revenue_lst.append(bids)\n",
    "\n",
    "                # Using Monte Carlo simulation results\n",
    "                total, im_buy, im_sell, time_to_full_soc, da_revenue, retail_revenue = get_online_alg_result_mc_simul(seed+run, day_no, date, unique_dates, sampling_unique_dates, ev_dict, perc, pv_gen_test_df, price_test_df, sampling_pv_gen_df, sampling_price_df, num_samples, all_bids_sample_paths)\n",
    "                total_revenue_lst_E_stage_1.append(total)\n",
    "                im_buy_revenue_lst_E_stage_1.append(im_buy)\n",
    "                im_sell_revenue_lst_E_stage_1.append(im_sell)\n",
    "                time_to_full_soc_lst_E_stage_1.append(time_to_full_soc)\n",
    "                da_revenue_lst_E_stage1.append(da_revenue)\n",
    "                retail_revenue_lst_E_stage1.append(retail_revenue)\n",
    "\n",
    "\n",
    "                # Using accurate predictions\n",
    "#                 total, im_buy, im_sell, time_to_full_soc = get_online_alg_result_acc_preds(seed+run, day_no,  date, perc, pv_gen_lst, da_price_lst, im_price_lst, ev_dict, False)\n",
    "#                 total_revenue_lst_R_stage_1.append(total)\n",
    "#                 im_buy_revenue_lst_R_stage_1.append(im_buy)\n",
    "#                 im_sell_revenue_lst_R_stage_1.append(im_sell)\n",
    "#                 time_to_full_soc_lst_R_stage_1.append(time_to_full_soc)\n",
    "\n",
    "                seed += 10000\n",
    "\n",
    "            #baseline_revenue_dict[str(perc)] = baseline_revenue_lst\n",
    "\n",
    "            online_algo_revenue_dict['total_revenue_'+str(perc)+'_samples_'+str(num_samples)+'_E'] = total_revenue_lst_E_stage_1\n",
    "            online_algo_revenue_dict['im_buy_'+str(perc)+'_samples_'+str(num_samples)+'_E'] = im_buy_revenue_lst_E_stage_1\n",
    "            online_algo_revenue_dict['im_sell_'+str(perc)+'_samples_'+str(num_samples)+'_E'] = im_sell_revenue_lst_E_stage_1\n",
    "            online_algo_revenue_dict['time_to_full_soc_'+str(perc)+'_samples_'+str(num_samples)+'_E'] = time_to_full_soc_lst_E_stage_1\n",
    "            \n",
    "            online_algo_revenue_dict[\"da_revenue\"+str(perc)+\"_samples_\"+str(num_samples)+\"_E\"]  =    da_revenue_lst_E_stage1\n",
    "            online_algo_revenue_dict[\"retail_revenue\"+str(perc)+\"_samples_\"+str(num_samples)+\"_E\"] = retail_revenue_lst_E_stage1\n",
    "\n",
    "\n",
    "#             online_algo_revenue_dict['total_revenue_'+str(perc)+'_samples_'+str(num_samples)+'_R'] = total_revenue_lst_R_stage_1\n",
    "#             online_algo_revenue_dict['im_buy_'+str(perc)+'_samples_'+str(num_samples)+'_R'] = im_buy_revenue_lst_R_stage_1\n",
    "#             online_algo_revenue_dict['im_sell_'+str(perc)+'_samples_'+str(num_samples)+'_R'] = im_sell_revenue_lst_R_stage_1\n",
    "#             online_algo_revenue_dict['time_to_full_soc_'+str(perc)+'_samples_'+str(num_samples)+'_R'] = time_to_full_soc_lst_R_stage_1\n",
    "\n",
    "#     util.save_result('w_mc_results/baseline_bids_'+str(perc),baseline_revenue_dict)\n",
    "#     util.save_result('w_mc_results/mama_1K/online_algo_revenue_ev_asap_'+str(perc),online_algo_revenue_dict)\n",
    "    util.save_result('w_mc_results/contract_no_solar/ev_asap_contract_revenue_allBidrealEV_'+str(perc),online_algo_revenue_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'vbcvbcvbc' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_306557/3643140288.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mvbcvbcvbc\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'vbcvbcvbc' is not defined"
     ]
    }
   ],
   "source": [
    "vbcvbcvbc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "price_test_df = pd.read_csv('new_data/new_test_data_price.csv', index_col='Date')\n",
    "price_test_df.index = pd.to_datetime(price_test_df.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "price_test_df['price_imbalance']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.percentile(price_test_df['price_imbalance'], 95)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "perc = 0\n",
    "\n",
    "np.cumsum(util.load_result('w_mc_results/contract_no_solar/ev_asap_contract_revenue_{}'.format(perc))['total_revenue_{}_samples_100_E'.format(perc)])[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "perc = 100\n",
    "\n",
    "print(np.cumsum(util.load_result('w_mc_results/contract_no_solar/tau_1_contract_online_algo_revenue_original_{}'.format(perc))['total_revenue_{}_run0_E'.format(perc)])[-1])\n",
    "\n",
    "print(np.cumsum(util.load_result('w_mc_results/contract_no_solar/tau_3_contract_online_algo_revenue_original_{}'.format(perc))['total_revenue_{}_run0_E'.format(perc)])[-1])\n",
    "\n",
    "#np.cumsum(util.load_result('w_mc_results/contract_no_solar/tau_3_contract_online_algo_revenue_original_{}'.format(perc))['total_revenue_{}_run0_E'.format(perc)])[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "revenue_sample_dict = {}\n",
    "\n",
    "for s in range(105, 205, 5):    \n",
    "    revenue_sample_dict[str(s)] = np.cumsum(util.load_result('w_mc_results/mama_1K/online_algo_revenue_ev_asap_0')['total_revenue_0_samples_{}_E'.format(s)])[-1]\n",
    "plt.plot(revenue_sample_dict.keys(), [0] + list(np.diff(list(revenue_sample_dict.values()))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "fig = plt.gcf()\n",
    "fig.set_size_inches(20, 16)\n",
    "fig.use_sticky_edges = True\n",
    "plt.tight_layout()\n",
    "\n",
    "revenue_sample_dict = {}\n",
    "\n",
    "for s in range(5, 105, 5):    \n",
    "    revenue_sample_dict[str(s)] = np.cumsum(util.load_result('w_mc_results/mama/online_algo_revenue_ev_asap_0')['total_revenue_0_samples_{}_E'.format(s)])[-1]\n",
    "plt.plot(revenue_sample_dict.keys(), [0] + list(np.diff(list(revenue_sample_dict.values()))))\n",
    "\n",
    "revenue_sample_dict = {}\n",
    "\n",
    "for s in range(105, 205, 5):    \n",
    "    revenue_sample_dict[str(s)] = np.cumsum(util.load_result('w_mc_results/mama_1K/online_algo_revenue_ev_asap_0')['total_revenue_0_samples_{}_E'.format(s)])[-1]\n",
    "plt.plot(revenue_sample_dict.keys(), [0] + list(np.diff(list(revenue_sample_dict.values()))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "sdfsdfs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "util.load_result('w_mc_results/mama_1K/online_algo_revenue_ev_asap_0').keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "util.load_result('w_mc_results/mama/online_algo_revenue_ev_asap_0').keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "revenue_sample_dict = {}\n",
    "for s in range(5, 105, 5):\n",
    "    revenue_sample_dict[str(s)] = np.cumsum(util.load_result('w_mc_results/mama/online_algo_revenue_ev_asap_0')['total_revenue_0_samples_{}_E'.format(s)])[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(revenue_sample_dict.keys(), revenue_sample_dict.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "revenue_sample_dict = {}\n",
    "\n",
    "for s in range(5, 105, 5):    \n",
    "    revenue_sample_dict[str(s)] = np.cumsum(util.load_result('w_mc_results/mama/online_algo_revenue_ev_asap_0')['total_revenue_0_samples_{}_E'.format(s)])[-1]\n",
    "plt.plot(revenue_sample_dict.keys(), [0] + list(np.diff(list(revenue_sample_dict.values()))))\n",
    "\n",
    "revenue_sample_dict = {}\n",
    "\n",
    "for s in range(5, 105, 5):    \n",
    "    revenue_sample_dict[str(s)] = np.cumsum(util.load_result('w_mc_results/mama/online_algo_revenue_ev_asap_25')['total_revenue_25_samples_{}_E'.format(s)])[-1]\n",
    "plt.plot(revenue_sample_dict.keys(), [0] + list(np.diff(list(revenue_sample_dict.values()))))\n",
    "\n",
    "\n",
    "revenue_sample_dict = {}\n",
    "\n",
    "for s in range(5, 105, 5):    \n",
    "    revenue_sample_dict[str(s)] = np.cumsum(util.load_result('w_mc_results/mama/online_algo_revenue_ev_asap_50')['total_revenue_50_samples_{}_E'.format(s)])[-1]\n",
    "plt.plot(revenue_sample_dict.keys(), [0] + list(np.diff(list(revenue_sample_dict.values()))))\n",
    "\n",
    "\n",
    "revenue_sample_dict = {}\n",
    "\n",
    "for s in range(5, 105, 5):    \n",
    "    revenue_sample_dict[str(s)] = np.cumsum(util.load_result('w_mc_results/mama/online_algo_revenue_ev_asap_75')['total_revenue_75_samples_{}_E'.format(s)])[-1]\n",
    "plt.plot(revenue_sample_dict.keys(), [0] + list(np.diff(list(revenue_sample_dict.values()))))\n",
    "\n",
    "\n",
    "revenue_sample_dict = {}\n",
    "\n",
    "for s in range(5, 105, 5):    \n",
    "    revenue_sample_dict[str(s)] = np.cumsum(util.load_result('w_mc_results/mama/online_algo_revenue_ev_asap_100')['total_revenue_100_samples_{}_E'.format(s)])[-1]\n",
    "plt.plot(revenue_sample_dict.keys(), [0] + list(np.diff(list(revenue_sample_dict.values()))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hjgfckjfvkhj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#util.load_result('w_mc_results/online_algo_revenue_original_50')\n",
    "\n",
    "ev_asap_E_revenue_lst = []\n",
    "ev_asap_R_revenue_lst = []\n",
    "\n",
    "for p in [0]:\n",
    "\n",
    "    total = np.array(util.load_result('w_mc_results/mama/neg_sample_online_algo_revenue_ev_asap_{}'.format(p))['total_revenue_{}_run0_E'.format(p)])\n",
    "    ev_asap_E_revenue_lst.append(np.cumsum(total)[-1])\n",
    "    total = np.array(util.load_result('w_mc_results/neg_sample_online_algo_revenue_ev_asap_{}'.format(p))['total_revenue_{}_run0_R'.format(p)])\n",
    "    ev_asap_R_revenue_lst.append(np.cumsum(total)[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "util.load_result('from_snowball/june_22/safe_rl/mc_sample_SAC_RL_result_test_0')['revenue_reward']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "util.load_result('from_snowball/june_22/safe_rl/mc_sample_SAC_RL_result_train_100')['mean_rewards']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.cumsum(util.load_result('from_snowball/june_22/safe_rl/mc_sample_SAC_RL_result_test_100')['revenue_reward'][1][0])[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ev_asap_R_revenue_lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ev_asap_E_revenue_lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#util.load_result('w_mc_results/online_algo_revenue_original_50')\n",
    "\n",
    "ev_asap_R_revenue_lst = []\n",
    "\n",
    "for p in [0]:\n",
    "\n",
    "    total = np.array(util.load_result('online_alg_results/online_algo_revenue_ev_asap_{}'.format(p))['total_revenue_{}_run0_R'.format(p)])\n",
    "    ev_asap_R_revenue_lst.append(np.cumsum(total)[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ev_asap_R_revenue_lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#util.load_result('w_mc_results/online_algo_revenue_original_50')\n",
    "\n",
    "total = np.array(util.load_result('w_mc_results/online_algo_revenue_ev_asap_0')['total_revenue_0_run0_E'])\n",
    "im_buy = np.array(util.load_result('w_mc_results/online_algo_revenue_ev_asap_0')['im_buy_0_run0_E'])\n",
    "im_sell = util.load_result('w_mc_results/online_algo_revenue_ev_asap_0')['im_sell_0_run0_E']\n",
    "np.cumsum(total)[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#util.load_result('w_mc_results/online_algo_revenue_original_50')\n",
    "\n",
    "total = np.array(util.load_result('w_mc_results/online_algo_revenue_ev_asap_0')['total_revenue_0_run0_R'])\n",
    "im_buy = np.array(util.load_result('w_mc_results/online_algo_revenue_ev_asap_0')['im_buy_0_run0_R'])\n",
    "im_sell = util.load_result('w_mc_results/online_algo_revenue_ev_asap_0')['im_sell_0_run0_R']\n",
    "np.cumsum(total)[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "asdasdaasdasd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#util.load_result('w_mc_results/online_algo_revenue_original_50')\n",
    "\n",
    "total = np.array(util.load_result('w_mc_results/online_algo_revenue_original_0')['total_revenue_0_run0_E'])\n",
    "im_buy = np.array(util.load_result('w_mc_results/online_algo_revenue_original_0')['im_buy_0_run0_E'])\n",
    "im_sell = util.load_result('w_mc_results/online_algo_revenue_original_0')['im_sell_0_run0_E']\n",
    "np.cumsum(total)[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#util.load_result('w_mc_results/online_algo_revenue_original_50')\n",
    "\n",
    "total = np.array(util.load_result('w_mc_results/online_algo_revenue_original_0')['total_revenue_0_run0_E'])\n",
    "im_buy = np.array(util.load_result('w_mc_results/online_algo_revenue_original_0')['im_buy_0_run0_E'])\n",
    "im_sell = util.load_result('w_mc_results/online_algo_revenue_original_0')['im_sell_0_run0_E']\n",
    "np.cumsum(total)[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#util.load_result('w_mc_results/online_algo_revenue_original_50')\n",
    "\n",
    "total = np.array(util.load_result('w_mc_results/online_algo_revenue_original_0')['total_revenue_0_run0_R'])\n",
    "im_buy = np.array(util.load_result('w_mc_results/online_algo_revenue_original_0')['im_buy_0_run0_R'])\n",
    "im_sell = util.load_result('w_mc_results/online_algo_revenue_original_0')['im_sell_0_run0_R']\n",
    "np.cumsum(total)[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#util.load_result('w_mc_results/online_algo_revenue_original_50')\n",
    "\n",
    "total = np.array(util.load_result('online_alg_results/online_algo_revenue_original_0')['total_revenue_0_run0_R'])\n",
    "im_buy = np.array(util.load_result('online_alg_results/online_algo_revenue_original_0')['im_buy_0_run0_R'])\n",
    "im_sell = util.load_result('online_alg_results/online_algo_revenue_original_0')['im_sell_0_run0_R']\n",
    "np.cumsum(total)[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.cumsum(im_buy)[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.cumsum(im_sell)[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Using Expec ',np.cumsum(util.load_result('online_alg_results/online_algo_revenue_original_0')['total_revenue_0_run0_E'])[-1])\n",
    "print('Using Actual ',np.cumsum(util.load_result('online_alg_results/online_algo_revenue_original_0')['total_revenue_0_run0_R'])[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Using Expec 0',np.cumsum(util.load_result('online_alg_results/baseline_revenue_0')['0'])[-1])\n",
    "print('Using Expec 0',np.cumsum(util.load_result('online_alg_results/baseline_revenue_100')['100'])[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Using Expec ',np.cumsum(util.load_result('online_alg_results/online_algo_revenue_ev_asap_0')['total_revenue_0_run0_E'])[-1])\n",
    "print('Using Actual ',np.cumsum(util.load_result('online_alg_results/online_algo_revenue_ev_asap_0')['total_revenue_0_run0_R'])[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Using Expec ',np.cumsum(util.load_result('online_alg_results/online_algo_revenue_original_25')['total_revenue_25_run0_E'])[-1])\n",
    "print('Using Actual ',np.cumsum(util.load_result('online_alg_results/online_algo_revenue_original_25')['total_revenue_25_run0_R'])[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Using Expec ',np.cumsum(util.load_result('online_alg_results/online_algo_revenue_original_100')['total_revenue_100_run2_E'])[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Using Expec ',np.cumsum(util.load_result('online_alg_results/online_algo_revenue_original_0')['total_revenue_0_run0_E'])[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Using Expec ',np.cumsum(util.load_result('online_alg_results/online_algo_revenue_original_75')['total_revenue_75_run1_E'])[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Using Expec ',np.cumsum(util.load_result('online_alg_results/online_algo_revenue_randomized_75')['total_revenue_75_run1_E'])[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Using Expec ',np.cumsum(util.load_result('online_alg_results/randomized/50_50/online_algo_revenue_randomized_75_50_50')['total_revenue_75_run1_E'])[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Using Expec ',np.cumsum(util.load_result('online_alg_results/randomized/90_10/online_algo_revenue_randomized_75_90_10')['total_revenue_75_run1_E'])[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Using Expec ',np.cumsum(util.load_result('online_alg_results/randomized/omid/90_10/online_algo_revenue_randomized_omid_75_90_10')['total_revenue_75_run1_E'])[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Using Expec ',np.cumsum(util.load_result('online_alg_results/randomized/omid/50_50/online_algo_revenue_randomized_omid_75_50_50')['total_revenue_75_run1_E'])[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ratio_EV_discharge = 0\n",
    "\n",
    "for day_num, date\n",
    "\n",
    "np.mean(np.array(util.load_result(('sample_path_1K/hist_mc_sample_paths/{}_perc'.format(ratio_EV_discharge)+'/bid_sample_path_'+str(ratio_EV_discharge)+'_perc')))[day_num][0:NUM_SAMPLES],axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.mean(np.array(util.load_result(('sample_path_1K/hist_mc_sample_paths/{}_perc'.format(ratio_EV_discharge)+'/bid_sample_path_'+str(ratio_EV_discharge)+'_perc')))[0][0:NUM_SAMPLES], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for idx, val in enumerate([1]):\n",
    "    print(idx)\n",
    "    print(val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}