colab_implicit_agent.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "colab": {
      "name": "implicit_agent.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/QasimWani/ROLEVT/blob/main/colab_implicit_agent.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eirOAFZ7W3-W",
        "outputId": "c361929b-6752-4f8b-e350-dd15f5fbae36",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive', force_remount=True)"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/gdrive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "udKNW1-cW5aB",
        "outputId": "6798efb6-b167-4884-c2a9-e83a301c1da9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "!ls"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "gdrive\tsample_data\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0tBPeV4iXAvl",
        "outputId": "ee6f4762-da69-4928-9f40-6eacd76cb7d9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "import os\n",
        "root = '/content'\n",
        "dirlist = [ item for item in os.listdir(root) if os.path.isdir(os.path.join(root, item)) ]\n",
        "\n",
        "if 'ROLEVT' not in dirlist:\n",
        "  !git clone https://username:password@github.com/QasimWani/ROLEVT.git #SSH\n",
        "  # !git clone https://<username>:<token>@github.com/QasimWani/ROLEVT.git #GitHub Token"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Cloning into 'ROLEVT'...\n",
            "remote: Enumerating objects: 216, done.\u001b[K\n",
            "remote: Counting objects: 100% (216/216), done.\u001b[K\n",
            "remote: Compressing objects: 100% (179/179), done.\u001b[K\n",
            "remote: Total 216 (delta 73), reused 151 (delta 32), pack-reused 0\u001b[K\n",
            "Receiving objects: 100% (216/216), 12.36 MiB | 19.84 MiB/s, done.\n",
            "Resolving deltas: 100% (73/73), done.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aZH_vqF3XF99",
        "outputId": "946ea1c0-7a52-4234-9cf3-926f6f64cf3c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "%cd ROLEVT/"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/content/ROLEVT\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6ZnsyEvbXH61",
        "outputId": "5a4e2eb6-cfd9-42e8-9251-af898bb15b51",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "!ls"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "agent.py\t\t\t   energy_models.py\t predictor_implicit\n",
            "agents\t\t\t\t   examples\t\t README.md\n",
            "buildings_state_action_space.json  images\t\t reward_function.py\n",
            "citylearn.py\t\t\t   implicit_agent.ipynb  src\n",
            "colab_implicit_agent.ipynb\t   LICENSE\t\t submission_files\n",
            "common\t\t\t\t   main.ipynb\n",
            "data\t\t\t\t   main.py\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UQrbEBjzWyxn"
      },
      "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\")"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MB9IQD3uWyxq"
      },
      "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()"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z-2amM4VWyxr"
      },
      "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]']"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G-HHLMHvWyxr"
      },
      "source": [
        "## Load Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TQDXOOroWyxr"
      },
      "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\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 = [3]*_num_buildings #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"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_0ZxX2BkWyxu"
      },
      "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"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KX9fEWI3Wyxw"
      },
      "source": [
        "def get_dimensions(data:dict):\n",
        "    \"\"\" Gets shape of each param \"\"\"\n",
        "    for key in data.keys():\n",
        "        print(data[key].shape)"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0vnBz8NxWyxw"
      },
      "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"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Out19JzMWyxw"
      },
      "source": [
        "## Optimization"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lT-nG0TsWyxx"
      },
      "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])"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YWMDOb6bWyxx"
      },
      "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"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "viWei5ZNWyxx"
      },
      "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)]"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SnH484_0Wyxx"
      },
      "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",
        "        E_grid_pkhist = cp.Parameter(name='E_grid_pkhist', \n",
        "                                    value=parameters['E_grid_past'][:(t+1), building_id].max())\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 = virtual_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_H'], actions['action_C'], actions['action_bat']], dispatch_cost if dispatch else None"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": false,
        "id": "pz39kuB0Wyxz"
      },
      "source": [
        "# # optimization debug -> !!! PROBLEM !!!\n",
        "# debug = get_actions(data, 0, debug=True) # for each building: [actions (size 2/3)], cost (if available)\n",
        "# problem = debug[0].get_problem()"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L7bhEXyRWyxz"
      },
      "source": [
        "# for var in problem.variables():\n",
        "#     print(var, var.value[0])"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n91xy0aGWyxz"
      },
      "source": [
        "## RBC for Data Collection "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DZYQHtTsWyx0"
      },
      "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"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "unoXT8o7Wyx0"
      },
      "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"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JOXYyphoWyx0"
      },
      "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])"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "scGQBo_fWyx0"
      },
      "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"
      ],
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sHvqnKtrWyx0"
      },
      "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"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_dtyixQHWyx0"
      },
      "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"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XnxtVPILWyx1"
      },
      "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"
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": false,
        "id": "aZKogFk_Wyx1",
        "outputId": "e18647ee-75bb-45ab-dd91-f1f022358475",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "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"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Time step: 1056\n",
            "Total time = 89.66337537765503\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J92dfb4uWyx2",
        "outputId": "482a3081-f603-4d6b-d5ef-467848fc8635",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        }
      },
      "source": [
        "# plt.figure(figsize=(10, 7))\n",
        "\n",
        "bid = 0\n",
        "\n",
        "week = end_time - 24 * 7 #plots last week of the month data \n",
        "# pred = np.transpose(look_ahead_cost, [1,2,0])[bid].flatten()[week - end_time:] ### uncomment this for E^grid + E^sell (this is for hourly)\n",
        "pred = np.array(look_ahead_cost).T[bid][(week - end_time)//24 : ] ### comment this for hourly cost (E^grid + E^sell) [this is for daily]\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()"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yazL3gxtWyx2"
      },
      "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))}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mfbGsUj5Wyx2"
      },
      "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()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0a1X1sGSWyx3"
      },
      "source": [
        "bd_actions = []\n",
        "for actions in np.array(actions_arr):\n",
        "    bd_actions.append(actions)"
      ],
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Qa9z8YQkWyx3",
        "outputId": "656ec8ab-22ef-4553-a4c5-51b4d10bd78d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 621
        }
      },
      "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()"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": false,
        "id": "FfYZiFDNWyx3"
      },
      "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])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "zjvFixzPWyx3"
      },
      "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",
        "])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": false,
        "id": "7_MYjARnWyx3"
      },
      "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)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MlrRUB-eWyx3"
      },
      "source": [
        "# basic_agent_cost = env.cost()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wBu0nnaDWyx4"
      },
      "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)'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "Wx1NikkAWyx4"
      },
      "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"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}