42M_ACOPF_24Hour_NormalOperation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import division\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import random\n",
    "import time\n",
    "from pyomo.environ import *\n",
    "from pyomo.opt import SolverFactory\n",
    "import matplotlib.pyplot as plt\n",
    "import gym\n",
    "from gym import spaces, logger\n",
    "from random import choice\n",
    "from mlxtend.preprocessing import one_hot\n",
    "import scipy.stats as stats\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class make_network(gym.Env):\n",
    "\n",
    "    def __init__(self):\n",
    "\n",
    "        # read technical parameters of distribution network from input excel\n",
    "        self.network_data = pd.read_excel('topology.template 42M.xlsx', sheet_name=None)\n",
    "        \n",
    "        # bus name and voltage limits\n",
    "        self.Bus_name = self.network_data['BUSES']['NAME'].values\n",
    "        self.Bus_v = self.network_data['BUSES']['U'].values\n",
    "        self.Bus_min_v = self.network_data['BUSES']['UMIN'].values\n",
    "        self.Bus_max_v = self.network_data['BUSES']['UMAX'].values\n",
    "        \n",
    "        # line name, topology, reactance, resistance, current limit\n",
    "        self.Line_name = self.network_data['LINES']['NAME'].values\n",
    "        self.Line_from = self.network_data['LINES']['BUS1'].values\n",
    "        self.Line_to = self.network_data['LINES']['BUS2'].values\n",
    "        self.Line_x = self.network_data['LINES']['X'].values\n",
    "        self.Line_r = self.network_data['LINES']['R'].values\n",
    "        self.Line_max_i = self.network_data['LINES']['CURRENTLIMIT'].values\n",
    "        \n",
    "        # transformer name, topology, reactance, resistance\n",
    "        self.Transformer_name = self.network_data['TRANSFORMERS']['NAME'].values\n",
    "        self.Transformer_from = self.network_data['TRANSFORMERS']['BUS1'].values\n",
    "        self.Transformer_to = self.network_data['TRANSFORMERS']['BUS2'].values\n",
    "        self.Transformer_x = self.network_data['TRANSFORMERS']['X'].values\n",
    "        self.Transformer_r = self.network_data['TRANSFORMERS']['R'].values\n",
    "        \n",
    "        # load name, topology, active and reactive power, shedding cost\n",
    "        self.Load_name = self.network_data['LOADS']['NAME'].values\n",
    "        self.Load_bus = self.network_data['LOADS']['BUS'].values\n",
    "        self.Load_p_base = self.network_data['LOADS']['P'].values * 1000\n",
    "        self.Load_q_base = self.network_data['LOADS']['Q'].values * 1000\n",
    "        self.Load_cost = self.network_data['LOADS']['LAMBDA'].values\n",
    "        self.demand_profile = pd.read_excel('Demand_Profile.xlsx', 'Demand_Profile').values[:,0]\n",
    "        self.Load_p = np.array([[x*y for x in self.demand_profile] for y in self.Load_p_base])\n",
    "        \n",
    "        # generator name, topology, active power capacity, reactive power capacity\n",
    "        self.DG_name = self.network_data['GENERATORS']['NAME'].values\n",
    "        self.DG_bus = self.network_data['GENERATORS']['BUS'].values\n",
    "        self.DG_min_p = self.network_data['GENERATORS']['MINP'].values * 1000\n",
    "        self.DG_max_p = self.network_data['GENERATORS']['MAXP'].values * 1000\n",
    "        self.DG_min_q = self.network_data['GENERATORS']['MINQ'].values * 1000\n",
    "        self.DG_max_q = self.network_data['GENERATORS']['MAXQ'].values * 1000\n",
    "        \n",
    "        # switch name, topology, status\n",
    "        self.Switch_name = self.network_data['SWITCHES']['NAME'].values\n",
    "        self.Switch_from = self.network_data['SWITCHES']['BUS1'].values\n",
    "        self.Switch_to = self.network_data['SWITCHES']['BUS2'].values\n",
    "        self.Switch_status = self.network_data['SWITCHES']['OPEN'].values\n",
    "        \n",
    "        # number of bus, line, transformer, load, generator\n",
    "        self.n_bus = self.network_data['BUSES'].shape[0]\n",
    "        self.n_line = self.network_data['LINES'].shape[0] \n",
    "        self.n_transformer = self.network_data['TRANSFORMERS'].shape[0] \n",
    "        self.n_load = self.network_data['LOADS'].shape[0]\n",
    "        self.n_dg = self.network_data['GENERATORS'].shape[0]\n",
    "        self.n_switch = self.network_data['SWITCHES'].shape[0]\n",
    "        self.n_time = 24\n",
    "        \n",
    "    def ACOPF_model(self):\n",
    "        \n",
    "        # construct optimisation model\n",
    "        model = ConcreteModel('ACOPF')\n",
    "        \n",
    "        # Define sets\n",
    "        model.T = Set(initialize=[t for t in range(self.n_time)], doc='Hours', ordered=True)\n",
    "        model.B = Set(initialize=[b for b in range(self.n_bus)], doc='Buses', ordered=True)\n",
    "        model.L = Set(initialize=[l for l in range(self.n_line)], doc='Lines', ordered=True)\n",
    "        model.F = Set(initialize=[f for f in range(self.n_transformer)], doc='Transformers', ordered=True)\n",
    "        model.D = Set(initialize=[d for d in range(self.n_load)], doc='Loads', ordered=True)\n",
    "        model.G = Set(initialize=[g for g in range(self.n_dg)], doc='Generators', ordered=True)\n",
    "        model.S = Set(initialize=[s for s in range(self.n_switch)], doc='Switches', ordered=True)\n",
    "\n",
    "        # Define variables\n",
    "        model.dg_p = Var(model.G, model.T, domain=Reals) # generator active power\n",
    "        model.loadshed_p = Var(model.D, model.T, domain=NonNegativeReals) # active load shedding\n",
    "        model.las = Var(model.L, model.T, domain=Reals) # line active power flow sending\n",
    "        model.lar = Var(model.L, model.T, domain=Reals) # line active power flow receiving\n",
    "        model.lrs = Var(model.L, model.T, domain=Reals) # line reactive power flow sending\n",
    "        model.lrr = Var(model.L, model.T, domain=Reals) # line reactive power flow receiving\n",
    "        model.fas = Var(model.F, model.T, domain=Reals) # transformer active power flow sending\n",
    "        model.far = Var(model.F, model.T, domain=Reals) # transformer active power flow receiving\n",
    "        model.frs = Var(model.F, model.T, domain=Reals) # transformer reactive power flow sending\n",
    "        model.frr = Var(model.F, model.T, domain=Reals) # transformer reactive power flow receiving\n",
    "        model.sas = Var(model.S, model.T, domain=Reals) # switch active power flow sending\n",
    "        model.sar = Var(model.S, model.T, domain=Reals) # switch active power flow receiving\n",
    "        model.srs = Var(model.S, model.T, domain=Reals) # switch eactive power flow sending\n",
    "        model.srr = Var(model.S, model.T, domain=Reals) # switch reactive power flow receiving\n",
    "        model.volt = Var(model.B, model.T, domain=NonNegativeReals) # bus voltage**2\n",
    "        model.lcurrent = Var(model.L, model.T, domain=NonNegativeReals) # line current**2\n",
    "        model.fcurrent = Var(model.F, model.T, domain=NonNegativeReals) # transformer current**2\n",
    "\n",
    "        # generator operating constraints\n",
    "        def _dg_p_UB_stay(model, g, t):\n",
    "            return model.dg_p[g,t] <= self.DG_max_p[g]\n",
    "        model.dg_p_UB_stay = Constraint(model.G, model.T, rule=_dg_p_UB_stay)\n",
    "\n",
    "        def _dg_p_LB_stay(model, g, t):\n",
    "            return model.dg_p[g,t] >= self.DG_min_p[g]\n",
    "        model.dg_p_LB_stay = Constraint(model.G, model.T, rule=_dg_p_LB_stay)\n",
    "\n",
    "        # load shedding constraint\n",
    "        def _loadshed_p_UB_(model, d, t):\n",
    "            return model.loadshed_p[d,t] <= self.Load_p[d,t]\n",
    "        model.loadshed_p_UB_ = Constraint(model.D, model.T, rule=_loadshed_p_UB_)\n",
    "\n",
    "        # nodal active power balance\n",
    "        def _node_balance_active_(model, b, t): \n",
    "            return + sum(model.dg_p[g,t] for g in model.G if self.DG_bus[g] == self.Bus_name[b]) \\\n",
    "                   - sum(self.Load_p[d,t] for d in model.D if self.Load_bus[d] == self.Bus_name[b]) \\\n",
    "                   + sum(model.loadshed_p[d,t] for d in model.D if self.Load_bus[d] == self.Bus_name[b]) == \\\n",
    "                   + sum(model.las[l,t] for l in model.L if self.Line_from[l] == self.Bus_name[b]) \\\n",
    "                   + sum(model.lar[l,t] for l in model.L if self.Line_to[l] == self.Bus_name[b]) \\\n",
    "                   + sum(model.fas[f,t] for f in model.F if self.Transformer_from[f] == self.Bus_name[b]) \\\n",
    "                   + sum(model.far[f,t] for f in model.F if self.Transformer_to[f] == self.Bus_name[b]) \\\n",
    "                   + sum(model.sas[s,t] for s in model.S if self.Switch_from[s] == self.Bus_name[b]) \\\n",
    "                   + sum(model.sar[s,t] for s in model.S if self.Switch_to[s] == self.Bus_name[b])\n",
    "        model.NodeBalanceActive_ = Constraint(model.B, model.T, rule=_node_balance_active_)\n",
    "\n",
    "        # nodal voltage constraints\n",
    "        def _volt_UB_(model, b, t):\n",
    "            return model.volt[b,t] <= self.Bus_max_v[b]**2\n",
    "        model.volt_UB_ = Constraint(model.B, model.T, rule=_volt_UB_)\n",
    "        \n",
    "        def _volt_LB_(model, b ,t):\n",
    "            return model.volt[b,t] >= self.Bus_min_v[b]**2\n",
    "        model.volt_LB_ = Constraint(model.B, model.T, rule=_volt_LB_)\n",
    "        \n",
    "        #---------------------- line constraints ----------------------#\n",
    "        # line current constraints\n",
    "        def _line_current_UB_(model, l, t):\n",
    "            return model.lcurrent[l,t] <= self.Line_max_i[l]**2\n",
    "        model.line_current_UB_ = Constraint(model.L, model.T, rule=_line_current_UB_)\n",
    "        \n",
    "        # second order cone distflow\n",
    "        def _line_equal_1(model, l, t):\n",
    "            return model.las[l,t] == - model.lar[l,t]\n",
    "        model.line_equal_1 = Constraint(model.L, model.T, rule=_line_equal_1)\n",
    "\n",
    "        def _line_equal_2(model, l, t):\n",
    "            return model.lrs[l,t] == - model.lrr[l,t]\n",
    "        model.line_equal_2 = Constraint(model.L, model.T, rule=_line_equal_2)\n",
    "        \n",
    "        # line power flow constraints \n",
    "        def _line_flow_send_UB_(model, l, t):\n",
    "            return model.lar[l,t] * model.lar[l,t] + model.lrr[l,t] * model.lrr[l,t] <= \\\n",
    "                   sum(model.lcurrent[l,t] * model.volt[b,t] for b in model.B if self.Line_from[l] == self.Bus_name[b])\n",
    "        model.line_flow_send_UB_ = Constraint(model.L, model.T, rule=_line_flow_send_UB_)\n",
    "        \n",
    "        # linearized distflow\n",
    "        def line_flow_(model, l, t):\n",
    "            return (sum(model.volt[b,t] for b in model.B if self.Bus_name[b] == self.Line_from[l]) - \\\n",
    "                    sum(model.volt[b,t] for b in model.B if self.Bus_name[b] == self.Line_to[l])) == \\\n",
    "                    2 * (self.Line_r[l] * model.las[l,t] + self.Line_x[l] * model.lrs[l,t])\n",
    "        model.LinePhaseActiveFlow = Constraint(model.L, model.T, rule=line_flow_)\n",
    "        \n",
    "        #---------------------- transformer constraints ----------------------#\n",
    "        def _transformer_equal_1(model, f, t):\n",
    "            return model.fas[f,t] == - model.far[f,t]\n",
    "        model.transformer_equal_1 = Constraint(model.F, model.T, rule=_transformer_equal_1)\n",
    "\n",
    "        def _transformer_equal_2(model, f, t):\n",
    "            return model.frs[f,t] == - model.frr[f,t]\n",
    "        model.transformer_equal_2 = Constraint(model.F, model.T, rule=_transformer_equal_2)\n",
    "        \n",
    "        # linearized distflow\n",
    "#         def transformer_flow_(model, f, t):\n",
    "#             return (sum(model.volt[b,t] for b in model.B if self.Bus_name[b] == self.Transformer_from[f]) - \\\n",
    "#                     sum(model.volt[b,t] for b in model.B if self.Bus_name[b] == self.Transformer_to[f])) >= \\\n",
    "#                     2 * (self.Transformer_r[f] * model.fas[f,t] + self.Transformer_x[f] * model.frs[f,t])\n",
    "#         model.TransformerPhaseActiveFlow = Constraint(model.F, model.T, rule=transformer_flow_)\n",
    "        \n",
    "        #---------------------- switch constraints ----------------------#\n",
    "        def _switch_equal_1(model, s, t):\n",
    "            return model.sas[s,t] == - model.sar[s,t]\n",
    "        model.switch_equal_1 = Constraint(model.S, model.T, rule=_switch_equal_1)\n",
    "\n",
    "        def _switch_equal_2(model, s, t):\n",
    "            return model.srs[s,t] == - model.srr[s,t]\n",
    "        model.switch_equal_2 = Constraint(model.S, model.T, rule=_switch_equal_2)\n",
    "        \n",
    "        def _switch_status_connect_(model, s, t):\n",
    "            if self.Switch_status[s] == 'OPEN':\n",
    "                return model.sas[s,t] == 0   \n",
    "            return Constraint.Skip\n",
    "        model.switch_status_connect_ = Constraint(model.S, model.T, rule=_switch_status_connect_)\n",
    "        \n",
    "        # --------------- outage scenario -----------------\n",
    "        damage = []\n",
    "        def _outage_status_connect_(model, l, t):\n",
    "            for i in range(len(damage)):\n",
    "                if l == damage[i]:\n",
    "                    return model.lcurrent[l,t] == 0\n",
    "            return Constraint.Skip\n",
    "        model.outage_status_connect_ = Constraint(model.L, model.T, rule=_outage_status_connect_)\n",
    "        \n",
    "        # -------------- objective function --------------             \n",
    "        def _obj_(model):\n",
    "            return sum(self.Load_cost[d] * model.loadshed_p[d,t] for d in model.D for t in model.T)\n",
    "        model.objective = Objective(rule=_obj_, sense=minimize)\n",
    "\n",
    "        return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Dawei Qiu\\anaconda3\\lib\\site-packages\\openpyxl\\worksheet\\_read_only.py:79: UserWarning: Data Validation extension is not supported and will be removed\n",
      "  for idx, row in parser.parse():\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set parameter Username\n",
      "Academic license - for non-commercial use only - expires 2024-08-16\n",
      "Read LP format model from file C:\\Users\\DAWEIQ~1\\AppData\\Local\\Temp\\tmphu2s6cgs.pyomo.lp\n",
      "Reading time = 0.07 seconds\n",
      "x19033: 22153 rows, 18865 columns, 40249 nonzeros\n",
      "Gurobi Optimizer version 10.0.2 build v10.0.2rc0 (win64)\n",
      "\n",
      "CPU model: AMD Ryzen 5 4600H with Radeon Graphics, instruction set [SSE2|AVX|AVX2]\n",
      "Thread count: 6 physical cores, 12 logical processors, using up to 12 threads\n",
      "\n",
      "Optimize a model with 22153 rows, 18865 columns and 40249 nonzeros\n",
      "Model fingerprint: 0x72a81df3\n",
      "Model has 2616 quadratic constraints\n",
      "Coefficient statistics:\n",
      "  Matrix range     [2e-03, 2e+00]\n",
      "  QMatrix range    [1e+00, 1e+00]\n",
      "  Objective range  [1e+00, 1e+01]\n",
      "  Bounds range     [0e+00, 0e+00]\n",
      "  RHS range        [1e-01, 2e+05]\n",
      "Presolve removed 11929 rows and 2041 columns\n",
      "Presolve time: 0.02s\n",
      "Presolved: 15456 rows, 22056 columns, 42504 nonzeros\n",
      "Presolved model has 2616 second-order cone constraints\n",
      "Ordering time: 0.00s\n",
      "\n",
      "Barrier statistics:\n",
      " Free vars  : 1536\n",
      " AA' NZ     : 5.911e+04\n",
      " Factor NZ  : 1.585e+05 (roughly 16 MB of memory)\n",
      " Factor Ops : 1.883e+06 (less than 1 second per iteration)\n",
      " Threads    : 6\n",
      "\n",
      "                  Objective                Residual\n",
      "Iter       Primal          Dual         Primal    Dual     Compl     Time\n",
      "   0   4.57857577e+08 -7.10128253e+08  4.07e+04 2.01e+01  3.43e+05     0s\n",
      "   1   6.53203359e+07 -4.03166907e+08  7.13e+03 5.28e+00  6.89e+04     0s\n",
      "   2   1.27737124e+07 -1.14535697e+08  1.64e+03 4.47e-01  1.41e+04     0s\n",
      "   3   1.82427237e+06 -3.01668358e+07  2.40e+02 7.14e-02  2.42e+03     0s\n",
      "   4   4.00966725e+05 -1.05254036e+07  5.13e+01 1.93e-02  6.37e+02     0s\n",
      "   5   1.46948469e+05 -6.72830946e+06  1.23e+01 1.15e-02  3.25e+02     0s\n",
      "   6   5.06634262e+04 -3.24064466e+06  2.84e+00 5.08e-03  1.42e+02     0s\n",
      "   7   2.47270472e+04 -8.67454409e+05  6.87e-01 1.27e-03  3.72e+01     0s\n",
      "   8   1.09593781e+04 -2.69765579e+05  1.81e-02 6.90e-04  1.15e+01     0s\n",
      "   9   6.70071276e+03 -1.23333607e+05  7.54e-03 6.81e-04  5.32e+00     0s\n",
      "  10   2.07779403e+03 -4.10529792e+04  1.36e-03 5.75e-04  1.77e+00     0s\n",
      "  11   1.14458487e+03 -8.70678023e+03  4.96e-04 2.20e-04  4.05e-01     0s\n",
      "  12   7.15465919e+02 -4.08254640e+03  1.37e-04 3.48e-04  1.98e-01     0s\n",
      "  13   5.76821938e+02 -6.14373034e+02  3.00e-05 1.50e-04  4.90e-02     0s\n",
      "  14   5.50296404e+02  2.83701763e+02  5.17e-05 2.65e-05  1.09e-02     0s\n",
      "  15   5.43633045e+02  4.74167982e+02  9.82e-06 9.57e-06  2.83e-03     0s\n",
      "  16   5.41177105e+02  5.34189304e+02  9.57e-06 4.89e-07  2.82e-04     0s\n",
      "  17   5.41088256e+02  5.40621729e+02  4.91e-05 4.69e-07  1.85e-05     0s\n",
      "  18   5.41075943e+02  5.40924590e+02  1.71e-05 2.49e-07  6.00e-06     0s\n",
      "  19   5.41074917e+02  5.41040180e+02  1.20e-04 7.49e-07  1.38e-06     0s\n",
      "  20   5.41074888e+02  5.41063367e+02  1.08e-03 2.52e-04  4.58e-07     0s\n",
      "  21   5.41074888e+02  5.41063905e+02  1.32e-03 9.75e-04  4.37e-07     0s\n",
      "  22   5.41074887e+02  5.41064161e+02  1.79e-03 1.10e-03  4.28e-07     0s\n",
      "  23   5.41074887e+02  5.41064522e+02  3.03e-03 1.65e-03  4.15e-07     0s\n",
      "  24   5.41074887e+02  5.41065826e+02  1.21e-03 3.16e-03  3.63e-07     1s\n",
      "  25   5.41074887e+02  5.41067390e+02  1.45e-03 5.80e-03  3.01e-07     1s\n",
      "  26   5.41074887e+02  5.41068119e+02  3.05e-03 1.28e-02  2.75e-07     1s\n",
      "  27   5.41074887e+02  5.41070782e+02  5.73e-03 2.11e-02  1.68e-07     1s\n",
      "  28   5.41074887e+02  5.41072590e+02  1.15e-02 3.40e-02  9.47e-08     1s\n",
      "  29   5.41074886e+02  5.41073874e+02  8.13e-03 5.12e-02  4.28e-08     1s\n",
      "  30   5.41074886e+02  5.41074434e+02  9.33e-03 7.37e-02  2.00e-08     1s\n",
      "  31   5.41074886e+02  5.41074596e+02  2.07e-02 1.11e-01  1.33e-08     1s\n",
      "  32   5.41074886e+02  5.41074653e+02  2.55e-02 1.68e-01  1.10e-08     1s\n",
      "  33   5.41074886e+02  5.41074673e+02  4.37e-02 1.72e-01  1.01e-08     1s\n",
      "  34   5.41074886e+02  5.41074623e+02  3.74e-02 2.29e-01  1.24e-08     1s\n",
      "  35   5.41074886e+02  5.41074677e+02  9.90e-02 1.63e-01  1.00e-08     1s\n",
      "  36   5.41074886e+02  5.41074596e+02  1.73e-01 2.47e-01  1.34e-08     1s\n",
      "  37   5.41074887e+02  5.41074675e+02  2.11e-01 1.40e-01  1.01e-08     1s\n",
      "  38   5.41074886e+02  5.41074685e+02  3.68e-01 1.79e-01  9.61e-09     1s\n",
      "  39   5.41074885e+02  5.41074625e+02  6.04e-01 2.06e-01  1.23e-08     1s\n",
      "  40   5.41074884e+02  5.41074684e+02  9.28e-01 4.76e-02  9.73e-09     1s\n",
      "  41   5.41074889e+02  5.41074691e+02  1.49e+00 4.08e-02  9.43e-09     1s\n",
      "  42   5.41074889e+02  5.41074697e+02  2.63e+00 4.16e-02  9.17e-09     1s\n",
      "  43   5.41074891e+02  5.41074697e+02  1.35e+00 6.91e-02  9.15e-09     1s\n",
      "  44   5.41074892e+02  5.41074696e+02  1.72e+00 9.70e-02  9.17e-09     1s\n",
      "  45   5.41074892e+02  5.41074694e+02  1.81e+00 1.73e-01  9.23e-09     1s\n",
      "  46   5.41074886e+02  5.41074695e+02  1.54e+00 2.49e-01  9.23e-09     1s\n",
      "  47   5.41074886e+02  5.41074696e+02  9.25e-01 2.31e-01  9.22e-09     1s\n",
      "  48   5.41074887e+02  5.41074696e+02  1.00e+00 2.50e-01  9.21e-09     2s\n",
      "  49   5.41074886e+02  5.41074696e+02  1.24e+00 2.36e-01  9.20e-09     2s\n",
      "  50   5.41074886e+02  5.41074697e+02  1.42e+00 2.82e-01  9.20e-09     2s\n",
      "  51   5.41074885e+02  5.41074697e+02  1.40e+00 3.29e-01  9.19e-09     2s\n",
      "\n",
      "Barrier performed 51 iterations in 1.63 seconds (0.95 work units)\n",
      "Sub-optimal termination - objective 5.41075943e+02\n",
      "\n",
      "WARNING: Loading a SolverResults object with a warning status into\n",
      "    model.name=\"ACOPF\";\n",
      "      - termination condition: other\n",
      "      - message from solver: Unable to satisfy optimality tolerances; a sub-\n",
      "        optimal solution is available.\n",
      "541.0759432987215\n"
     ]
    }
   ],
   "source": [
    "Network = make_network()\n",
    "inst = Network.ACOPF_model()\n",
    "solver = SolverFactory ('gurobi', tee=True)\n",
    "result = solver.solve (inst, tee=True)\n",
    "print(value(inst.objective))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "Load_SP = np.zeros([Network.n_load,Network.n_time])\n",
    "Load_P = np.zeros([Network.n_load,Network.n_time])\n",
    "DG_P = np.zeros([Network.n_dg,Network.n_time])\n",
    "LineFlow_P = np.zeros([Network.n_line,Network.n_time])\n",
    "LineCurrent = np.zeros([Network.n_line,Network.n_time])\n",
    "SwitchFlow_P = np.zeros([Network.n_switch,Network.n_time])\n",
    "BusVoltage = np.zeros([Network.n_bus,Network.n_time])\n",
    "for t in inst.T:\n",
    "    for d in inst.D:\n",
    "        Load_SP[d,t] = value(inst.loadshed_p[d,t])\n",
    "        Load_P[d,t] = Network.Load_p[d,t] - Load_SP[d,t]\n",
    "    for g in inst.G:\n",
    "        DG_P[g,t] = value(inst.dg_p[g,t])\n",
    "    for l in inst.L:\n",
    "        LineFlow_P[l,t] = value(inst.las[l,t])\n",
    "        LineCurrent[l,t] = value(inst.lcurrent[l,t])**0.5\n",
    "    for s in inst.S:\n",
    "        SwitchFlow_P[s,t] = value(inst.sas[s,t])\n",
    "    for b in inst.B:\n",
    "        BusVoltage[b,t] = value(inst.volt[b,t])**0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "NonEss_Load_Base, NonEss_Load_Net, NonEss_Load_Shed = [], [], []\n",
    "Ess_Load_Base, Ess_Load_Net, Ess_Load_Shed = [], [], []\n",
    "for d in range(len(Network.Load_p)):\n",
    "    if Network.Load_cost[d] == 10:\n",
    "        Ess_Load_Base.append(Network.Load_p[d])\n",
    "        Ess_Load_Net.append(Load_P[d])\n",
    "        Ess_Load_Shed.append(Load_SP[d])\n",
    "    else:\n",
    "        NonEss_Load_Base.append(Network.Load_p[d])\n",
    "        NonEss_Load_Net.append(Load_P[d])\n",
    "        NonEss_Load_Shed.append(Load_SP[d])\n",
    "        \n",
    "Ess_Load_Base_Sum = np.sum(Ess_Load_Base, axis=0)\n",
    "Ess_Load_Net_Sum = np.sum(Ess_Load_Net, axis=0)\n",
    "Ess_Load_Shed_Sum = np.sum(Ess_Load_Shed, axis=0)\n",
    "NonEss_Load_Base_Sum = np.sum(NonEss_Load_Base, axis=0)\n",
    "NonEss_Load_Net_Sum = np.sum(NonEss_Load_Net, axis=0)\n",
    "NonEss_Load_Shed_Sum = np.sum(NonEss_Load_Shed, axis=0)\n",
    "Load_Base_Sum = np.sum(Network.Load_p, axis=0)\n",
    "Load_Net_Sum = np.sum(Load_P, axis=0)\n",
    "Load_Shed_Sum = np.sum(Load_SP, axis=0)\n",
    "\n",
    "GGrid, G8, G11, G17, G24, G26 = DG_P[0], np.sum([DG_P[1], DG_P[2]], axis=0), DG_P[3], DG_P[4], DG_P[5], DG_P[6]\n",
    "G33, G34, G22, G88, G119, G120 = DG_P[7], DG_P[8], DG_P[9], np.sum([DG_P[10], DG_P[11]], axis=0), DG_P[12], DG_P[13]\n",
    "G126, G128, G130, G133, G132, G122, G124 = DG_P[14], DG_P[15], DG_P[16], DG_P[17], DG_P[18], DG_P[19], DG_P[20]\n",
    "DG_Sum = np.sum([G8, G11, G17, G24, G26, G33, G34, G22, G88, G119, G120, G126, G128, G130, G133, G132, G122, G124], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "GGrid_Buy, GGrid_Sell = np.zeros(24), np.zeros(24) \n",
    "for t in range(24):\n",
    "    if GGrid[t] >= 0:\n",
    "        GGrid_Buy[t] = GGrid[t]\n",
    "    else:\n",
    "        GGrid_Sell[t] = -GGrid[t]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x201.6 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize = (5,2.8))\n",
    "# sources = ['Grid', 'Bus8', 'Bus11', 'Bus17', 'Bus24', 'Bus26', 'Bus33', 'Bus34', 'Bus22', 'Bus88', \n",
    "#            'Bus119', 'Bus120', 'Bus126', 'Bus128', 'Bus130', 'Bus133', 'Bus132', 'Bus122', 'Bus124']\n",
    "sources = ['Grid', 'DG', 'Load Shed']\n",
    "colors = ['tab:red', 'tab:green', 'tab:gray']\n",
    "x = range(24)\n",
    "line_width = 3\n",
    "alpha=0.8\n",
    "space = 0.2\n",
    "text1 = 10\n",
    "text2 = 12\n",
    "font1 = {'family': 'Times New Roman', 'weight': 'normal', 'size': text1}\n",
    "font2 = {'family': 'Times New Roman', 'weight': 'normal', 'size': text2}\n",
    "plt.plot(x, Load_Base_Sum, '-', color='black', label='Load', linewidth=line_width)\n",
    "stacks = plt.stackplot(x, GGrid_Buy, DG_Sum, Load_Shed_Sum, labels=sources, colors=colors, alpha=alpha)\n",
    "plt.grid(which='major', linestyle='--', axis='y')\n",
    "plt.tick_params(labelsize = text2)\n",
    "plt.xticks(np.linspace(0,23), fontname = \"Times New Roman\")\n",
    "plt.xticks([0,2,5,8,11,14,17,20,23],['1','3','6','9','12','15','18','21','24'])\n",
    "plt.yticks(np.linspace(0,10000,6), fontname = \"Times New Roman\")\n",
    "plt.ylabel('Power supply (kW)', font2)\n",
    "plt.xlabel('Time', font2)\n",
    "legend = plt.legend(loc='upper left', prop=font1, labelspacing=space, framealpha=1, ncol=2, bbox_to_anchor=(0,1.0))\n",
    "plt.savefig('Day_Normal_Supply.jpg', bbox_inches='tight', dpi = 900)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x108 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize = (5,1.5))\n",
    "sources = ['Net', 'Curtail']\n",
    "colors = ['tab:brown', 'tab:gray']\n",
    "x = range(24)\n",
    "line_width = 3\n",
    "alpha=0.8\n",
    "space = 0.1\n",
    "text1 = 10\n",
    "text2 = 12\n",
    "font1 = {'family': 'Times New Roman', 'weight': 'normal', 'size': text1}\n",
    "font2 = {'family': 'Times New Roman', 'weight': 'normal', 'size': text2}\n",
    "plt.plot(x, Ess_Load_Base_Sum, '-', color='tab:purple', label='Load', linewidth=line_width)\n",
    "stacks = plt.stackplot(x, Ess_Load_Net_Sum, Ess_Load_Shed_Sum, labels=sources, colors=colors, alpha=alpha)\n",
    "plt.grid(which='major', linestyle='--', axis='y')\n",
    "plt.tick_params(labelsize = text2)\n",
    "plt.xticks(np.linspace(0,23), fontname = \"Times New Roman\")\n",
    "plt.xticks([0,2,5,8,11,14,17,20,23],['1','3','6','9','12','15','18','21','24'])\n",
    "plt.yticks(np.linspace(0,8000,5), fontname = \"Times New Roman\")\n",
    "plt.ylabel('Essential (kW)', font2)\n",
    "plt.xlabel('Time', font2)\n",
    "legend = plt.legend(loc='upper left', prop=font1, labelspacing=space, framealpha=1, ncol=1, bbox_to_anchor=(0,1.03))\n",
    "plt.savefig('Day_Normal_EssLoad.jpg', bbox_inches='tight', dpi = 900)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x108 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize = (5,1.5))\n",
    "sources = ['Net', 'Curtail']\n",
    "colors = ['tab:brown', 'tab:gray']\n",
    "x = range(24)\n",
    "line_width = 3\n",
    "alpha=0.8\n",
    "space = 0.1\n",
    "text1 = 10\n",
    "text2 = 12\n",
    "font1 = {'family': 'Times New Roman', 'weight': 'normal', 'size': text1}\n",
    "font2 = {'family': 'Times New Roman', 'weight': 'normal', 'size': text2}\n",
    "plt.plot(x, NonEss_Load_Base_Sum, '-', color='tab:orange', label='Demand', linewidth=line_width)\n",
    "stacks = plt.stackplot(x, NonEss_Load_Net_Sum, NonEss_Load_Shed_Sum, labels=sources, colors=colors, alpha=alpha)\n",
    "plt.grid(which='major', linestyle='--', axis='y')\n",
    "plt.tick_params(labelsize = text2)\n",
    "plt.xticks(np.linspace(0,23), fontname = \"Times New Roman\")\n",
    "plt.xticks([0,2,5,8,11,14,17,20,23],['1','3','6','9','12','15','18','21','24'])\n",
    "plt.yticks(np.linspace(0,2000,5), fontname = \"Times New Roman\")\n",
    "plt.ylabel('Non-Essential (kW)', font2)\n",
    "plt.xlabel('Time', font2)\n",
    "legend = plt.legend(loc='upper left', prop=font1, labelspacing=space, framealpha=1, ncol=1, bbox_to_anchor=(0,1.03))\n",
    "plt.savefig('Day_Normal_NonEssLoad.jpg', bbox_inches='tight', dpi = 900)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "541.0757340585299"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(Load_Shed_Sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}