implicit_agent.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To run this example, move this file to the main directory of this repository\n",
    "from citylearn import  CityLearn\n",
    "import matplotlib.pyplot as plt\n",
    "from pathlib import Path\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import cvxpy as cp\n",
    "import json\n",
    "import time\n",
    "from agents.rbc import RBC\n",
    "from copy import deepcopy\n",
    "\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select the climate zone and load environment\n",
    "climate_zone = 5\n",
    "sim_period = (0, 8760*4-1)\n",
    "params = {'data_path':Path(\"data/Climate_Zone_\"+str(climate_zone)), \n",
    "        'building_attributes':'building_attributes.json', \n",
    "        'weather_file':'weather_data.csv', \n",
    "        'solar_profile':'solar_generation_1kW.csv', \n",
    "        'carbon_intensity':'carbon_intensity.csv',\n",
    "        'building_ids':[\"Building_\"+str(i) for i in [1,2,3,4,5,6,7,8,9]],\n",
    "        'buildings_states_actions':'buildings_state_action_space.json', \n",
    "        'simulation_period': sim_period, \n",
    "        'cost_function': ['ramping','1-load_factor','average_daily_peak','peak_demand','net_electricity_consumption','carbon_emissions'], \n",
    "        'central_agent': False,\n",
    "        'save_memory': False }\n",
    "\n",
    "env = CityLearn(**params)\n",
    "\n",
    "observations_spaces, actions_spaces = env.get_state_action_spaces()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "### load weather data for calculation of COP\n",
    "with open(env.data_path / env.weather_file) as csv_file:\n",
    "    weather_data = pd.read_csv(csv_file)\n",
    "weather_data = weather_data['Outdoor Drybulb Temperature [C]']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_current_data(env, t):\n",
    "    \"\"\" Returns data:dic for each building from `env` for `t` timestep \"\"\"\n",
    "    ### FB - Full batch. Trim output X[:time-step]\n",
    "    ### CT - current timestep only. X = full_data[time-step], no access to full_data\n",
    "    ### DP - dynamic update. time-step k = [... k], time-step k+n = [... k + n].\n",
    "    ### P - constant value across all time steps. changes per building only.\n",
    "    \n",
    "    _max_load = 2 * 168 # 2-week max load\n",
    "    _num_buildings = len(actions_spaces) # total number of buildings in env.\n",
    "    _start = max(t - _max_load, 0)\n",
    "    observation_data = {}\n",
    "    \n",
    "    p_ele = [2 if 10 <= t % 24 <= 20 else 0.2 for i in range(1, _num_buildings+1)] # FB -- virtual electricity price.\n",
    "    #can't get future data since action dependent -- > eod hour. (1, 9)\n",
    "    E_grid_past = [env.net_electric_consumption[t - 24] for i in range(1, _num_buildings+1)] #FB -- replace w/ per building cost\n",
    "    ramping_cost_coeff = [0.1 for i in range(_num_buildings)] #P  -- initialized to 0.1, learned through diff.\n",
    "    \n",
    "    # Loads\n",
    "    E_ns = [env.buildings['Building_'+str(i)].sim_results['non_shiftable_load'][t] for i in range(1, _num_buildings+1)] #CT\n",
    "    H_bd = [env.buildings['Building_'+str(i)].sim_results['dhw_demand'][t] for i in range(1, _num_buildings+1)] #DP\n",
    "    C_bd = [env.buildings['Building_'+str(i)].sim_results['cooling_demand'][t] for i in range(1, _num_buildings+1)] #DP\n",
    "    H_max = 1.2 * np.max([env.buildings['Building_'+str(i)].sim_results['dhw_demand'][_start : t] for i in range(1, _num_buildings+1)], axis=1) #DP\n",
    "    C_max = 1.2 * np.max([env.buildings['Building_'+str(i)].sim_results['cooling_demand'][_start : t] for i in range(1, _num_buildings+1)], axis=1) #DP\n",
    "    \n",
    "    # PV generations\n",
    "    E_pv = [env.buildings['Building_'+str(i)].sim_results['solar_gen'][t] for i in range(1, _num_buildings+1)] #CT\n",
    "    \n",
    "    # Heat Pump\n",
    "    eta_hp = [0.22]*_num_buildings #P\n",
    "    t_C_hp = [8]*_num_buildings #P target cooling temperature (universal constant)\n",
    "    \n",
    "    #### CityLearn.py def. doesn't make too much sense. !!!! NOTE: THIS IS NOT UDPATED to CITYLEARN !!!!\n",
    "    COP_C = [eta_hp[i] * float(t_C_hp[i] + 273.15) / float(273.15 + weather_data[t] - t_C_hp[i])  for i in range(_num_buildings)] #DP\n",
    "    \n",
    "    E_hpC_max = [None]*_num_buildings\n",
    "    for i in range(1, _num_buildings + 1):\n",
    "        try:\n",
    "            E_hpC_max[i - 1] = np.max(env.buildings['Building_'+str(i)].sim_results['non_shiftable_load'][:t]) / COP_C[i - 1]\n",
    "            max_soc = np.max(env.buildings['Building_'+str(i)].cooling_storage.soc[:t])\n",
    "            E_hpC_max[i - 1] = max(E_hpC_max[i - 1], max_soc)\n",
    "\n",
    "        except ValueError:\n",
    "            pass\n",
    "    \n",
    "    \n",
    "    # Electric Heater\n",
    "    eta_ehH = [0.9]*_num_buildings #P\n",
    "    #replaced capacity (not avaiable in electric heater) w/ nominal_power\n",
    "    E_ehH_max = [H_max[i] / eta_ehH[i] for i in range(_num_buildings)] #P\n",
    "    \n",
    "    # Battery\n",
    "    C_f_bat = [0.00001 for i in range(_num_buildings)] #P\n",
    "    C_p_bat = [100]*_num_buildings #P (range: [20, 200])\n",
    "    eta_bat = [1]*_num_buildings #P\n",
    "    #current hour soc. normalized\n",
    "    c_bat_end = [None]*_num_buildings #can't get future data since action dependent\n",
    "    for i in range(1, 10):\n",
    "        building = env.buildings['Building_' + str(i)].electrical_storage\n",
    "        c_bat_end[i-1] = building.soc[t - 24] / building.capacity\n",
    "    \n",
    "    # Heat (Energy->dhw) Storage\n",
    "    C_f_Hsto = [0.008]*_num_buildings #P\n",
    "    C_p_Hsto = 2 * C_max #P\n",
    "    eta_Hsto = [1]*_num_buildings #P\n",
    "    #current hour soc. normalized\n",
    "    c_Hsto_end = [None]*_num_buildings #can't get future data since action dependent\n",
    "    for i in range(1, 10):\n",
    "        building = env.buildings['Building_' + str(i)].dhw_storage\n",
    "        c_Hsto_end[i-1] = building.soc[t - 24] / building.capacity \n",
    "        \n",
    "    # Cooling (Energy->cooling) Storage\n",
    "    C_f_Csto = [0.006]*_num_buildings #P\n",
    "    C_p_Csto = [2]*_num_buildings #P\n",
    "    eta_Csto = [1]*_num_buildings #P\n",
    "    #current hour soc. normalized\n",
    "    c_Csto_end = [None]*_num_buildings #can't get future data since action dependent\n",
    "    for i in range(1, 10):\n",
    "        building = env.buildings['Building_' + str(i)].cooling_storage\n",
    "        c_Csto_end[i-1] = building.soc[t - 24] / building.capacity\n",
    "    \n",
    "    \n",
    "    # fill data\n",
    "    observation_data['p_ele'] = p_ele\n",
    "    observation_data['ramping_cost_coeff'] = ramping_cost_coeff\n",
    "    observation_data['E_grid_past'] = E_grid_past\n",
    "    \n",
    "    observation_data['E_ns'] = E_ns\n",
    "    observation_data['H_bd'] = H_bd\n",
    "    observation_data['C_bd'] = C_bd\n",
    "    observation_data['H_max'] = H_max\n",
    "    observation_data['C_max'] = C_max\n",
    "    \n",
    "    observation_data['E_pv'] = E_pv\n",
    "    \n",
    "    observation_data['E_hpC_max'] = E_hpC_max\n",
    "    observation_data['eta_hp'] = eta_hp\n",
    "    observation_data['t_C_hp'] = t_C_hp\n",
    "    observation_data['COP_C'] = COP_C\n",
    "    \n",
    "    observation_data['eta_ehH'] = eta_ehH\n",
    "    observation_data['E_ehH_max'] = E_ehH_max\n",
    "    \n",
    "    observation_data['C_f_bat'] = C_f_bat\n",
    "    observation_data['C_p_bat'] = C_p_bat\n",
    "    observation_data['eta_bat'] = eta_bat\n",
    "    observation_data['c_bat_end'] = c_bat_end\n",
    "    \n",
    "    observation_data['C_f_Hsto'] = C_f_Hsto\n",
    "    observation_data['C_p_Hsto'] = C_p_Hsto\n",
    "    observation_data['eta_Hsto'] = eta_Hsto\n",
    "    observation_data['c_Hsto_end'] = c_Hsto_end\n",
    "    \n",
    "    observation_data['C_f_Csto'] = C_f_Csto\n",
    "    observation_data['C_p_Csto'] = C_p_Csto\n",
    "    observation_data['eta_Csto'] = eta_Csto\n",
    "    observation_data['c_Csto_end'] = c_Csto_end\n",
    "    \n",
    "    return observation_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_data(data:dict, current_data:dict):\n",
    "    \"\"\" Parses `current_data` for optimization and loads into `data` \"\"\"\n",
    "    assert len(current_data) == 27, \"Invalid number of parameters. Can't run basic (root) agent optimization\"\n",
    "    \n",
    "    for key, value in current_data.items():\n",
    "        if key not in data:\n",
    "            data[key] = []\n",
    "        data[key].append(value)\n",
    "        \n",
    "    for key, value in current_data.items():\n",
    "        if np.array(data[key]).shape == (1, 9):#removes duplicates\n",
    "            data[key] = [value]\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_dimensions(data:dict):\n",
    "    \"\"\" Gets shape of each param \"\"\"\n",
    "    for key in data.keys():\n",
    "        print(data[key].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_building(data:dict, building_id:int):\n",
    "    \"\"\" Loads data (dict) from a particular building. 1-based indexing for building \"\"\"\n",
    "    assert building_id > 0, \"building_id is 1-based indexing.\"\n",
    "    building_data = {}\n",
    "    for key in data.keys():\n",
    "        building_data[key] = np.array(data[key])[:, building_id - 1]\n",
    "    return building_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_to_numpy(params:dict):\n",
    "    \"\"\" Converts dic[key] to nd.array \"\"\"\n",
    "    for key in params:\n",
    "        if key == 'c_bat_end' or key == 'c_Csto_end' or key == 'c_Hsto_end':\n",
    "            params[key] = np.array([params[key][-1], params[key][-1]])\n",
    "            params[key][1] = 0.1\n",
    "        else:\n",
    "            params[key] = np.array(params[key])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_random_data(data:dict):\n",
    "    \"\"\" Creates random data drawn from Gaussian. \"\"\"\n",
    "    for key in data:\n",
    "        data[key] = np.clip(np.random.random(size=data[key].shape), 0, 1)\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_actions(data:dict, t, debug=False, apply_seed=False, lookahead=False):\n",
    "    \"\"\" Runs Optim for all 9 buildings per hour. `lookahead` once set to `True` computes day-ahead dispatch \"\"\"\n",
    "    convert_to_numpy(data)\n",
    "    data = create_random_data(deepcopy(data)) if apply_seed else data\n",
    "    if debug:\n",
    "        return [Optim(t, data, i, actions_spaces[i].shape[0]) for i in range(9)]\n",
    "\n",
    "    return [Optim(t, data, i, actions_spaces[i].shape[0]).solve(debug, lookahead) for i in range(9)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Optim:\n",
    "    \"\"\" Define Differential Optimization framework for CL. \"\"\"\n",
    "    def __init__(self, t:int, parameters:dict, building_id:int, num_actions:int):\n",
    "        \"\"\" \n",
    "        @Param:\n",
    "        - `parameters` : data (dict) from r <= t <= T following `get_current_data` format.\n",
    "        - `T` : 24 hours (constant)\n",
    "        - `t` : hour to solve optimization for.\n",
    "        - `building_id`: building index number (0-based)\n",
    "        - `num_actions`: Number of actions for building \n",
    "            NOTE: right now, this is an integer, but will be checked programmatically.\n",
    "        Solves per building as specified by `building_id`. Note: 0 based.\n",
    "        \"\"\"\n",
    "        T = 24\n",
    "        window = T - t\n",
    "        self.constraints = []\n",
    "        self.costs = []\n",
    "        self.t = t\n",
    "        self.num_actions = num_actions\n",
    "        \n",
    "        # -- define action space -- #\n",
    "        bounds_high, bounds_low = np.vstack([actions_spaces[building_id].high, actions_spaces[building_id].low])\n",
    "        #parse to dictionary --- temp... need to check w/ state-action-dictionary.json !!! @Zhaiyao !!!\n",
    "        if len(bounds_high) == 2:\n",
    "            bounds_high = {'action_H' : bounds_high[0], 'action_C' : None, 'action_bat' : bounds_high[1]}\n",
    "            bounds_low = {'action_H' : bounds_low[0], 'action_C' : None, 'action_bat' : bounds_low[1]}\n",
    "        else:\n",
    "            bounds_high = {'action_H' : bounds_high[0], 'action_C' : bounds_high[1], 'action_bat' : bounds_high[2]}\n",
    "            bounds_low = {'action_H' : bounds_low[0], 'action_C' : bounds_low[1], 'action_bat' : bounds_low[2]}\n",
    "            \n",
    "        # -- define action space -- #\n",
    "        \n",
    "        #define parameters and variables\n",
    "        \n",
    "        ### --- Parameters ---\n",
    "        p_ele = cp.Parameter(name='p_ele', shape=(window), value=parameters['p_ele'][t:, building_id])\n",
    "        E_grid_prevhour = cp.Parameter(name='E_grid_prevhour', \n",
    "                                       value=parameters['E_grid_past'][min(t-1, 0), building_id])\n",
    "        \n",
    "        #### 0 for day-ahead.\n",
    "#         E_grid_pkhist = cp.Parameter(name='E_grid_pkhist', \n",
    "#                                     value=parameters['E_grid_past'][:(t+1), building_id].max())\n",
    "        E_grid_pkhist = cp.Parameter(name='E_grid_pkhist', value=0)\n",
    "\n",
    "        # max-min normalization of ramping_cost to downplay E_grid_sell weight.\n",
    "        ramping_cost_coeff = cp.Parameter(name='ramping_cost_coeff', \n",
    "                                          value=parameters['ramping_cost_coeff'][t, building_id])\n",
    "        \n",
    "        # Loads\n",
    "        E_ns = cp.Parameter(name='E_ns', shape=(window), value=parameters['E_ns'][t:, building_id])\n",
    "        H_bd = cp.Parameter(name='H_bd', shape=(window), value=parameters['H_bd'][t:, building_id])\n",
    "        C_bd = cp.Parameter(name='C_bd', shape=(window), value=parameters['C_bd'][t:, building_id])\n",
    "        \n",
    "        # PV generations\n",
    "        E_pv = cp.Parameter(name='E_pv', shape=(window), value=parameters['E_pv'][t:, building_id])\n",
    "\n",
    "        # Heat Pump\n",
    "        COP_C = cp.Parameter(name='COP_C', shape=(window), value=parameters['COP_C'][t:, building_id])\n",
    "        E_hpC_max = cp.Parameter(name='E_hpC_max', value=parameters['E_hpC_max'][t, building_id])\n",
    "\n",
    "        # Electric Heater\n",
    "        eta_ehH = cp.Parameter(name='eta_ehH', value=parameters['eta_ehH'][t, building_id])\n",
    "        E_ehH_max = cp.Parameter(name='E_ehH_max', value=parameters['E_ehH_max'][t, building_id])\n",
    "\n",
    "        # Battery\n",
    "        C_f_bat = cp.Parameter(name='C_f_bat', value=parameters['C_f_bat'][t, building_id])\n",
    "        C_p_bat = parameters['C_p_bat'][t, building_id] #cp.Parameter(name='C_p_bat', value=parameters['C_p_bat'][t, building_id])\n",
    "        eta_bat = cp.Parameter(name='eta_bat', value=parameters['eta_bat'][t, building_id])\n",
    "        soc_bat_init = cp.Parameter(name='soc_bat_init', value=parameters['c_bat_end'][0, building_id])\n",
    "        soc_bat_norm_end = cp.Parameter(name='soc_bat_norm_end', value=parameters['c_bat_end'][1, building_id])\n",
    "        \n",
    "        # Heat (Energy->dhw) Storage\n",
    "        C_f_Hsto = cp.Parameter(name='C_f_Hsto', value=parameters['C_f_Hsto'][t, building_id]) #make constant.\n",
    "        C_p_Hsto = cp.Parameter(name='C_p_Hsto', value=parameters['C_p_Hsto'][t, building_id])\n",
    "        eta_Hsto = cp.Parameter(name='eta_Hsto', value=parameters['eta_Hsto'][t, building_id])\n",
    "        soc_Hsto_init = cp.Parameter(name='soc_Hsto_init', value=parameters['c_Hsto_end'][0, building_id])\n",
    "\n",
    "        # Cooling (Energy->cooling) Storage\n",
    "        C_f_Csto = cp.Parameter(name='C_f_Csto', value=parameters['C_f_Csto'][t, building_id])\n",
    "        C_p_Csto = cp.Parameter(name='C_p_Csto', value=parameters['C_p_Csto'][t, building_id])\n",
    "        eta_Csto = cp.Parameter(name='eta_Csto', value=parameters['eta_Csto'][t, building_id])\n",
    "        soc_Csto_init = cp.Parameter(name='soc_Csto_init', value=parameters['c_Csto_end'][0, building_id])\n",
    "\n",
    "        ### --- Variables ---\n",
    "        \n",
    "        #relaxation variables - prevents numerical failures when solving optimization\n",
    "        E_bal_relax = cp.Variable(name='E_bal_relax', shape=(window)) #electricity balance relaxation\n",
    "        H_bal_relax = cp.Variable(name='H_bal_relax', shape=(window)) #heating balance relaxation\n",
    "        C_bal_relax = cp.Variable(name='C_bal_relax', shape=(window)) #cooling balance relaxation\n",
    "        \n",
    "        E_grid = cp.Variable(name='E_grid', shape=(window)) #net electricity grid\n",
    "        E_grid_sell = cp.Variable(name='E_grid_sell', shape=(window)) #net electricity grid\n",
    "        \n",
    "        E_hpC = cp.Variable(name='E_hpC', shape=(window)) #heat pump\n",
    "        E_ehH = cp.Variable(name='E_ehH', shape=(window)) #electric heater\n",
    "        \n",
    "        SOC_bat = cp.Variable(name='SOC_bat', shape=(window)) #electric battery\n",
    "        SOC_Brelax = cp.Variable(name='SOH_Brelax', shape=(window)) #electrical battery relaxation (prevents numerical infeasibilities)\n",
    "        action_bat = cp.Variable(name='action_bat', shape=(window)) #electric battery\n",
    "    \n",
    "        SOC_H = cp.Variable(name='SOC_H', shape=(window)) #heat storage\n",
    "        SOC_Hrelax = cp.Variable(name='SOH_Crelax', shape=(window)) #heat storage relaxation (prevents numerical infeasibilities)\n",
    "        action_H = cp.Variable(name='action_H', shape=(window)) #heat storage\n",
    "\n",
    "        SOC_C = cp.Variable(name='SOC_C', shape=(window)) #cooling storage\n",
    "        SOC_Crelax = cp.Variable(name='SOC_Crelax', shape=(window)) #cooling storage relaxation (prevents numerical infeasibilities)\n",
    "        action_C = cp.Variable(name='action_C', shape=(window)) #cooling storage\n",
    "        \n",
    "        \n",
    "        ### objective function\n",
    "        ramping_cost = cp.abs(E_grid[0] - E_grid_prevhour) + cp.sum(cp.abs(E_grid[1:] - E_grid[:-1])) # E_grid_t+1 - E_grid_t\n",
    "        peak_net_electricity_cost = cp.max(cp.atoms.affine.hstack.hstack([*E_grid, E_grid_pkhist])) #max(E_grid, E_gridpkhist)\n",
    "        electricity_cost = cp.sum(p_ele * E_grid)\n",
    "        selling_cost = -1e2 * cp.sum(E_grid_sell) #not as severe as violating constraints\n",
    "        \n",
    "        ### relaxation costs - L1 norm\n",
    "        # balance eq.\n",
    "        E_bal_relax_cost = cp.sum(cp.abs( E_bal_relax ))\n",
    "        H_bal_relax_cost = cp.sum(cp.abs( H_bal_relax ))\n",
    "        C_bal_relax_cost = cp.sum(cp.abs( C_bal_relax ))\n",
    "        # soc eq.\n",
    "        SOC_Brelax_cost = cp.sum(cp.abs( SOC_Brelax ))\n",
    "        SOC_Crelax_cost = cp.sum(cp.abs( SOC_Crelax ))\n",
    "        SOC_Hrelax_cost = cp.sum(cp.abs( SOC_Hrelax ))\n",
    "        \n",
    "        self.costs.append(ramping_cost_coeff.value * ramping_cost + \n",
    "                          peak_net_electricity_cost + electricity_cost + selling_cost +\n",
    "                          E_bal_relax_cost*1e4 + H_bal_relax_cost*1e4 + C_bal_relax_cost*1e4 \n",
    "                          + SOC_Brelax_cost*1e4 + SOC_Crelax_cost*1e4 + SOC_Hrelax_cost*1e4)\n",
    "        \n",
    "        \n",
    "        ### constraints\n",
    "        self.constraints.append( E_grid >= 0 )\n",
    "        self.constraints.append( E_grid_sell <= 0 )\n",
    "        \n",
    "        #energy balance constraints\n",
    "        self.constraints.append( E_pv + E_grid + E_grid_sell + E_bal_relax == E_ns + E_hpC + E_ehH + action_bat * C_p_bat) #electricity balance\n",
    "        self.constraints.append( E_ehH * eta_ehH + H_bal_relax == action_H * C_p_Hsto + H_bd ) #heat balance\n",
    "        \n",
    "        #!!!!! Problem Child !!!!!\n",
    "        self.constraints.append( E_hpC * COP_C + C_bal_relax == action_C * C_p_Csto + C_bd ) #cooling balance\n",
    "        #!!!!! Problem Child !!!!!\n",
    "        \n",
    "        \n",
    "        #heat pump constraints\n",
    "        self.constraints.append( E_hpC <= E_hpC_max ) #maximum cooling\n",
    "        self.constraints.append( E_hpC >= 0 ) #constraint minimum cooling to positive\n",
    "        #electric heater constraints\n",
    "        self.constraints.append( E_ehH >= 0 ) #constraint to PD\n",
    "        self.constraints.append( E_ehH <= E_ehH_max ) #maximum limit\n",
    "        \n",
    "        #electric battery constraints\n",
    "        \n",
    "        self.constraints.append( SOC_bat[0] == (1 - C_f_bat)*soc_bat_init + action_bat[0]*eta_bat + SOC_Crelax[0] ) #initial SOC\n",
    "        #soc updates\n",
    "        for i in range(1, window): #1 = t + 1\n",
    "            self.constraints.append( SOC_bat[i] == (1 - C_f_bat)*SOC_bat[i - 1] + action_bat[i]*eta_bat + SOC_Crelax[i])\n",
    "        self.constraints.append( SOC_bat[-1] == soc_bat_norm_end ) #soc terminal condition\n",
    "        self.constraints.append(SOC_bat >= 0) #battery SOC bounds\n",
    "        self.constraints.append(SOC_bat <= 1) #battery SOC bounds\n",
    "\n",
    "        #Heat Storage constraints\n",
    "        self.constraints.append( SOC_H[0] == (1 - C_f_Hsto) * soc_Hsto_init + action_H[0]*eta_Hsto + SOC_Hrelax[0]) #initial SOC\n",
    "        #soc updates\n",
    "        for i in range(1, window):\n",
    "            self.constraints.append( SOC_H[i] == (1 - C_f_Hsto)*SOC_H[i - 1] + action_H[i]*eta_Hsto + SOC_Hrelax[i])\n",
    "        self.constraints.append(SOC_H >= 0) #battery SOC bounds\n",
    "        self.constraints.append(SOC_H <= 1) #battery SOC bounds\n",
    "        \n",
    "        #Cooling Storage constraints\n",
    "        self.constraints.append( SOC_C[0] == (1 - C_f_Csto) * soc_Csto_init + action_C[0]*eta_Csto + SOC_Crelax[0]) #initial SOC\n",
    "        #soc updates\n",
    "        for i in range(1, window):\n",
    "            self.constraints.append( SOC_C[i] == (1 - C_f_Csto)*SOC_C[i - 1] + action_C[i]*eta_Csto + SOC_Crelax[i])\n",
    "        self.constraints.append(SOC_C >= 0) #battery SOC bounds\n",
    "        self.constraints.append(SOC_C <= 1) #battery SOC bounds\n",
    "        \n",
    "        \n",
    "        #### action constraints (limit to action-space)\n",
    "        #format: AS[building_id][0/1 (high/low)][heat, cool, battery]\n",
    "        \n",
    "        heat_high, cool_high, battery_high = bounds_high\n",
    "        heat_low, cool_low, battery_low = bounds_low\n",
    "        \n",
    "        assert len(bounds_high) == 3, 'Invalid number of bounds for actions - see dict defined in `Optim`'\n",
    "        \n",
    "        for high, low in zip(bounds_high.items(), bounds_low.items()):\n",
    "            key, h, l = [*high, low[1]]\n",
    "            if not (h and l): #throw DeMorgan's in!!!\n",
    "                continue\n",
    "                \n",
    "            #heating action\n",
    "            if key == 'action_H':\n",
    "                self.constraints.append(action_H <= h)\n",
    "                self.constraints.append(action_H >= l)\n",
    "            #cooling action\n",
    "            elif key == 'action_C':\n",
    "                self.constraints.append(action_C <= h)\n",
    "                self.constraints.append(action_C >= l)\n",
    "            #Battery action\n",
    "            elif key == 'action_bat':\n",
    "                self.constraints.append(action_bat <= h)\n",
    "                self.constraints.append(action_bat >= l)\n",
    "\n",
    "    def get_problem(self):\n",
    "        \"\"\" Returns raw problem \"\"\"\n",
    "        # Form objective.\n",
    "        obj = cp.Minimize(*self.costs)\n",
    "        # Form and solve problem.\n",
    "        prob = cp.Problem(obj, self.constraints)\n",
    "        \n",
    "        return prob\n",
    "    \n",
    "    def get_constraints(self):\n",
    "        \"\"\" Returns constraints for problem \"\"\"\n",
    "        return self.constraints\n",
    "    \n",
    "    def solve(self, debug=False, dispatch=False):\n",
    "        prob = self.get_problem() #Form and solve problem\n",
    "        status = prob.solve(verbose=debug)  # Returns the optimal value.\n",
    "\n",
    "        if float('-inf') < status < float('inf'):\n",
    "            pass\n",
    "        else:\n",
    "            return \"Unbounded Solution\"\n",
    "            \n",
    "        actions = {}\n",
    "        for var in prob.variables():\n",
    "            if dispatch:\n",
    "                actions[var.name()] = np.array(var.value) #no need to clip... automatically restricts range\n",
    "            else:\n",
    "                actions[var.name()] = var.value[0] #no need to clip... automatically restricts range\n",
    "        \n",
    "        #Temporary... needs fixing!\n",
    "        ## compute dispatch cost\n",
    "        params = {x.name() : x.value for x in prob.parameters()}\n",
    "\n",
    "        if dispatch:\n",
    "            ramping_cost = np.sum(np.abs(actions['E_grid'][1: ] + actions['E_grid_sell'][1: ] - \n",
    "                                         actions['E_grid'][:-1] - actions['E_grid_sell'][:-1]))\n",
    "            net_peak_electricity_cost = np.max(actions['E_grid'])\n",
    "            virtual_electricity_cost = np.sum(params['p_ele'] * actions['E_grid'])\n",
    "            dispatch_cost = net_peak_electricity_cost #ramping_cost + net_peak_electricity_cost + virtual_electricity_cost\n",
    "            \n",
    "        if self.num_actions == 2:\n",
    "            return [actions['action_H'], actions['action_bat']], dispatch_cost if dispatch else None\n",
    "        return [actions['action_C'], actions['action_H'], actions['action_bat']], dispatch_cost if dispatch else None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# # optimization debug -> !!! PROBLEM !!!\n",
    "# debug = get_actions(data_est, 0, debug=True) # for each building: [actions (size 2/3)], cost (if available)\n",
    "# problem = debug[0].get_problem()\n",
    "# problem.solve()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for var in problem.variables():\n",
    "#     print(var, var.value[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## RBC for Data Collection "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_idx_hour():\n",
    "    # Finding which state \n",
    "    with open('buildings_state_action_space.json') as file:\n",
    "        actions_ = json.load(file)\n",
    "\n",
    "    indx_hour = -1\n",
    "    for obs_name, selected in list(actions_.values())[0]['states'].items():\n",
    "        indx_hour += 1\n",
    "        if obs_name=='hour':\n",
    "            break\n",
    "        assert indx_hour < len(list(actions_.values())[0]['states'].items()) - 1, \"Please, select hour as a state for Building_1 to run the RBC\"\n",
    "    return indx_hour"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def estimate_data(surrogate_env:CityLearn, data:dict, t_start:int, init_updates:dict):\n",
    "    \"\"\" Returns data for hours `t_start` - 24 using `surrogate_env` running RBC `agent` \"\"\"\n",
    "    for i in range(0, 24):\n",
    "        data = parse_data(data, get_current_data(surrogate_env, t_start + i))\n",
    "        \n",
    "    return init_values(data, init_updates)[0] if t_start == 0 else data #only load previous values at start of day"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_rbc_data(surrogate_env:CityLearn, state, indx_hour:int, dump_data:list, run_timesteps:int):\n",
    "    \"\"\" Runs RBC for x number of timesteps \"\"\"\n",
    "    ## --- RBC generation ---\n",
    "    for i in range(run_timesteps):\n",
    "        hour_state = np.array([[state[0][indx_hour]]])\n",
    "        action = agents.select_action(hour_state) #using RBC to select next action given current sate\n",
    "        next_state, rewards, done, _ = surrogate_env.step(action)\n",
    "        state = next_state\n",
    "        dump_data.append([x[26] for x in state])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_values(data:dict, update_values:dict=None):\n",
    "    \"\"\" Loads eod values for SOC and E_grid_past before(after) wiping data cache \"\"\"\n",
    "    if update_values:\n",
    "        #assign previous day's end socs.\n",
    "        data['c_bat_end'][0] =  update_values['c_bat_end']\n",
    "        data['c_Hsto_end'][0] = update_values['c_Hsto_end']\n",
    "        data['c_Csto_end'][0] = update_values['c_Csto_end']\n",
    "            \n",
    "        #assign previous day's end E_grid.\n",
    "        data['E_grid_past'][0] = update_values['E_grid_past']\n",
    "    else:\n",
    "        update_values = {'c_bat_end' : data['c_bat_end'][-1], 'c_Hsto_end' : data['c_Hsto_end'][-1], \n",
    "                         'c_Csto_end' : data['c_Csto_end'][-1], 'E_grid_past' : data['E_grid_past'][-1]}\n",
    "        \n",
    "    return data, update_values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_ramping_rbc(day_data):\n",
    "    arr = []\n",
    "    for day in range(len(day_data) // 24): #number of days\n",
    "        data = day_data[day : day + 24]\n",
    "        arr.append( np.sum(np.abs(data[1:] - data[:-1])) )\n",
    "    return arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_peak_rbc(day_data):\n",
    "    arr = []\n",
    "    for day in range(len(day_data) // 24): #number of days\n",
    "        arr.append(np.max(day_data[day : day + 24]))\n",
    "    return arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_virtual_electricity_rbc(day_data):\n",
    "    arr = []\n",
    "    p_ele = np.array([2 if 10 <= i <= 20 else 0.2 for i in range(24)])\n",
    "    for day in range(len(day_data) // 24): #number of days\n",
    "        arr.append(np.sum(p_ele * day_data[day : day + 24]))\n",
    "    return arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time step: 360\n",
      "Total time = 7.174033880233765\n"
     ]
    }
   ],
   "source": [
    "#### accumulate\n",
    "data = {}\n",
    "actions_arr = [] #plot actions\n",
    "E_grid = []\n",
    "#### accumulate\n",
    "\n",
    "\n",
    "state = env.reset() #states/building\n",
    "done = False\n",
    "t_idx = 0\n",
    "rbc_threshold = 336 #run RBC for 2 weeks\n",
    "end_time = rbc_threshold + 24 * 30\n",
    "\n",
    "total_rewards = [] #reward for each building\n",
    "\n",
    "agents = RBC(actions_spaces)\n",
    "indx_hour = get_idx_hour()\n",
    "\n",
    "start = time.time()\n",
    "\n",
    "look_ahead_cost = []\n",
    "RBC_cost = []\n",
    "\n",
    "get_rbc_data(deepcopy(env), state, indx_hour, RBC_cost, end_time)\n",
    "\n",
    "#run agent\n",
    "while not done and t_idx < end_time:\n",
    "\n",
    "    hour_state = np.array([[state[0][indx_hour]]])\n",
    "\n",
    "    if t_idx%24 == 0 and t_idx > rbc_threshold - 24: #reset values every day\n",
    "        \n",
    "        _, init_updates = init_values(data) #update 0th hour values \n",
    "        data = {}\n",
    "            \n",
    "    if t_idx%1460 < rbc_threshold:\n",
    "        action = agents.select_action(hour_state)\n",
    "        next_state, rewards, done, _ = env.step(action)\n",
    "    else:\n",
    "        #day ahead dispatch.\n",
    "        ### at first hour, collects the data from t = 1 to t = 24 using RBC. \n",
    "        ### solves optimization for all hours, and runs corresponding actions for the next 23 hours\n",
    "        if t_idx%24 == 0: #first hour\n",
    "            data_est = estimate_data(env, deepcopy(data), t_idx, init_updates)\n",
    "            optim_results = get_actions(data_est, t_idx % 24, lookahead=True) #day-ahead plan\n",
    "            action_planned_day, cost_dispatch = zip(*optim_results)\n",
    "            \n",
    "            look_ahead_cost.append(cost_dispatch) # per day estimation cost after solving for hour 1 for hours 1-24\n",
    "        #action = get_actions(data_est, t_idx % 24) #runs optimization per hour.\n",
    "        assert len(action_planned_day[0][0]) == 24, 'Invalid number of observations for Optimization actions'\n",
    "\n",
    "        actions = [np.array(action_planned_day[idx])[:, t_idx % 24] for idx in range(len(actions_spaces))]\n",
    "        \n",
    "        next_state, rewards, done, _ = env.step(actions)\n",
    "        actions_arr.append(actions)\n",
    "    \n",
    "    state = next_state\n",
    "    E_grid.append([x[26] for x in state]) #E_Grid\n",
    "    \n",
    "#     state = next_state\n",
    "\n",
    "    if t_idx >= rbc_threshold - 24: #start collecting data\n",
    "        data = parse_data(data, get_current_data(env, t_idx))\n",
    "    total_rewards.append(rewards)\n",
    "    \n",
    "    t_idx += 1\n",
    "    \n",
    "    print(f\"\\rTime step: {t_idx}\", end='')\n",
    "    \n",
    "end = time.time()\n",
    "print(f\"\\nTotal time = {end - start}\")\n",
    "E_grid = np.array(E_grid).T #set per building\n",
    "RBC_cost = np.array(RBC_cost).T #set per building"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAABASElEQVR4nO3dd3xV9f348dc7ew8ChCmEIXvJlipBCnWj2NpaUVFbv25rnd9v7U/tsGqtWnediANcFUe1VpGIaJUtICBDgoRNIHsn798f5+TmJmTchNzcjPfz8biPe+9Z9/2JeN7n8zmf8/mIqmKMMcYABAU6AGOMMa2HJQVjjDEelhSMMcZ4WFIwxhjjYUnBGGOMhyUFY4wxHpYUjGmAiOSJSD/38zwR+VM926qIDHA/PyUiv2+pOI1pDpYUTLsnIukiUuie3I+IyL9EpLev+6tqjKp+39jfVdUrVfWPjd3PFyJylohscMv0pYgM9cfvmI7HkoLpKM5S1RigO7AfeDTA8TSZiAwEXgGuBBKA94B3RSQkkHGZ9sGSgulQVLUIeBPwXFmLSJqI/Mrr+1wRWeb13dMkVJOI3CIie0Vkj4hcVmOdp6lJRFJFJENEbhKRA+4+l3ptmyQi74lIjoisEJE/ecdQw0+Az1V1maqWAfcBPYGpjf6DGFODJQXToYhIFPBz4KtmONapwM3ADGAg8OMGdukGxOOcwC8HHheRRHfd40C+u80l7qven6/xWYDhjYnfmNpYUjAdxSIRyQKycU7if22GY54PvKCqG1Q1H7irge1LgT+oaqmqfgDkAYNEJBg4D7hTVQtUdSPwYj3H+QSY6tY+woD/A8KAqGMsjzGWFEyHcY6qJgARwLXAZyLS7RiP2QPY5fV9ZwPbZ7rNPZUKgBigCxBS41jen6tR1c04NYnHgL1AZ2AjkOFz5MbUwZKC6VBUtVxV/wmUAz9yF+dT/Srb12SxF/DuxXRcE8M6CJQBvbyW1ds7SlXfVNXhqpoE3An0BVY08feN8bCkYDoUccwCEoFN7uK1wGwRiXJvKF/u4+FeB+aKyFD3XsWdTYlJVcuBfwJ3uTEMBi5uoBxjRSRYRLoATwPvujUIY46JJQXTUbwnInlADvBn4BJV/dZd9xBQgtNV9UWc7p4NUtUPgYeBT4Ft7ntTXYtzE3of8BKwACiuZ/u/A1nAd8AR4NfH8NvGeIhNsmNM6yMi9wHdVLWhXkjGNCurKRjTCojIYBEZ6TZvTcBpwno70HGZjseegDSmdYjFaTLqgdOM9TfgnYBGZDokaz4yxhjjYc1HxhhjPNp081Hnzp21b9++Tdo3Pz+f6Ojo5g0oQKwsrU97KQdYWVqrYynLqlWrDqlql9rWtemk0LdvX1auXNmkfdPS0khNTW3egALEytL6tJdygJWltTqWsohInU/fW/ORMcYYD0sKxhhjPPyaFNwZr9aLyFoRWeku6yQiH4vIVvc90V0uIvKIiGwTkXUicoI/YzPGGHO0lrinME1VD3l9vx1YrKr3isjt7vfbgNNwxqQfCEwEnnTfG6W0tJSMjAyKiorq3S4+Pp5NmzbVu01bYWWpX0REBL169SI0NLRZj2tMexSIG82zgFT384tAGk5SmAXMV+fBia9EJEFEuqvq3sYcPCMjg9jYWPr27YuI1Lldbm4usbGxTYm/1bGy1E1VyczMJCMjg5SUlGY7rjHtlb/vKSjwHxFZJSJXuMuSvU70+4Bk93NPqo8hn+Eua5SioiKSkpLqTQim4xARkpKSGqw5GmMc/q4p/EhVd4tIV+BjEak2tK+qqog06pFqN7lcAZCcnExaWlq19fHx8eTl5TV4nPLycnJzcxvz062WlaVhRUVFR/1b8ae8vLwW/T1/srK0Tv4qi1+Tgqrudt8PiMjbwARgf2WzkIh0Bw64m++m+sQivdxlNY/5NM748YwbN05r9tPdtGmTT80P1uTSOvmrLBEREYwZM6bZj1sX6w/fOrXlsqgqu7MK2bQ3l417cogv/4Ez/VAWvyUFEYkGglQ11/08E/gD8C7OVIL3uu+Vg369C1wrIgtxbjBnN/Z+QmuQmZnJ9OnTAdi3bx/BwcF06eI8OLh8+XLCwsICGV7ApKWlERYWxoknngjAU089RVRUFBdfXO9cMsZ0SMVl5Wzdn8emvTls3JvDxj05bNqbQ06RM5urCFw0xD/nEn/WFJKBt922/RDgVVX9t4isAF4Xkctx5rQ9393+A+B0nMlKCoBL/Rib3yQlJbF27VoA7rrrLmJiYrj55ps968vKyggJadMPkjdJWloaMTExnqRw5ZVXBjgiY1qHw/klzsnfPfFv3JvDtgN5lFU4LeuRocEM7h7LWaN6MKR7HEN7xDG4WyzLv1zml3j8dnZS1e+BUbUszwSm17JcgWv8FU8gzZ07l4iICNasWcOUKVOIi4urliyGDx/O+++/T9++fXn55Zd55JFHKCkpYeLEiTzxxBMEBwdXO96KFSu44YYbyM/PJzw8nEWLFhEaGspVV13FypUrCQkJ4cEHH2TatGnMmzePd999l4KCArZv3865557L/fffT3l5OZdffjkrV65ERLjsssu48cYbSU1N5YEHHmDcuHEcOnSIcePGkZ6ezrx581i0aBH5+fls3bqVm2++mZKSEl566SXCw8P54IMP6NSpE6mpqYwaNYrPPvuMsrIynn/+ebp27cpTTz1FcHAwL7/8Mo8++iiLFy/2/A3Wrl3LlVdeSUFBAX369GH+/PkkJiaSmprKxIkTWbJkCVlZWTz33HOcdNJJgfhPaMwxq6hQ0jPzneafvdmeZqB9OVWdIJLjwhnaPY7pQ7o6CaB7HH2SogkOarmOM+36kvXu975l456cWteVl5cfdbL1xdAecdx51rBG75eRkcGXX35JcHAwd911V63bbNq0iddee40vvviC0NBQrr76al555ZVqTSwlJSX8/Oc/57XXXmP8+PHk5ORQXl7O448/joiwfv16Nm/ezMyZM9myZQsAa9euZc2aNYSHhzNo0CCuu+46Dhw4wO7du9mwYQMAWVlZDZZhw4YNrFmzhqKiIgYMGMB9993HmjVruPHGG5k/fz6/+c1vACgoKGDt2rUsXbqUyy67jA0bNnDllVdWS4SLFy/2HPfiiy/m0UcfZerUqdx2223cfffdPPzww4BTs1q+fDkffPABd999N5988kkj//LGtLyCkjI278utVgPYvC+XgpJyAIKDhAFdYpjcP4mh3eMY0j2OId1jSYoJD3Dk7TwptCY/+9nPGkxCixcvZtWqVYwfPx6AwsJCunbtWm2b7777ju7du3u2iYuLIzc3l2XLlnHdddcBMHjwYPr06eNJCtOnTyc+Ph6AoUOHsnPnToYNG8b333/PddddxxlnnMHMmTMbLMO0adOIjY0lNjaW+Ph4zjrrLABGjBjBunXrPNtdcMEFAJx88snk5OTUm3Cys7PJyspi6tSpAPzyl7/k0kurWg5nz54NwNixY0lPT28wRmNakqpyILeYjXvctv+9OWzak8OOzHwqp6qJjQhhaPc4zh/Xm6E9nKv/AV1jiAht/EVpS2jXSaG+K/qW7rHjPcRtSEgIFRUVnu+VfehVlUsuuYS//OUvzfrb4eFVVx/BwcGUlZWRmJjIN998w0cffcRTTz3F66+/zvPPP18ttpp9+72PExQU5PkeFBREWVmZZ13NZ0SO5ZmRyt+ojNuYQCktr2D7wTyvq/9cNu7N4XB+iWeb3p0iGdo9jrNH9/DUAHolRrap56badVJorfr27cv7778PwOrVq9mxYwfgXNHPmjWLG2+8ka5du3L48GFyc3Pp06ePZ99Bgwaxd+9eVqxYwfjx48nNzaWsrIyTTjqJV155hVNOOYUtW7bwww8/MGjQIFavXl1rDIcOHSIsLIzzzjuPQYMGMWfOHE9sq1atYsKECbz55ptNKt9rr73GtGnTWLZsGfHx8cTHxxMbG0tOztFNefHx8SQmJvL5559z0kknsXDhQk+twZhAyS4sZdPenKoEsC+HLfvyKCl3LpjCQoIYlBzLjCHJDOkey9Ae8QzuHktcRNsfSsWSQgCcd955zJ8/n2HDhjFx4kSOP/54wGna+dOf/sTMmTOpqKggNDSUxx9/vFpSCAsL47XXXuO6666jsLCQyMhI3n77ba6++mquuuoqRowYQUhICPPmzat2ZV/T7t27ufTSSz21gsrayc0338z555/P008/zRlnnNGk8lU+E1BaWsrzzz8PwFlnncVPf/pT3nnnHR599NFq27/44oueG83HHXccL730UpN+15jGUlUyjhTyrVfPn017c8g4UujZJik6jKE94rh0Sl9P759+naMJCW6fg0y36Tmax40bpzUn2dm0aRNDhgxpcF974Ms/vHsvNYW/yuLrv4vm0pYfkqqpvZSluKycBf9KI7LHQE/zz6a9OeQWV/X9T+kczVD3xD+kexzDusfRJTa8VTb/HOMkO6tUtdb/Sa2mYIxp14pKy3n16x94Im0bh/JKgPVEhQUzpHscs8b0YGj3eIZ0j2VQt1iiwuyUaH8B06zay7gypu0rLa/grVUZPLJ4K3uyi5jcL4nz++fxsxmT6dMpiqAW7PvfllhSMMa0KxUVynvr9vDQx1tIzyxgdO8E/vqzUUwZ0Jm0tDRSOjdtsvuOwpKCMaZdUFU+3rifBz/ewuZ9uQzuFsuzF49j+pCurfKeQGtlScEY06apKsu2HeKB/2zhm11ZpHSO5pELxnDmiO7WRNQElhSMMW3Wqp2H+etH3/HV94fpER/BfeeN4LwTerXb7qItwf5yfpCRkcGsWbMYOHAg/fv354YbbqCkpKTefbKysnjiiSc83/fs2cNPf/pTf4faqqSnp/P66697vq9cuZLrr78+gBGZ1urbPdlcNm8F5z35X7YdyOOus4ay5JZUfj7+OEsIx8j+es1MVZk9ezbnnHMOW7duZcuWLeTl5fG73/2u3v1qJoUePXo0+Ynitio9PZ033njD833cuHE88sgjAYzItDbbDuRxzSurOeORZazaeYRbTx3E0lunMXdKCuEhrXMsobbGkkIz+/TTT4mIiPAM6hYcHMxDDz3E888/T0FBAfPmzWPWrFmkpqYycOBA7r77bgBuv/12tm/fzujRo7nllltIT09n+PDhAMybN49zzjmHGTNm0LdvXx577DEefPBBxowZw6RJkzh8+PBRcezfv59zzz2XUaNGMWrUKL788ksAHnzwQYYPH87w4cM9I5Gmp6czZMgQfv3rXzNs2DBmzpxJYaHzROcjjzzC0KFDGTlyJL/4xS8AZ56IBx54wPNbw4cPJz09nfT0dAYPHszcuXM5/vjjufDCC/nkk0+YMmUKAwcOZPny5Z79L7roIiZPnszAgQN55plnPH+D//73v4wePZqHHnqItLQ0zjzzTAAOHz7MOeecw8iRI5k0aZJnAL677rqLyy67jNTUVPr162dJpJ3adbiAm9/4hpkPfUbadwe47pQBLL11GlenDrBnC5pZ+/5rfng77Ftf66rI8jIIbkLxu42A0+6tc/W3337L2LFjqy2Li4vjuOOOY9u2bYAzA9uGDRuIiopi/PjxnHHGGdx7771s2LDBM0FPzRFB6xu2esGCBdx+++3Vtr/++uuZOnUqb7/9NuXl5eTl5bFq1SpeeOEFvv76a1SViRMnMnXqVBITE9m6dSsLFizgmWee4fzzz+ett95izpw53HvvvezYsYPw8HCfhtfetm0bb7zxBs8//zzjx4/n1VdfZdmyZbz77rvcc889LFq0CIB169bx1VdfkZ+fz5gxYzx/g3vvvZd///vfQPVnHu68807GjBnDokWL+PTTT7n44os9f6vNmzezZMkScnNzGTRoEFdddRWhoW1/DBoDB3KKePTTbSxc8YMz78eUFK5K7d8qhphur6ymEAAzZswgKSmJyMhIZs+ezbJlDc+gVDlsdZcuXY4atvqHH344avtPP/2Uq666CnBqK/Hx8Sxbtoxzzz2X6OhoYmJimD17Np9//jkAKSkpjB49Gqg+TPXIkSO58MILefnll32aMS4lJYURI0YQFBTEsGHDmD59OiLCiBEjqiW6WbNmERkZSefOnZk2bZqnFlGXZcuWcdFFFwFwyimnkJmZ6Rlg74wzziA8PJzOnTvTtWtX9u/f32CcpnU7kl/CXz7YxMl/XcKC5T9w/rjeLL1lGnecOdQSgp+175pCPVf0hX4aY2fo0KFH3QvIycnhhx9+YMCAAaxevbpJQ0v7Omx1U9UcXruy+ehf//oXS5cu5b333uPPf/4z69evr3Po78bE6Y/htStjtyG2267colKeW7aDZz/fQX5JGeeO7skNPx5InyR74KylWE2hmU2fPp2CggLmz58PODO83XTTTcydO5eoqCgAPv74Yw4fPkxhYSGLFi1iypQpxMbGkpub26xxPPnkk54YsrOzOemkk1i0aBEFBQXk5+fz9ttv1zu9ZUVFBbt27WLatGncd999ZGdnk5eXR9++fT1DcnsP/d0Y77zzDkVFRWRmZpKWlsb48eOJjY0lLy+v1u0rhwYHp1mpc+fOxMXFNfp3TetUWFLOPz7bzsn3L+HhT7byowGd+eg3J/Pgz0dbQmhh7bumEAAi4hnK+o9//CMVFRWcfvrp3HPPPZ5tJkyYwHnnnUdGRgZz5szxjCg6ZcoUhg8fzmmnncY11xzbdNV///vfueKKK3juuecIDg7mySefZPLkycydO5cJEyYA8Ktf/YoxY8bUOaNZeXk5c+bMITs7G1Xl+uuvJyEhoc6hvxtj5MiRTJs2jUOHDvH73/+eHj160KVLF4KDgxk1ahRz585lzJgxnu0rbyiPHDmSqKgoXnzxxSb9XUzrUlJWwcIVP/DYp9s4kFvM1OO7cPPMQYzoFR/o0DosGzq7hc2bN4+VK1fy2GOPNdsxW9PQ2b646667qs3X7M2Gzm59/FGWsvIK3l6zm78v3krGkUIm9O3EzT8ZxISUTs36OzXZfxeHDZ1tjGkVKiqUDzfs48GPv2P7wXxG9Iznz+eO4OSBnW18olbCkkILmzt3LnPnzg10GAF11113BToE08JUlbTvDvLXj75j494cBnaN4ak5J/CTYd0sGbQylhSMMX713+2ZPPCf71i18wjHdYriwfNHMWt0T4JtsLpWyZKCMcYv1u7K4oGPvmPZtkN0i4vgz+cO5/xxvQm1sYlaNUsKxphmtXlfDn/7zxY+3rifTtFh3HHGEOZM6kNEqI1N1BZYUjDGNIv0Q/k89MkW3v1mDzHhIdw043gu/VEKMeF2mmlLrB7nB8HBwYwePZrhw4dz1llnecYMSk9PJzIyktGjRzNq1ChOPPFEvvvuO89+H374IePGjWPo0KGMGTOGm266KUAlaF42LHj7tierkNvfWsf0Bz/jP9/u58qp/fn81mlcN32gJYQ2yJKCH0RGRrJ27Vo2bNhAp06dePzxxz3r+vfvz9q1a/nmm2+45JJLPA+1bdiwgWuvvZaXX36ZjRs3snLlSgYMGBCoIjQrGxa8fTqYW8zd731L6l/T+Ofq3Vw0qQ+f3ZrKbacOJiEqLNDhmSaypOBnkydPZvfu3bWuy8nJITExEYD777+f3/3udwwePBhwahuVA9p5y8vL49JLL2XEiBGMHDmSt956C4AFCxYwYsQIhg8fzm233ebZPiYmht/97neMGjWKSZMmeQaLe+ONNxg+fDijRo3i5JNPBpwH66699lrPvmeeeaZnpNKYmBhuueUWhg0bxo9//GOWL1/uGa763Xff9ezf2GHBi4qKPOUZM2YMS5cu9Rxr9uzZnHrqqQwcOJBbb721CX994w/ZBaXc/+/NnHz/Eub/dyfnjunJkltSuevsYXSNjQh0eOYYteu63X3L72Pz4c21risvLyc4uPE3vgZ3GsxtE25reEP3NxYvXszll1/uWVZ5cszNzaWgoICvv/4acGoKvjQX/fGPfyQ+Pp71650hwY8cOcLevXu57bbbWLVqFYmJicycOZNFixZxzjnnkJ+fz6RJk/jzn//MrbfeyjPPPMMdd9zBH/7wBz766CN69uzp05DY+fn5nHLKKfz1r3/l3HPP5Y477uDjjz9m48aNXHLJJZx99tlA44cFf/zxxxER1q9fz+bNm5kxYwZbt24FYO3ataxZs4bw8HAGDRrEddddR+/evX350xs/yC8u44UvdvCPpd+TW1TG2aN68JsfD6Rfl5hAh2aakdUU/KCwsJDRo0fTrVs39u/fz4wZMzzrKpuPtm/fzsMPP8wVV1zRqGN/8skn1cZFSkxMZPXq1aSmptKlSxdCQkK48MILPVfcYWFhnolqvIfEnjJlCnPnzuWZZ56hvLy8wd8NCwvj1FNPBZzhuqdOnUpoaOhRQ2I3dljwZcuWMWfOHAAGDx5M79692bJlC+AM6hcfH09ERARDhw5l586dvv2RTLMqKVeeW7aDk+9fwgP/2cLElCQ+vOEkHrlgjCWEdqhd1xTqu6L353hBlfcUCgoK+MlPfsLjjz9e61zDZ599tmeGtmHDhrFq1SpGjRrVrLGEhoZ6nhj1Hlb6qaee4uuvv+Zf//oXY8eOZdWqVfUOie19HBsSu+P4ZON+bv+8kMNFG5kyIImbZg7ihOMSAx2W8SOrKfhRVFQUjzzyCH/7299qPaEtW7aM/v37A3DLLbdwzz33eK6SKyoqeOqpp47aZ8aMGdVuXB85coSxY8fy2WefcejQIcrLy1mwYAFTp06tN7bt27czceJE/vCHP9ClSxd27dpF3759Wbt2rWfI7IYmvqlNY4cF9x4Se8uWLWRkZDBo0KBG/65pfs8v28GvX1pJTKjw6q8n8sqvJllC6AD8XlMQkWBgJbBbVc8UkRRgIZAErAIuUtUSEQkH5gNjgUzg56qa7u/4/G3MmDGMHDmSBQsWcNJJJ3nuKagqYWFhPPvss4AzlPTDDz/MBRdcQEFBASLiafbxdscdd3DNNdcwfPhwgoODufPOO5kxYwb33nsv06ZNQ1U544wzmDVrVr1x3XLLLWzduhVVZfr06Z4aSkpKCkOHDmXIkCGccMIJjS5vY4cFv/rqq7nqqqsYMWIEISEhPPnkk9VqCKbllVcof3x/I/O+TOcnw5KZ3SOXE/t3DnRYpqWoql9fwG+BV4H33e+vA79wPz8FXOV+vhp4yv38C+C1ho49duxYrWnjxo1HLatNTk6OT9u1Ba2lLC+88IJec801x3QMf5XF138XzWXJkiUt+nvNJb+4VC+ft0L73Pa+/vG9b7WsvKLNlqU2bbksFRUVeiD/gH615yt9ddOr+upHrzb5WMBKreO86teagoj0As4A/gz8VpwG5lOAX7qbvAjcBTwJzHI/A7wJPCYi4hbAGONnB3KL+NWLK9mwO5s/zBrGxZP7BjqkDqm8opzdebvZkb2D77O/97x2ZO0gt7SqGXZ24my//L5fJ9kRkTeBvwCxwM3AXOArVR3gru8NfKiqw0VkA3Cqqma467YDE1X1UI1jXgFcAZCcnDx24cKF1X4zPj7ep4e+mtoltTWysjRs27ZtZGdnN/tx65KXl0dMTNvpmbM7r4IHVxaRW6pcPSqc0V2rrhfbWlnq05rKUqqlHCg9wL7Sfewv3e95P1B6gDKq7kHGBsXSLbQbyaHJnvfk0GRCCkOa3Flm2rRpLT/JjoicCRxQ1VUiktpcx1XVp4GnwZl5rebMQ5s2bSImJqbBXi9tbbay+lhZ6qeqREREVJve09/a0gxfX247xL0vryIiNIy3fjX+qKkw21JZGhKIsuSW5DpX+1nfV7v63523mwp1evsJQo+YHvTv2p8Z8TPol9CPfvH9SIlPIT689qlJ/VUWfzYfTQHOFpHTgQggDvg7kCAiIapaBvQCKh/33Q30BjJEJASIx7nh3CgRERFkZmaSlJRkk3cYVJXMzEwiIuxJ29q8tSqD2/+5jpTO0Tw/dzy9EqMCHVKbpKocKjxU1dzjlQAOFh70bBcSFELfuL4M7jSY01NOp198P/ol9KNPXB8iQyIDWIIqfksKqvq/wP8CuDWFm1X1QhF5A/gpTg+kS4B33F3edb//113/aVPuJ/Tq1YuMjAwOHjxY73ZFRUXt5kRhZalfREQEvXr1atZjtnWqyt8Xb+XhT7YyZUAST1w4lvjI0ECH1eqVV5SzJ29Ptbb+2tr7o0OjSYlLYXKPyaTEpzgn//h+9IrtRUhQ6348LBDR3QYsFJE/AWuA59zlzwEvicg24DBOD6RGCw0NJSUlpcHt0tLSWrQ5wZ+sLKYxSsoquP2f6/jn6t38dGwv7jl3BGEh9siSt+LyYnbm7PSc8CtP/unZ6ZRUlHi2S4pIol9CP07vd3q1k3/XqK5ttqWiwaQgIvep6m0NLauPqqYBae7n74EJtWxTBPzM12MaYxovu6CUK19exX+/z+S3M47nulMGtNmTV3NoTHt/v/h+TO4+2af2/rbMl5rCDJyre2+n1bLMGNOK7TpcwKXzVrAzM5+Hfj6Kc8fU3aRWXlHOrtxdbM/azrKcZezZtAdwhi0RnCTiea9laJO6tqn8Xtsyn7apa1tpeBtB+CL3C7746os2297fEupMCiJyFc4DZf1EZJ3XqljgC38HZoxpPusysrhs3kpKysqZf9lEJvdPAqr6xG/L2sb2rO2e9x3ZO6o1k9D4EU9arejcaOeqvw2297eE+v4CrwIf4jxncLvX8lxVPezXqIwxzeY/3+7jhoWrSYzP56ZTY9lYsIj3PncSwI7sHRSVVw182C26G/0T+jOp+yT6J/RnQMIAdqzbwY+m/KhyhAKUqv4fNZfVtk3N5XVu63mr+5h1blszjhrLK5dtXr2ZWdNndegms4bUmRRUNRvIFpE7gH2qWuz2IhopIvNVNatlQjTG+EpV2Zu/13PF/+8ta1l/YAuh/Q+SK8Xcs8rZrmtUVwYkDGBct3EMSBhA/4T+9I/vT0zY0Q92ZQZn0imiUwuXxD/2heyzhNAAX+pKbwHjRGQAzkNj7+DUIk73Z2DGmLqpKvsL9h/V7LM9azsFZQWe7SrKYukU2ZvTjj+ZQUkDGZAwgH4J/YgLiwtg9KY18yUpVKhqmYjMBh5V1UdFZI2/AzPGOCf/g4UHq530Kz/nleZ5tusU0YkBCQOYNWAWx8X04/2VFXz1XSiXTR7G784YQnCQXR0b3/iSFEpF5ALgYuAsd5k95WKOSWlFKbtyd7Eje4fntTNnJzk5OSz8ZCGxobHEhMUQGxpLdGi08zkslpjQGOflrosJc76HBrftf5KqSmZR5lFX/tuytpFbUvVQVGJ4Iv0T+nNGvzM8zT4DEgaQGOHMc3Awt5hfvbiC9buzuevMocyd0vAzO8Z48yUpXApcCfxZVXe48yG85N+wTHuRW5JLenY6O3J2ePqC78jZwa6cXZRp1aBfXaO60jeuL2ESRnZRNrtzd5Nbkkt+aX61G6F1CQ8OJybUSRyeJOKVNCrfK9d71lWuD40hMiSyRdqbDxcdrnbi33pkK9uzt5NdXDVgX3x4PP3j+3Na39M8J/7+Cf1Jikyq87jbDuQy94UVZOaV8I+LxjFjaLLfy2LanwaTgqpuFJGbgeNFZDjwnare5//QTFtR2b79ffb31a78d2TvOKof+HGxx9E/vj8/Pu7HpMSnkBKfQt+4vp4bnLUN8lVaXkpeaR55JXnOe2keuSW51ZeV5JFbmkt+ST65pbnkleSRWZhZbZuGBEtwtSThqamERXsSSrV17vfo0Gjnc1gM0SHRBAc5o7xmFWVVv/LPdpp/DhdVdd6LDY2lf4Lz9xiYONCTAJIiGjd215fbD3HlS6sICwnmtf+ZxMheCT7va4w3X55oTsWZ9yAdEKC3iFyiqkv9GplpdUrKS/gh54eqk39O1cm/sKzQs11saCwpCSmc2ONE+iX0IyXOOfn3jO1JaFDjm3lCg0NJDE70NJE0RYVWkF+aT35pviehVNZE6koweSV57C/YT25W1Xrv2k1dokKioAIKdlbd8I0OjaZ/Qn9Se6fSP77qyr85hkP45+oMbntrHX2TnEHteneyQe1M0/nSfPQ3YKaqfgcgIscDC3CmzTTtUHZxtudk7331n5GX4Xn0H6BHdA9S4lM4YeAJnqv+lPiURl/ltoQgCSI2LJbYsFi6RXdr0jFUleLy4qqailfNJa/EK8mU5rLjhx1MGlzV1z85KrnZ/yaqyiOLt/HQJ1s4sX8ST86xQe3MsfMlKYRWJgQAVd0iIvYvr42r0Ar25O2paupx2/zTc9KrNW+EBYXRJ74PQ5KGOIN+uVf9feL6EBXasa5IRYSIkAgiQiLoHFn/nMVp+WmkDkv1WywlZRX87z/X89bqDM47oRd/mW2D2pnm4UtSWCkizwIvu9/nACv9F5JpToVlhezM2XlUW396TjrF5cWe7RLDE0mJT2Fa72nVrvp7RPfwtJGb1iG7sJSrXl7Fl9szufHHx3P99I49qJ1pXr4khauAa4Dr3e9LceZUNq2EqpJZmFntin9Hzg7Ss9PZk7fH88i/IPSM6Um/hH5M6j6p2sn/WNrrTcvJOFLApS+sID0zn7/9bBTnjbV5Ikzzqm9AvC5AF1XdCDzovhCRYTizqNU/i43xKK8op7i8mKLyIorL3PfyYorKnPfKz0XlRUctq/butb/3dnty9lDwetVNzciQSPrG9WVkl5GcM+Acz4m/T1wfwoPDA/iXMMdiXUYWl7+4kqLScl68bAIn9q+/CcuYpqivpvAo8EQtyzsBvwN+6ZeIWkB5RTlFFUVkFmZWO9kWlxdTWFZ41LLaTsreJ3LPdjXWV34urShtcqwRwRGEh4QTHhxOZEgk4cHhnmWJoYlEBEeQXJbMj4b8yDPiY3J0MkFi7cvtyScb93PdgjV0ig7j1V9NZGBy+5iT27Q+9SWFAbV1O1XVz0WkTTcfvfDtC/x9199hV+P2E5wbjeHBzkk6IiTCc4KOCI4gKTTpqPXVtvNe5nWyjwiOqHasyu3CgsJ8aitOS0sjdWhq0/4YptV78ct07n7vW4b3jOfZS8bRNbZ9TL1qWqf6kkJ9lyJtuvfRhG4TOCfhHIYOGuo5WVee2Gs9mbvrQoNC7YaeaTHlFco9H2ziuWU7mDE0mb//YjRRYTbev/Gv+v6FbROR01X1A++FInIa8L1/w/KvkV1Gcjj+MKmDUwMdijG1Kiwp5zevreGjb/dz6ZS+3HHGUBvUzrSI+pLCb4B/icj5gDsKO+OAycCZfo7LmA7rYG4xv5q/knUZWfy/M4dy2Y9sUDvTcuqbZGeriIzAuaE83F38GfA/qtrwCGXGmEbbdiCPS+ct52BuMf+YM5aZw5r29LUxTVVvA6WqFgMvtFAsxnRoX32fyRXzVxIWEsRrV0xmVO+EQIdkOiC7a2VMK/D2mgxufXMdfZKiecEGtTMBZEnBmABSVR79dBsPfryFSf068Y8544iPatOd+0wb1+ATTiJylog9CWVMcystr+DWN9fx4MdbmD2mJ/Mvm2gJwQScLyf7nwNbReR+ERns74CM6Qhyikq59IUVvLEqgxumD+Rv54+yUU5Nq+DLzGtzRCQOuACYJyKKc/N5garm1r+3MaamjCMFXDZvBd8fzOeBn43ipzaonWlFfLo0UdUc4E1gIdAdOBdYLSLX+TE2Y9qd9RnZnPvEl+zNLmL+ZRMsIZhWx5fpOGcBc4EBwHxggqoeEJEoYCPOwHnG+Ky0vIK9WUVkZBWQcaSQ3UcK2Z1VyJ6sQgpyivjo8HqS48JJjouga6z7HhdOUnR4m36qd/Gm/Vz7qjOo3Su/msjxNqidaYV86X00G3io5uB4qlogIpf7JyzTlhWVlrMnq9A54WcVknGkgN1Hqr7vzymiQqu2F4Hk2Ai6J0SQWaR8vHEfh/JKjjpucJDQOSbMkyy6xkWQHOskjOS4cLrGtt7k8dJ/07nzXRvUzrR+viSFfTUTgojcp6q3qepiP8VlWrH84jJ2ZxW6J/oCMioTgHvSP5hbXG374CChW1wEvRIjmdw/iV6JUfRKiKRnYiS9EiPpHh/pucmalpZGamoqJWUVHMor5kBuMftzijiQU+T5vD+nmN1ZRaz5IYvM/NqTR5cYJ1F0iY2otdbRNTaCpOgwgvycPCrcQe2eXbaDHw9J5pELbFA707r58q9zBnBbjWWn1bLMtBPZhaWeq/vdXif8jCxn2ZGC6vNDhAUH0SMhgp6JkZwyqKvnZN8zIZJenaJIjg0nJLhxPWvCQoLokRBJj4TIererTB6VyeJgrvO+P6eI/bnFZBwpYPUPRzhcS/IICRK6xIZX1TrcZJEc53yvTCKdopqWPApLyrnxtbX8+9t9zD2xL78/0wa1M61ffTOvXQVcDfQXkXVeq2KBL/wdmPEPVeVwfkm1k31lE0/l99zismr7RIQGOSf4xChG9kqoOuEnRtErMZIuMeF+v+KuS2OSx8G82msdB3KL2XW4gJXph49KeOCVPOIiSI4Nd5qrYiNIjougi+dzOIleySOnWLngma/4JiOL3585lMttUDvTRtRXU3gV+BD4C3C71/JcVT3c0IFFJAJnPudw93feVNU7RSQFpxdTEs7oqxepaomIhOPcyB4LZAI/V9X0xhepY6uoUA7lFbOrRnu+dxIoLC2vtk9MeIjnRD8xpZN7pR/lnvgj6RTt22Q/rVlYiJPYejaQPIrLyjmYW3xUraMyiezMLGBFPcmjstax80AhhRVFPHnhWE4dboPambajvqSgqpouItfUXCEinXxIDMXAKaqaJyKhwDIR+RD4Lc6N64Ui8hRwOfCk+35EVQeIyC+A+3AenDOu8gol07ud3X1fvbmYZ7d97WnnLymvqLZfQlQovRIj6d8lmpMHdnESgNvE0yshirjIkDZ/0m8u4SHBbg2o/rGHikqd5HEgt5gDOUVe/z2KOZBbRNco4b5fTma0DWpn2piGagpn4lzNK+B91lCgX30HVlUF8tyvoe5LgVOomt/5ReAunKQwy/0MzjMRj4mIuMdp18rKK8jML3GbNorZn+u8H/C8Oyf/Q3nF1XrtVIoLg5TkMob2iGPm0GSvNv0oeiZGEhNuNzabW0RoML07RdU5cF1aWpolBNMm1Tefwpnue5MbQ0UkGCepDAAeB7YDWapa2WidAfR0P/fEnTVZVctEJBunielQU38/0ErL3R40Xk0Q3u3ZB9wrzUN5xdRMfSKQFB3m6T0zpHtsta6YlTdBO8eE8+WypaSmTglMIY0x7Yo0dCEuIucCn6pqtvs9AUhV1UU+/4izz9vA74F5qjrAXd4b+FBVh4vIBuBUVc1w120HJqrqoRrHugK4AiA5OXnswoULfQ2jmry8PGJiYpq0b1mFkl2sZNV8FXkvryC3xKkaVYsfiA0TEiOE+HAhoeYrwnmPCxNCfLx5eyxlaW3aS1naSznAytJaHUtZpk2btkpVx9W2zpd2hTtV9e3KL6qaJSJ3Aot8DcDdZwnOVJ4JIhLi1hZ6AbvdzXYDvYEMEQkB4nFuONc81tPA0wDjxo3T1NRUX8OoprI/vLfKm4xHXdF7NeEczC2utW98kEDnGKdnysDOVX3hK3uqdHX7yidFhzW6e2ZTytJWtZeytJdygJWltfJXWXxJCrWdwXwZHqMLUOomhEic5x3uA5YAP8XpgXQJ8I67y7vu9/+66z/11/2ElemHeXNLCe8f/MZzot+fU1Rrj5LKB6G6xoXTKzGSE/okVj0E5fWeFNP6nqI1xpjG8iUprBSRB3HuCQBcg3OfoCHdgRfd+wpBwOuq+r6IbAQWisifgDXAc+72zwEvicg24DDwi0aUo1G+ycjmwx2ldM08RNe4CHp3imJsn8RqJ/oulQ8uRYfZyd4Y02H4khSuw7kX8Jr7/WOcxFAvVV0HjKll+ffAhFqWFwE/8yGeY3bRpD6klKZzyrRpLfFzxhjTZvgyn0I+1R9ea/PCQoIIsn75xhhzlPqGuXhYVX8jIu9xdCcaVPVsv0ZmjDGmxdVXU3jJfX+gJQIxxhgTePU9vLbKvUl8hape2IIxGWOMCZB6O8yrajnQR0TCWigeY4wxAeRL76PvgS9E5F0gv3Khqj7ot6iMMcYEhC9JYbv7CsKZSwFqufFsjDGm7fMlKWxU1Te8F4hIizxPYIwxpmX5MgjP//q4zBhjTBtX33MKpwGnAz1F5BGvVXFAWe17GWOMacvqaz7aA6wEzqb6WEe5wI3+DMoYY0xg1PecwjfANyLyNpDvdk+tnDgnvIXiM8YY04J8uafwH8B7tvNI4BP/hGOMMSaQfEkKEapaOdcy7uf6ZzU3xhjTJvmSFPJF5ITKLyIyFij0X0jGGGMCxZfnFH4DvCEie3CmGO4G/NyfQRljjAkMX+ZTWCEig4FB7qLvVPXoeSuNMca0eQ02H4lIFHAbcIOqbgD6isiZfo/MGGNMi/PlnsILQAkw2f2+G/iT3yIyxhgTML4khf6qej9QCqCqBTj3FowxxrQzviSFEhGJxB0ZVUT6A8V+jcoYY0xA+NL76E7g30BvEXkFmALM9WdQxhhjAsOX3kcfi8hqYBJOs9ENqnrI75EZY4xpcfWNknpCjUV73ffjROQ4VV3tv7CMMcYEQn01hb/Vs06BU5o5FmOMMQFW3yip01oyEGOMMYFXZ+8jEbnV6/PPaqy7x59BGWOMCYz6uqT+wutzzek3T/VDLMYYYwKsvqQgdXyu7bsxxph2oL6koHV8ru27McaYdqC+3kejRCQHp1YQ6X7G/R7h98iMMca0uPp6HwW3ZCDGGGMCz5exj4wxxnQQlhSMMcZ4+C0piEhvEVkiIhtF5FsRucFd3klEPhaRre57ortcROQREdkmIutqGWbDGGOMn/mzplAG3KSqQ3EG07tGRIYCtwOLVXUgsNj9DnAaMNB9XQE86cfYjDHG1KK+AfFyqb3rqQCqqnH1HVhV9+IOoqequSKyCegJzAJS3c1eBNJwpvucBcxXVQW+EpEEEenuHscYY0wLEOcc7OcfEekLLAWGAz+oaoK7XIAjqpogIu8D96rqMnfdYuA2VV1Z41hX4NQkSE5OHrtw4cImxZSXl0dMTEzTCtTKWFlan/ZSDrCytFbHUpZp06atUtVxta3zZZIdAESkK17PJ6jqDz7uFwO8BfxGVXOcPOA5hopIo7KSqj4NPA0wbtw4TU1NbczuHmlpaTR139bGytL6tJdygJWltfJXWRq8pyAiZ4vIVmAH8BmQDnzoy8FFJBQnIbyiqv90F+8Xke7u+u7AAXf5bqC31+693GXGGGNaiC83mv+Ic6N4i6qmANOBrxrayW0aeg7YpKoPeq16F7jE/XwJ8I7X8ovdXkiTgGy7n2CMMS3Ll+ajUlXNFJEgEQlS1SUi8rAP+00BLgLWi8had9n/AfcCr4vI5cBO4Hx33QfA6cA2oAC41PdiGGOMaQ6+JIUs977AUuAVETkA5De0k3vDuK7RVKfXsr0C1/gQjzHGGD/xpfloFlAI3Aj8G9gOnOXPoIwxxgRGgzUFVfWuFbzox1iMMcYEWINJocZDbGFAKJDf0MNrxhhj2h5fagqxlZ/dHkWzcHojGWOMaWcaNfaROhYBP/FPOMYYYwLJl+aj2V5fg4BxQJHfIjLGGBMwvnRJ9e5pVIbzRPMsv0RjjDEmoHxJCs+q6hfeC0RkClXDUxhjjGknfLmn8KiPy4wxxrRx9c2nMBk4EegiIr/1WhUHBPs7MGOMMS2vvuajMCDG3SbWa3kO8FN/BmWMMSYw6kwKqvqZiCwDRqrq3S0YkzHGmACp956CqpYDPVooFmOMMQHmS++jtSLyLvAGXqOjek2aY4wxpp3wJSlEAJnAKV7LFLCkYIwx7YwvYx/ZZDfGGNNB1Ncl9VZVvV9EHqVqlFQPVb3er5EZY4xpcfXVFDa67ytbIhBjjDGBV19SOE1EjqiqTaxjjDEdRH1dUrcAD4hIuojcLyJjWiooY4wxgVFnUlDVv6vqZGAqTu+j50Vks4jcKSLHt1iExhhjWkyDA+Kp6k5VvU9VxwAXAOcAm/wdmDHGmJbXYFIQkRAROUtEXgE+BL4DZjewmzHGmDaovi6pM3BqBqcDy4GFwBWqml/XPsYYY9q2+nof/S/wKnCTqh5poXiMMcYEUH2jpJ5S1zpjjDHtky8zrxljjOkgLCkYY4zxsKRgjDHGw5KCMcYYD0sKxhhjPCwpGGOM8bCkYIwxxsNvSUFEnheRAyKywWtZJxH5WES2uu+J7nIRkUdEZJuIrBORE/wVlzHGmLr5s6YwDzi1xrLbgcWqOhBY7H4HOA0Y6L6uAJ70Y1zGGGPq4LekoKpLgcM1Fs8CKifteRFnxNXK5fPV8RWQICLd/RWbMcaY2rX0PYVkVd3rft4HJLufewK7vLbLcJcZY4xpQfUNiOdXqqoioo3dT0SuwGliIjk5mbS0tCb9fl5eXpP3bW2sLK1PeykHWFlaK7+VRVX99gL6Ahu8vn8HdHc/dwe+cz//A7igtu3qe40dO1abasmSJU3et7WxsrQ+7aUcqlaW1upYygKs1DrOqy3dfPQucIn7+RLgHa/lF7u9kCYB2VrVzGSMMaaF+K35SEQWAKlAZxHJAO4E7gVeF5HLgZ3A+e7mH+BM5rMNKAAu9Vdcxhhj6ua3pKCqF9Sxanot2ypwjb9iMcYY4xt7otkYY4yHJQVjjDEelhSMMcZ4WFIwxhjjYUnBGGOMhyUFY4wxHpYUjDHGeFhSMMYY42FJwRhjjIclBWOMMR6WFIwxxnhYUjDGGOMRsEl2jDHGNEF5GRzYSGhJll8O3zGTQnkZUlEGqiAS6GiMMaZuBYchYwXsWg67vobdq6E0ny4D/4eqae6bT8dMCl89ztSl/w+WAkGhEBwGwd7vlZ/d7/VuU9v6MAgOaeAYvmxT4z0oFIKOocVPFbQCKspBy2u817Vca1lWDhUVtS9XPYbjV9AzYyes3AEhERAaASGRdb+HhENopPP3MaY9qKiAg5shY7mbBJZD5lZnnQRDt+Ew5kLoNYFDe4M53g8hdMykcNyJfJ9yIf2O6wXlJVBe6r5Kqt4rvJeVOFW2knwoP1L/NpXL/UWCqyeS4FAmlZTAytCGT9o0ekrsFjcQnKmWGkOCneQQEuH1XiNxVFtX470xCahyv6BgP5TedDhF2ZCx0jn5ZyyHjFVQnO2si+wEvSfC6Auc9x5jICzas2vJ4TS/hNQxk0Lv8fzQJ59+qan+Ob6qkywqaiQa78RRufyobWokmooa29eyzZG9e+jeo6dzcgwK9noPqvG98l1qWRbs1EJqWy5Sx3Ga6fhBQc6xJJhlS5fwo4ljobQQyoqhrBBKi7zei9x1Xu9lRTW2qfFenFO1r/e25SVN/28cFFpvAhqeUwSFH0Ji36pXQh8Ii2qmf2SmzVGFQ1ur1wIObgbU+fffdSgMn+0kgN4ToFO/gDRvd8yk4G8iEBIGhAHRDW19zL5LS6O7vxJcCysLjYW4Hi3zYxXltSeUsuKjE0+t77UlrUIoLSSiaD+seRlK8qr/Zkxy9UTh/YrpdmzNg6Z1Kc6D3au8agEroPCIsy4iHnqNd5JAr/HQcyxExAU2XpclBdNxBQU71fGw5k/cK9PSSJ061blJeGQHHEn3et8JO7+Eda9TrUkvOBwS+9SeMBL6QHhMs8dpmomq89+3sgaQsRz2f+vcSwPoMhgGn+nUAHpPhKSBrfYCwJKCMf4iAtFJzqvXuKPXl5VA9i6vZOH12vlfKMmtvn10l7prGbE9Wu1Jpl0qKYA9a6o3BRUcctaFxUKvsXDSzU4C6DUWIhMDG28jWFIwJlBCwiCpv/OqSdVpaqgtYez6Gja8VXUVCk7Hg4Tj6k4a4bH+Lk37peokb+9awL71zv0+gE79YeBM6D0eek2ArkPadEcESwrGtEYiENXJefUce/T68lK3lpFeS9JYUdWDpVJUUo1EkVL1Oa5Hmz6JNbvSItj7TfVaQN4+Z11olPPf48Tr3VrAeKcm2I5YUjCmLQoOdXqndOpX+/rCI7UnjN2r4NtFTjflSkGh9dQy+vixEK1Ezh63BrDCqYXt/aaqZ1pCH0g5qSoBJA93ni9qx9p36YzpqCITnVePMUevKy+DnIzak8ae1VU9ZFwnBUXAVxG1P3QZFNLA8tDqD1/W9gBocyz3fvCznm6cUlFW1SOoMhFk73JWBoc7f6+JVzo3hHtNgNjkZvoP0nZYUjCmowkOqaoJ1KYwC7J2ehLFnk2r6N2jWy0PbNb4XFroPIxVc3lFze2L/Vs+74QUVD15/OjID7DUrQXE9XLuA0y62qkJdBvhdiXv2CwpGGOqi0xwXt1HAbC9NI3ezfkcTOVQKEcli7qSSH0PejZunz2RQ+g9+TynFhDfs/nK1I5YUjDGtCwRt6kpxHkCvAVtT0uj97DUFv3NtsY6NhtjjPGwpGCMMcbDkoIxxhgPSwrGGGM8LCkYY4zxsKRgjDHGw5KCMcYYD0sKxhhjPES19c/bWxcROQjsbOLunYFDzRhOIFlZWp/2Ug6wsrRWx1KWPqrapbYVbTopHAsRWamqtcx80vZYWVqf9lIOsLK0Vv4qizUfGWOM8bCkYIwxxqMjJ4WnAx1AM7KytD7tpRxgZWmt/FKWDntPwRhjzNE6ck3BGGNMDZYUjDHGeHTIpCAip4rIdyKyTURuD3Q8TSUiz4vIARHZEOhYjoWI9BaRJSKyUUS+FZEbAh1TU4lIhIgsF5Fv3LLcHeiYjpWIBIvIGhF5P9CxHAsRSReR9SKyVkRWBjqephKRBBF5U0Q2i8gmEZncrMfvaPcURCQY2ALMADKAFcAFqroxoIE1gYicDOQB81V1eKDjaSoR6Q50V9XVIhILrALOaaP/TQSIVtU8EQkFlgE3qOpXAQ6tyUTkt8A4IE5Vzwx0PE0lIunAOFVt0w+viciLwOeq+qyIhAFRqprVXMfviDWFCcA2Vf1eVUuAhcCsAMfUJKq6FDgc6DiOlaruVdXV7udcYBPQJifQVUee+zXUfbXZKy8R6QWcATwb6FgMiEg8cDLwHICqljRnQoCOmRR6Aru8vmfQRk9A7ZGI9AXGAF8HOJQmc5tb1gIHgI9Vtc2WBXgYuBWoCHAczUGB/4jIKhG5ItDBNFEKcBB4wW3Se1ZEopvzBzpiUjCtlIjEAG8Bv1HVnEDH01SqWq6qo4FewAQRaZNNeyJyJnBAVVcFOpZm8iNVPQE4DbjGbX5ta0KAE4AnVXUMkA80633RjpgUdgO9vb73cpeZAHLb398CXlHVfwY6nubgVuuXAKcGOJSmmgKc7bbFLwROEZGXAxtS06nqbvf9APA2TlNyW5MBZHjVPt/ESRLNpiMmhRXAQBFJcW/S/AJ4N8AxdWjuzdnngE2q+mCg4zkWItJFRBLcz5E4HRo2BzSoJlLV/1XVXqraF+f/k09VdU6Aw2oSEYl2OzHgNrfMBNpcrz1V3QfsEpFB7qLpQLN2yAhpzoO1BapaJiLXAh8BwcDzqvptgMNqEhFZAKQCnUUkA7hTVZ8LbFRNMgW4CFjvtsUD/J+qfhC4kJqsO/Ci28stCHhdVdt0V852Ihl427n+IAR4VVX/HdiQmuw64BX3ovZ74NLmPHiH65JqjDGmbh2x+cgYY0wdLCkYY4zxsKRgjDHGw5KCMcYYD0sKxhhjPDpcl1RjmoOIlAPrccY2KgPmAw+pansYDsJ0YJYUjGmaQncoC0SkK/AqEAfcGcigjDlW1nxkzDFyh024ArhWHH1F5HMRWe2+TgQQkfkick7lfiLyioi0yRF6TftlD68Z0wQikqeqMTWWZQGDgFygQlWLRGQgsEBVx4nIVOBGVT3HHQJ5LTBQVctaOHxj6mTNR8Y0v1DgMREZDZQDxwOo6mci8oSIdAHOA96yhGBaG0sKxjQDEemHkwAO4NxX2A+MwmmiLfLadD4wB2eAuWYds8aY5mBJwZhj5F75PwU8pqrqNg1lqGqFiFyCM/BipXnAcmBfW5xu1LR/lhSMaZpId0TXyi6pLwGVw34/AbwlIhcD/8aZCAUAVd0vIpuARS0arTE+shvNxrQgEYnCeb7hBFXNDnQ8xtRkXVKNaSEi8mNgE/CoJQTTWllNwRhjjIfVFIwxxnhYUjDGGONhScEYY4yHJQVjjDEelhSMMcZ4/H9lhAfF3C8UbwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plt.figure(figsize=(10, 7))\n",
    "\n",
    "bid = 8\n",
    "\n",
    "week = end_time - 24 * 7\n",
    "# pred = np.transpose(look_ahead_cost, [1,2,0])[bid].flatten()[week - end_time:]\n",
    "pred = np.array(look_ahead_cost).T[bid][(week - end_time)//24 : ]\n",
    "\n",
    "true = get_virtual_electricity_rbc(E_grid[bid][week:])\n",
    "true_rbc = get_virtual_electricity_rbc(RBC_cost[bid][week:])\n",
    "\n",
    "# true = np.mean(true.reshape(-1, 24), axis=1)\n",
    "\n",
    "# pred = np.mean(pred.reshape(-1, 24), axis=1)\n",
    "                \n",
    "plt.plot(true, label='True consumption') #plots per month\n",
    "plt.plot(pred, label='Optim consumption') #plots per month\n",
    "plt.plot(true_rbc, label='RBC consumption') #plots per month\n",
    "\n",
    "plt.grid()\n",
    "plt.legend()\n",
    "plt.title(f\"Building {bid + 1}\")\n",
    "plt.xlabel(\"Day\")\n",
    "plt.ylabel(\"Virtual Electricity Cost\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ### Shouldn't have to normalize. But cost is in the order of 1e-9. that's why. \n",
    "# ### See test documentation for more details\n",
    "\n",
    "# bid = 0\n",
    "# x = E_grid[bid][rbc_threshold:]\n",
    "# true = np.mean(x.reshape(-1, 24), axis=1)\n",
    "\n",
    "# pred = np.array(look_ahead_cost).T[bid].astype(np.float)\n",
    "\n",
    "# plt.plot(true, label='True consumption') #plots per month\n",
    "# plt.plot(pred, label='Predicted consumption') #plots per month\n",
    "\n",
    "# plt.legend()\n",
    "# plt.grid()\n",
    "\n",
    "# plt.title(f\"Building {bid + 1} costs\")\n",
    "# plt.xlabel(\"day\")\n",
    "# plt.ylabel(\"Cost\")\n",
    "\n",
    "# plt.show()\n",
    "\n",
    "# print(f\"MSE: {np.sum(np.square(pred - true))}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Create some mock data\n",
    "\n",
    "# fig, ax1 = plt.subplots(figsize=(20,10))\n",
    "\n",
    "\n",
    "# color = 'tab:red'\n",
    "# ax1.set_xlabel('time (hour)')\n",
    "# ax1.set_ylabel('Action', color=color)\n",
    "# # ax1.plot(t, data1, color=color)\n",
    "\n",
    "# for i, actions in enumerate(x):\n",
    "#     ax1.plot(actions, label=list_actions[i])\n",
    "\n",
    "# ax1.tick_params(axis='y', labelcolor=color)\n",
    "\n",
    "# ax2 = ax1.twinx()  # instantiate a second axes that shares the same x-axis\n",
    "\n",
    "# color = 'tab:blue'\n",
    "# ax2.set_ylabel('E_grid', color=color)  # we already handled the x-label with ax1\n",
    "# # ax2.plot(t, data2, color=color)\n",
    "\n",
    "# ax2.plot(true, label='True consumption', color='black') #plots per month\n",
    "# ax2.plot(pred, label='Predicted consumption', color='red') #plots per month\n",
    "\n",
    "# ax2.legend(loc=\"upper right\")\n",
    "# ax1.legend(loc=\"upper left\")\n",
    "\n",
    "# ax2.tick_params(axis='y', labelcolor=color)\n",
    "\n",
    "# fig.tight_layout()  # otherwise the right y-label is slightly clipped\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "bd_actions = []\n",
    "for actions in np.array(actions_arr):\n",
    "    bd_actions.append(actions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(20,10))\n",
    "\n",
    "####\n",
    "bid = 0\n",
    "####\n",
    "\n",
    "x = np.array([*np.array(bd_actions).T[bid]])[:24].T\n",
    "\n",
    "list_actions = ['action_C', 'action_H', 'action_bat']\n",
    "\n",
    "if len(x) == 2:\n",
    "    list_actions = ['action_C', 'action_bat']\n",
    "    \n",
    "    \n",
    "for i, actions in enumerate(x):\n",
    "    plt.plot(actions, label=list_actions[i])\n",
    "    \n",
    "plt.legend()\n",
    "plt.grid()\n",
    "# plt.ylim([-1, 1])\n",
    "plt.title(f\"Building {bid + 1}\")\n",
    "plt.xlabel(\"Timestep (hour)\")\n",
    "plt.ylabel(\"Action\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 ([3.3086240462276077e-06, 0.09305680888219774, 0.004020533210289018], None)\n",
      "1 ([4.2421965758067866e-08, 0.006422445125441899, 0.1359279757654057], None)\n",
      "2 ([-1.150889415336406e-11, 0.08811561933432611], None)\n",
      "3 ([-4.449671615806843e-12, -0.004400000090806397], None)\n",
      "4 ([-0.0981683207582873, 0.6666666879216733, 0.6449518435796185], None)\n",
      "5 ([-0.09704157625667939, 0.3333333454107738, 0.31411878948944727], None)\n",
      "6 ([-0.09666329878941292, 0.5000000172638829, 0.47042477999028526], None)\n",
      "7 ([-0.09895210804836231, 0.3333333434945132, 0.28418474768422836], None)\n",
      "8 ([-0.09910671479896108, 0.3333333433587552, 0.2553973727894045], None)\n"
     ]
    }
   ],
   "source": [
    "#optimization debug -> !!! PROBLEM !!!\n",
    "debug = get_actions(data_est, (t_idx - rbc_threshold) % 24, debug=False, apply_seed=False)\n",
    "for i in range(len(debug)):\n",
    "    print(i, debug[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>c_Csto_start</th>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c_Hsto_start</th>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c_bat_start</th>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c_bat_end</th>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                0    1    2    3    4    5    6    7    8\n",
       "c_Csto_start  0.1  0.1  0.1  0.1  0.1  0.1  0.1  0.1  0.1\n",
       "c_Hsto_start  0.1  0.1  0.1  0.1  0.1  0.1  0.1  0.1  0.1\n",
       "c_bat_start   0.1  0.1  0.1  0.1  0.1  0.1  0.1  0.1  0.1\n",
       "c_bat_end     0.1  0.1  0.1  0.1  0.1  0.1  0.1  0.1  0.1"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame([data_est['c_Csto_end'][0], data_est['c_Hsto_end'][0], *data_est['c_bat_end']], index=[\n",
    "    \"c_Csto_start\", \"c_Hsto_start\", \"c_bat_start\", \"c_bat_end\"\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mess up: 0\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>p_ele</th>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.200000</td>\n",
       "      <td>0.200000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ramping_cost_coeff</th>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "      <td>0.100000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>E_grid_past</th>\n",
       "      <td>153.003494</td>\n",
       "      <td>153.003494</td>\n",
       "      <td>153.003494</td>\n",
       "      <td>153.003494</td>\n",
       "      <td>153.003494</td>\n",
       "      <td>153.003494</td>\n",
       "      <td>153.003494</td>\n",
       "      <td>153.003494</td>\n",
       "      <td>153.003494</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>E_ns</th>\n",
       "      <td>13.760000</td>\n",
       "      <td>2.380000</td>\n",
       "      <td>2.360000</td>\n",
       "      <td>0.440000</td>\n",
       "      <td>7.100000</td>\n",
       "      <td>9.500000</td>\n",
       "      <td>17.700000</td>\n",
       "      <td>9.900000</td>\n",
       "      <td>16.700000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>H_bd</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>4.920000</td>\n",
       "      <td>0.480000</td>\n",
       "      <td>0.360000</td>\n",
       "      <td>1.320000</td>\n",
       "      <td>0.480000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C_bd</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.040000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.320000</td>\n",
       "      <td>0.260000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.040000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>H_max</th>\n",
       "      <td>6.408000</td>\n",
       "      <td>19.728000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>48.096000</td>\n",
       "      <td>32.544000</td>\n",
       "      <td>36.720000</td>\n",
       "      <td>33.840000</td>\n",
       "      <td>29.376000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C_max</th>\n",
       "      <td>131.196000</td>\n",
       "      <td>20.220000</td>\n",
       "      <td>59.772000</td>\n",
       "      <td>57.060000</td>\n",
       "      <td>52.968000</td>\n",
       "      <td>51.912000</td>\n",
       "      <td>48.744000</td>\n",
       "      <td>33.000000</td>\n",
       "      <td>35.040000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>E_pv</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>E_hpC_max</th>\n",
       "      <td>618.119995</td>\n",
       "      <td>227.369995</td>\n",
       "      <td>414.679993</td>\n",
       "      <td>383.565002</td>\n",
       "      <td>244.684998</td>\n",
       "      <td>98.619501</td>\n",
       "      <td>127.820000</td>\n",
       "      <td>165.449997</td>\n",
       "      <td>175.229996</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>eta_hp</th>\n",
       "      <td>0.220000</td>\n",
       "      <td>0.220000</td>\n",
       "      <td>0.220000</td>\n",
       "      <td>0.220000</td>\n",
       "      <td>0.220000</td>\n",
       "      <td>0.220000</td>\n",
       "      <td>0.220000</td>\n",
       "      <td>0.220000</td>\n",
       "      <td>0.220000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>t_C_hp</th>\n",
       "      <td>8.000000</td>\n",
       "      <td>8.000000</td>\n",
       "      <td>8.000000</td>\n",
       "      <td>8.000000</td>\n",
       "      <td>8.000000</td>\n",
       "      <td>8.000000</td>\n",
       "      <td>8.000000</td>\n",
       "      <td>8.000000</td>\n",
       "      <td>8.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>COP_C</th>\n",
       "      <td>0.231192</td>\n",
       "      <td>0.231192</td>\n",
       "      <td>0.231192</td>\n",
       "      <td>0.231192</td>\n",
       "      <td>0.231192</td>\n",
       "      <td>0.231192</td>\n",
       "      <td>0.231192</td>\n",
       "      <td>0.231192</td>\n",
       "      <td>0.231192</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>eta_ehH</th>\n",
       "      <td>0.900000</td>\n",
       "      <td>0.900000</td>\n",
       "      <td>0.900000</td>\n",
       "      <td>0.900000</td>\n",
       "      <td>0.900000</td>\n",
       "      <td>0.900000</td>\n",
       "      <td>0.900000</td>\n",
       "      <td>0.900000</td>\n",
       "      <td>0.900000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>E_ehH_max</th>\n",
       "      <td>7.120000</td>\n",
       "      <td>21.920000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>53.440000</td>\n",
       "      <td>36.160000</td>\n",
       "      <td>40.800000</td>\n",
       "      <td>37.600000</td>\n",
       "      <td>32.640000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C_f_bat</th>\n",
       "      <td>0.000010</td>\n",
       "      <td>0.000010</td>\n",
       "      <td>0.000010</td>\n",
       "      <td>0.000010</td>\n",
       "      <td>0.000010</td>\n",
       "      <td>0.000010</td>\n",
       "      <td>0.000010</td>\n",
       "      <td>0.000010</td>\n",
       "      <td>0.000010</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C_p_bat</th>\n",
       "      <td>100.000000</td>\n",
       "      <td>100.000000</td>\n",
       "      <td>100.000000</td>\n",
       "      <td>100.000000</td>\n",
       "      <td>100.000000</td>\n",
       "      <td>100.000000</td>\n",
       "      <td>100.000000</td>\n",
       "      <td>100.000000</td>\n",
       "      <td>100.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>eta_bat</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C_f_Hsto</th>\n",
       "      <td>0.008000</td>\n",
       "      <td>0.008000</td>\n",
       "      <td>0.008000</td>\n",
       "      <td>0.008000</td>\n",
       "      <td>0.008000</td>\n",
       "      <td>0.008000</td>\n",
       "      <td>0.008000</td>\n",
       "      <td>0.008000</td>\n",
       "      <td>0.008000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C_p_Hsto</th>\n",
       "      <td>3.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>3.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>eta_Hsto</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C_f_Csto</th>\n",
       "      <td>0.006000</td>\n",
       "      <td>0.006000</td>\n",
       "      <td>0.006000</td>\n",
       "      <td>0.006000</td>\n",
       "      <td>0.006000</td>\n",
       "      <td>0.006000</td>\n",
       "      <td>0.006000</td>\n",
       "      <td>0.006000</td>\n",
       "      <td>0.006000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C_p_Csto</th>\n",
       "      <td>2.000000</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>2.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>eta_Csto</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                             0           1           2           3  \\\n",
       "p_ele                 0.200000    0.200000    0.200000    0.200000   \n",
       "ramping_cost_coeff    0.100000    0.100000    0.100000    0.100000   \n",
       "E_grid_past         153.003494  153.003494  153.003494  153.003494   \n",
       "E_ns                 13.760000    2.380000    2.360000    0.440000   \n",
       "H_bd                  0.000000    0.000000    0.000000    0.000000   \n",
       "C_bd                  0.000000    0.000000    0.000000    0.040000   \n",
       "H_max                 6.408000   19.728000    0.000000    0.000000   \n",
       "C_max               131.196000   20.220000   59.772000   57.060000   \n",
       "E_pv                  0.000000    0.000000    0.000000    0.000000   \n",
       "E_hpC_max           618.119995  227.369995  414.679993  383.565002   \n",
       "eta_hp                0.220000    0.220000    0.220000    0.220000   \n",
       "t_C_hp                8.000000    8.000000    8.000000    8.000000   \n",
       "COP_C                 0.231192    0.231192    0.231192    0.231192   \n",
       "eta_ehH               0.900000    0.900000    0.900000    0.900000   \n",
       "E_ehH_max             7.120000   21.920000    0.000000    0.000000   \n",
       "C_f_bat               0.000010    0.000010    0.000010    0.000010   \n",
       "C_p_bat             100.000000  100.000000  100.000000  100.000000   \n",
       "eta_bat               1.000000    1.000000    1.000000    1.000000   \n",
       "C_f_Hsto              0.008000    0.008000    0.008000    0.008000   \n",
       "C_p_Hsto              3.000000    3.000000    3.000000    3.000000   \n",
       "eta_Hsto              1.000000    1.000000    1.000000    1.000000   \n",
       "C_f_Csto              0.006000    0.006000    0.006000    0.006000   \n",
       "C_p_Csto              2.000000    2.000000    2.000000    2.000000   \n",
       "eta_Csto              1.000000    1.000000    1.000000    1.000000   \n",
       "\n",
       "                             4           5           6           7           8  \n",
       "p_ele                 0.200000    0.200000    0.200000    0.200000    0.200000  \n",
       "ramping_cost_coeff    0.100000    0.100000    0.100000    0.100000    0.100000  \n",
       "E_grid_past         153.003494  153.003494  153.003494  153.003494  153.003494  \n",
       "E_ns                  7.100000    9.500000   17.700000    9.900000   16.700000  \n",
       "H_bd                  4.920000    0.480000    0.360000    1.320000    0.480000  \n",
       "C_bd                  0.000000    0.320000    0.260000    0.000000    0.040000  \n",
       "H_max                48.096000   32.544000   36.720000   33.840000   29.376000  \n",
       "C_max                52.968000   51.912000   48.744000   33.000000   35.040000  \n",
       "E_pv                  0.000000    0.000000    0.000000    0.000000    0.000000  \n",
       "E_hpC_max           244.684998   98.619501  127.820000  165.449997  175.229996  \n",
       "eta_hp                0.220000    0.220000    0.220000    0.220000    0.220000  \n",
       "t_C_hp                8.000000    8.000000    8.000000    8.000000    8.000000  \n",
       "COP_C                 0.231192    0.231192    0.231192    0.231192    0.231192  \n",
       "eta_ehH               0.900000    0.900000    0.900000    0.900000    0.900000  \n",
       "E_ehH_max            53.440000   36.160000   40.800000   37.600000   32.640000  \n",
       "C_f_bat               0.000010    0.000010    0.000010    0.000010    0.000010  \n",
       "C_p_bat             100.000000  100.000000  100.000000  100.000000  100.000000  \n",
       "eta_bat               1.000000    1.000000    1.000000    1.000000    1.000000  \n",
       "C_f_Hsto              0.008000    0.008000    0.008000    0.008000    0.008000  \n",
       "C_p_Hsto              3.000000    3.000000    3.000000    3.000000    3.000000  \n",
       "eta_Hsto              1.000000    1.000000    1.000000    1.000000    1.000000  \n",
       "C_f_Csto              0.006000    0.006000    0.006000    0.006000    0.006000  \n",
       "C_p_Csto              2.000000    2.000000    2.000000    2.000000    2.000000  \n",
       "eta_Csto              1.000000    1.000000    1.000000    1.000000    1.000000  "
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t_test = (t_idx - rbc_threshold) % 24\n",
    "print(f\"Mess up: {t_test}\")\n",
    "\n",
    "bd_debug = []\n",
    "row_ind = []\n",
    "for key in data_est.keys():\n",
    "    if len(data_est[key]) > 2:\n",
    "        row_ind.append(key)\n",
    "        bd_debug.append(data_est[key][t_test])\n",
    "pd.DataFrame(bd_debug, index=row_ind)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# basic_agent_cost = env.cost()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Plotting 5 days of winter operation of year 1\n",
    "# plt.figure(figsize=(16,5))\n",
    "# interval = range(0,24*5)\n",
    "# plt.plot(env.net_electric_consumption_no_pv_no_storage[interval])\n",
    "# plt.plot(env.net_electric_consumption_no_storage[interval])\n",
    "# plt.plot(env.net_electric_consumption[interval], '--')\n",
    "# plt.xlabel('time (hours)')\n",
    "# plt.ylabel('kW')\n",
    "# plt.legend(['Electricity demand without storage or generation (kW)', 'Electricity demand with PV generation and without storage(kW)', 'Electricity demand with PV generation and using RBC for storage(kW)'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# total_rewards = np.array(total_rewards).T\n",
    "# plt.figure(figsize=(15, 10))\n",
    "# for i in range(9):\n",
    "#     plt.plot(total_rewards[i], label='Building_'+str(i))\n",
    "\n",
    "# plt.xlabel('Hour')\n",
    "# plt.ylabel('Reward')\n",
    "# plt.legend()\n",
    "# plt.show()\n",
    "# print(total_rewards.sum(1)) #total reward per building"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}