{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decomposition Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import numpy as np\n",
    "import gurobipy as gb\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "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>maxprod</th>\n",
       "      <th>price</th>\n",
       "      <th>uppremium</th>\n",
       "      <th>downpremium</th>\n",
       "      <th>upflex</th>\n",
       "      <th>downflex</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>gen</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>g1</th>\n",
       "      <td>80</td>\n",
       "      <td>10</td>\n",
       "      <td>2</td>\n",
       "      <td>8</td>\n",
       "      <td>0.10</td>\n",
       "      <td>0.10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>g2</th>\n",
       "      <td>60</td>\n",
       "      <td>20</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "      <td>0.15</td>\n",
       "      <td>0.15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>g3</th>\n",
       "      <td>40</td>\n",
       "      <td>30</td>\n",
       "      <td>6</td>\n",
       "      <td>6</td>\n",
       "      <td>0.20</td>\n",
       "      <td>0.20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>g4</th>\n",
       "      <td>40</td>\n",
       "      <td>40</td>\n",
       "      <td>8</td>\n",
       "      <td>5</td>\n",
       "      <td>0.50</td>\n",
       "      <td>0.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>g5</th>\n",
       "      <td>50</td>\n",
       "      <td>100</td>\n",
       "      <td>10</td>\n",
       "      <td>2</td>\n",
       "      <td>1.00</td>\n",
       "      <td>1.00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     maxprod  price  uppremium  downpremium  upflex  downflex\n",
       "gen                                                          \n",
       "g1        80     10          2            8    0.10      0.10\n",
       "g2        60     20          4            7    0.15      0.15\n",
       "g3        40     30          6            6    0.20      0.20\n",
       "g4        40     40          8            5    0.50      0.50\n",
       "g5        50    100         10            2    1.00      1.00"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('https://raw.githubusercontent.com/ming-zhao/Optimization-and-Learning/master/data/benders.csv',\n",
    "                 index_col='gen', skipinitialspace=True)\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Class which can have attributes set\n",
    "class expando(object):\n",
    "    pass\n",
    "\n",
    "\n",
    "class Benders_Master:\n",
    "    def __init__(self, max_iters=25, verbose=True, numscenarios=100, demand_avg=200.0, demand_std=20.0, epsilon=0.001, delta=0.001):\n",
    "        '''\n",
    "            Class which solves the benders decomposed version of the dispatch problem.\n",
    "\n",
    "            Parameters\n",
    "            ----------\n",
    "            max_iters: int, default 25\n",
    "                    Maximum number of Benders iterations to run.\n",
    "            verbose: boolean, default True\n",
    "                    Print information on upper and lower bounds for each iteration\n",
    "            numscenarios: int, default 100\n",
    "                    Number of scenarios to use for subproblems\n",
    "            demand_avg: float, default 200.0\n",
    "                    Average demand, used as day-ahead bid.\n",
    "            demand_std: float, default 20.0\n",
    "                    Standard deviation for demand in scenario generation.\n",
    "            epsilon: float, default 0.001\n",
    "                    Relative threshold for benders iterations.\n",
    "                    Iterations will stop if ub - lb > |epsilon * lb|\n",
    "            delta: float, default 0.001\n",
    "                    Absolute threshold for benders iterations.\n",
    "                    Iterations will stop if ub < lb + delta\n",
    "        '''\n",
    "        self.data = expando()\n",
    "        self.variables = expando()\n",
    "        self.constraints = expando()\n",
    "        self.results = expando()\n",
    "        self.params = expando()\n",
    "\n",
    "        self.params.max_iters = max_iters\n",
    "        self.params.verbose = verbose\n",
    "        self.params.numscenarios = numscenarios\n",
    "        self.params.demand_avg = demand_avg\n",
    "        self.params.demand_std = demand_std\n",
    "\n",
    "        self._init_benders_params(epsilon=epsilon, delta=delta)\n",
    "        self._load_data()\n",
    "        self._build_model()\n",
    "\n",
    "    def optimize(self, force_submodel_rebuild=False):\n",
    "        # initial solution\n",
    "        self.model.optimize()\n",
    "\n",
    "        # Only build submodels if they don't exist or a rebuild is forced.\n",
    "        if not hasattr(self, 'submodels') or force_submodel_rebuild:\n",
    "            self.submodels = {s: Benders_Subproblem(self, scenario=s) for s in self.data.scenarios}\n",
    "        # Update fixed variables for submodels and rebuild.\n",
    "        [sm.update_fixed_vars(self) for sm in self.submodels.values()]\n",
    "        [sm.optimize() for sm in self.submodels.values()]\n",
    "\n",
    "        # Update bounds based on submodel rebuild\n",
    "        self._update_bounds()\n",
    "        self._save_vars()\n",
    "        # Build cuts until we reach absolute and relative tolerance,\n",
    "        # or max_iters cuts have been generated.\n",
    "        while (\n",
    "            (self.data.ub > self.data.lb + self.data.delta or\n",
    "             self.data.ub - self.data.lb > abs(self.data.epsilon * self.data.lb)) and\n",
    "                len(self.data.cutlist) < self.params.max_iters):\n",
    "            # Generate new cut.\n",
    "            if self.params.verbose:\n",
    "                print('********')\n",
    "                print('* Benders\\' step {0}:'.format(len(self.data.upper_bounds)))\n",
    "                print('* Upper bound: {0}'.format(self.data.ub))\n",
    "                print('* Lower bound: {0}'.format(self.data.lb))\n",
    "                print('********')\n",
    "            self._do_benders_step()\n",
    "        pass\n",
    "\n",
    "    def _do_benders_step(self):\n",
    "            self._add_cut()\n",
    "            self._start_from_previous()\n",
    "            self.model.optimize()\n",
    "            [sm.update_fixed_vars(self) for sm in self.submodels.values()]\n",
    "            [sm.optimize() for sm in self.submodels.values()]\n",
    "            self._update_bounds()\n",
    "            self._save_vars()\n",
    "\n",
    "    def _init_benders_params(self, epsilon=0.001, delta=0.001):\n",
    "        self.data.cutlist = []\n",
    "        self.data.upper_bounds = []\n",
    "        self.data.lower_bounds = []\n",
    "        self.data.mipgap = []\n",
    "        self.data.solvetime = []\n",
    "        self.data.alphas = []\n",
    "        self.data.lambdas = {}\n",
    "        self.data.epsilon = epsilon\n",
    "        self.data.delta = delta\n",
    "        self.data.ub = gb.GRB.INFINITY\n",
    "        self.data.lb = -gb.GRB.INFINITY\n",
    "\n",
    "    ###\n",
    "    # Data Loading\n",
    "    ###\n",
    "    def _load_data(self):\n",
    "        self._load_generator_data()\n",
    "        self._load_demand_data()\n",
    "\n",
    "    def _load_generator_data(self):\n",
    "        self.data.geninfo = pd.read_csv('https://raw.githubusercontent.com/ming-zhao/Optimization-and-Learning/master/data/benders.csv', index_col='gen', skipinitialspace=True)\n",
    "        self.data.generators = self.data.geninfo.index\n",
    "\n",
    "    def _load_demand_data(self):\n",
    "        self.data.VOLL = 1000\n",
    "        self.data.demand_da = self.params.demand_avg\n",
    "        self.data.scenarios = ['s'+str(i) for i in range(self.params.numscenarios)]\n",
    "        self.data.demand_rt = pd.Series(\n",
    "            data=np.random.normal(self.params.demand_avg, self.params.demand_std, size=self.params.numscenarios),\n",
    "            index=self.data.scenarios)\n",
    "        self.data.scenarioprobs = {s: 1.0/self.params.numscenarios for s in self.data.scenarios}\n",
    "        # Dump load\n",
    "        self.data.dumploadprice = 10\n",
    "        self.data.dumploadmax = self.data.demand_da\n",
    "\n",
    "    ###\n",
    "    # Model Building\n",
    "    ###\n",
    "    def _build_model(self):\n",
    "        self.model = gb.Model()\n",
    "        self._build_variables()\n",
    "        self._build_objective()\n",
    "        self._build_constraints()\n",
    "        self.model.update()\n",
    "\n",
    "    def _build_variables(self):\n",
    "        m = self.model\n",
    "        gens = self.data.generators\n",
    "        geninfo = self.data.geninfo\n",
    "\n",
    "        self.variables.gprod_da = {}\n",
    "        for g in gens:\n",
    "            self.variables.gprod_da[g] = m.addVar(lb=0, ub=geninfo.maxprod[g])\n",
    "\n",
    "        self.variables.load_da = m.addVar(lb=0, ub=self.data.demand_da)\n",
    "\n",
    "        # Benders' proxy variable\n",
    "        self.variables.alpha = m.addVar(lb=-self.data.demand_da*self.data.VOLL, ub=gb.GRB.INFINITY)\n",
    "\n",
    "        m.update()\n",
    "\n",
    "    def _build_objective(self):\n",
    "        m = self.model\n",
    "        gens = self.data.generators\n",
    "        geninfo = self.data.geninfo\n",
    "\n",
    "        self.objective = m.setObjective(\n",
    "            gb.quicksum(geninfo.price[g] * self.variables.gprod_da[g] for g in gens) -\n",
    "            self.data.VOLL*self.variables.load_da +\n",
    "            self.variables.alpha)\n",
    "\n",
    "    def _build_constraints(self):\n",
    "        m = self.model\n",
    "        gens = self.data.generators\n",
    "        geninfo = self.data.geninfo\n",
    "\n",
    "        self.constraints.powerbalance_da = m.addConstr(\n",
    "            gb.quicksum(self.variables.gprod_da[g] for g in gens),\n",
    "            gb.GRB.EQUAL,\n",
    "            self.variables.load_da)\n",
    "\n",
    "        self.constraints.cuts = {}\n",
    "\n",
    "    def _add_cut(self):\n",
    "        gens = self.data.generators\n",
    "        geninfo = self.data.geninfo\n",
    "\n",
    "        cut = len(self.data.cutlist)\n",
    "        self.data.cutlist.append(cut)\n",
    "\n",
    "        # Get sensitivities from subproblem\n",
    "        sens_gen = {\n",
    "            g: sum(self.data.scenarioprobs[s] * self.submodels[s].constraints.fixed_da[g].pi for s in self.data.scenarios)\n",
    "            for g in gens}\n",
    "        self.data.lambdas[cut] = sens_gen\n",
    "        sens_load = sum(self.data.scenarioprobs[s] * self.submodels[s].constraints.fixed_load_da.pi for s in self.data.scenarios)\n",
    "        # Get subproblem objectives)\n",
    "        z_sub = sum(self.data.scenarioprobs[s] * self.submodels[s].model.ObjVal for s in self.data.scenarios)\n",
    "        # Generate cut\n",
    "        self.constraints.cuts[cut] = self.model.addConstr(\n",
    "            self.variables.alpha,\n",
    "            gb.GRB.GREATER_EQUAL,\n",
    "            z_sub +\n",
    "            gb.quicksum(sens_gen[g] * self.variables.gprod_da[g] for g in gens) -\n",
    "            sum(sens_gen[g] * self.variables.gprod_da[g].x for g in gens) +\n",
    "            sens_load * (self.variables.load_da - self.variables.load_da.x)\n",
    "        )\n",
    "\n",
    "    def _clear_cuts(self):\n",
    "        self.data.cutlist = []\n",
    "        self.data.lambdas = {}\n",
    "        self.model.update()\n",
    "        for con in self.constraints.cuts.values():\n",
    "            self.model.remove(con)\n",
    "        self.constraints.cuts = {}\n",
    "        self.data.ub = gb.GRB.INFINITY\n",
    "        self.data.lb = -gb.GRB.INFINITY\n",
    "        self.data.upper_bounds = []\n",
    "        self.data.lower_bounds = []\n",
    "\n",
    "    ###\n",
    "    # Update upper and lower bounds for Benders' iterations\n",
    "    ###\n",
    "    def _update_bounds(self):\n",
    "        z_sub = sum(self.data.scenarioprobs[s] * self.submodels[s].model.ObjVal for s in self.data.scenarios)\n",
    "        z_master = self.model.ObjVal\n",
    "        # The best upper bound is the best incumbent with\n",
    "        # alpha replaced by the sub problems' actual cost\n",
    "        self.data.ub = z_master - self.variables.alpha.x + z_sub\n",
    "        # The best lower bound is the current bestbound,\n",
    "        # This will equal z_master at optimality\n",
    "        try:\n",
    "            self.data.lb = self.model.ObjBound\n",
    "        except gb.GurobiError:\n",
    "            self.data.lb = self.model.ObjVal\n",
    "        self.data.upper_bounds.append(self.data.ub)\n",
    "        self.data.lower_bounds.append(self.data.lb)\n",
    "        self.data.mipgap.append(self.model.params.IntFeasTol)\n",
    "        self.data.solvetime.append(self.model.Runtime)\n",
    "\n",
    "    def _save_vars(self):\n",
    "        # self.data.xs.append(self.variables.x.x)\n",
    "        # self.data.ys.append(self.submodel.variables.y.x)\n",
    "        self.data.alphas.append(self.variables.alpha.x)\n",
    "\n",
    "    def _start_from_previous(self):\n",
    "        '''\n",
    "            Used to warm-start MIP problems.\n",
    "        '''\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Benders_Subproblem:\n",
    "    def __init__(self, MP, scenario=0):\n",
    "        self.data = expando()\n",
    "        self.variables = expando()\n",
    "        self.constraints = expando()\n",
    "        self.results = expando()\n",
    "        \n",
    "        self.MP = MP\n",
    "        self.data.scenario = scenario\n",
    "\n",
    "        self._build_model()\n",
    "        self.update_fixed_vars(MP)\n",
    "\n",
    "    def optimize(self):\n",
    "        self.model.optimize()\n",
    "\n",
    "    ###\n",
    "    #   Model Building\n",
    "    ###\n",
    "    def _build_model(self):\n",
    "        self.model = gb.Model()\n",
    "        self.model.setParam('OutputFlag', False)\n",
    "        self._build_variables()\n",
    "        self._build_objective()\n",
    "        self._build_constraints()\n",
    "        self.model.update()\n",
    "\n",
    "    def _build_variables(self):\n",
    "        m = self.model\n",
    "\n",
    "        dumploadmax = self.MP.data.dumploadmax\n",
    "        gens = self.MP.data.generators\n",
    "        geninfo = self.MP.data.geninfo\n",
    "        s = self.data.scenario\n",
    "        demandmax = self.MP.data.demand_rt[s]\n",
    "\n",
    "        # Production of generator g, up and downregulation\n",
    "        # Up and down regulation are limited by the generators' capability.\n",
    "        self.variables.gprod_da = {}\n",
    "        self.variables.gprod_rt = {}\n",
    "        self.variables.gprod_rt_up = {}\n",
    "        self.variables.gprod_rt_down = {}\n",
    "        for g in gens:\n",
    "            self.variables.gprod_da[g] = m.addVar(lb=0.0, ub=geninfo.maxprod[g])\n",
    "            self.variables.gprod_rt[g] = m.addVar(lb=0.0, ub=geninfo.maxprod[g])\n",
    "            self.variables.gprod_rt_up[g] = m.addVar(lb=0.0, ub=geninfo.maxprod[g] * geninfo.upflex[g])\n",
    "            self.variables.gprod_rt_down[g] = m.addVar(lb=0.0, ub=geninfo.maxprod[g] * geninfo.downflex[g])\n",
    "\n",
    "        self.variables.loadserved = m.addVar(lb=0.0, ub=demandmax)\n",
    "        self.variables.loadserved_DA = m.addVar(lb=0.0, ub=gb.GRB.INFINITY)\n",
    "        self.variables.dumpload = m.addVar(lb=0.0, ub=dumploadmax)\n",
    "\n",
    "        m.update()\n",
    "\n",
    "    def _build_objective(self):\n",
    "        m = self.model\n",
    "        gens = self.MP.data.generators\n",
    "        geninfo = self.MP.data.geninfo\n",
    "        VOLL = self.MP.data.VOLL\n",
    "        dumploadprice = self.MP.data.dumploadprice\n",
    "\n",
    "        m.setObjective(\n",
    "            gb.quicksum((geninfo.price[g] + geninfo.uppremium[g])*self.variables.gprod_rt_up[g] for g in gens) +\n",
    "            gb.quicksum((- geninfo.price[g] + geninfo.downpremium[g])*self.variables.gprod_rt_down[g] for g in gens) -\n",
    "            VOLL*(self.variables.loadserved-self.variables.loadserved_DA) +\n",
    "            dumploadprice * self.variables.dumpload\n",
    "        )\n",
    "\n",
    "    def _build_constraints(self):\n",
    "        m = self.model\n",
    "        gens = self.MP.data.generators\n",
    "\n",
    "        self.constraints.powerbalance_rt = m.addConstr(\n",
    "            gb.quicksum(self.variables.gprod_rt[g] for g in gens),\n",
    "            gb.GRB.EQUAL,\n",
    "            self.variables.loadserved + self.variables.dumpload)\n",
    "\n",
    "        self.constraints.coupling_da = {}\n",
    "        self.constraints.fixed_da = {}\n",
    "        for g in gens:\n",
    "            self.constraints.coupling_da[g] = m.addConstr(\n",
    "                self.variables.gprod_rt[g],\n",
    "                gb.GRB.EQUAL,\n",
    "                self.variables.gprod_da[g] + self.variables.gprod_rt_up[g] - self.variables.gprod_rt_down[g])\n",
    "            self.constraints.fixed_da[g] = m.addConstr(\n",
    "                self.variables.gprod_da[g],\n",
    "                gb.GRB.EQUAL,\n",
    "                0.0)\n",
    "        self.constraints.fixed_load_da = m.addConstr(\n",
    "            self.variables.loadserved_DA,\n",
    "            gb.GRB.EQUAL,\n",
    "            0.0)\n",
    "\n",
    "    def update_fixed_vars(self, MP):\n",
    "        for g in self.MP.data.generators:\n",
    "                self.constraints.fixed_da[g].rhs = MP.variables.gprod_da[g].x\n",
    "        self.constraints.fixed_load_da.rhs = MP.variables.load_da.x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "********\n",
      "* Benders' step 1:\n",
      "* Upper bound: -194905.0151374541\n",
      "* Lower bound: -396000.0\n",
      "********\n",
      "********\n",
      "* Benders' step 2:\n",
      "* Upper bound: -187402.87165686628\n",
      "* Lower bound: -195412.41513745408\n",
      "********\n",
      "********\n",
      "* Benders' step 3:\n",
      "* Upper bound: -190056.8887556546\n",
      "* Lower bound: -195394.04089071462\n",
      "********\n",
      "********\n",
      "* Benders' step 4:\n",
      "* Upper bound: -190189.18706464546\n",
      "* Lower bound: -195387.0448463883\n",
      "********\n",
      "********\n",
      "* Benders' step 5:\n",
      "* Upper bound: -191926.79858712998\n",
      "* Lower bound: -195371.37543796783\n",
      "********\n",
      "********\n",
      "* Benders' step 6:\n",
      "* Upper bound: -193053.94425360794\n",
      "* Lower bound: -195252.92352163696\n",
      "********\n",
      "********\n",
      "* Benders' step 7:\n",
      "* Upper bound: -193094.90138226718\n",
      "* Lower bound: -195252.59889917375\n",
      "********\n",
      "********\n",
      "* Benders' step 8:\n",
      "* Upper bound: -193758.79224701668\n",
      "* Lower bound: -195237.6931196585\n",
      "********\n",
      "********\n",
      "* Benders' step 9:\n",
      "* Upper bound: -193659.98456954808\n",
      "* Lower bound: -195220.181321286\n",
      "********\n",
      "********\n",
      "* Benders' step 10:\n",
      "* Upper bound: -194260.30295156644\n",
      "* Lower bound: -195202.9596396856\n",
      "********\n",
      "********\n",
      "* Benders' step 11:\n",
      "* Upper bound: -194459.43108348924\n",
      "* Lower bound: -195111.2427179468\n",
      "********\n",
      "********\n",
      "* Benders' step 12:\n",
      "* Upper bound: -194405.62220426043\n",
      "* Lower bound: -195073.99413989688\n",
      "********\n",
      "********\n",
      "* Benders' step 13:\n",
      "* Upper bound: -194510.54007723092\n",
      "* Lower bound: -195072.45353457573\n",
      "********\n",
      "********\n",
      "* Benders' step 14:\n",
      "* Upper bound: -194758.666887083\n",
      "* Lower bound: -195065.588551258\n",
      "********\n",
      "********\n",
      "* Benders' step 15:\n",
      "* Upper bound: -194781.09309929312\n",
      "* Lower bound: -194987.81892669486\n",
      "********\n",
      "********\n",
      "* Benders' step 16:\n",
      "* Upper bound: -194817.49128958743\n",
      "* Lower bound: -194980.491941937\n",
      "********\n",
      "********\n",
      "* Benders' step 17:\n",
      "* Upper bound: -194853.54839749951\n",
      "* Lower bound: -194972.91244241988\n",
      "********\n",
      "********\n",
      "* Benders' step 18:\n",
      "* Upper bound: -194894.67175970715\n",
      "* Lower bound: -194915.2602827549\n",
      "********\n",
      "********\n",
      "* Benders' step 19:\n",
      "* Upper bound: -194901.65770319957\n",
      "* Lower bound: -194910.86229620536\n",
      "********\n",
      "********\n",
      "* Benders' step 20:\n",
      "* Upper bound: -194904.55696394757\n",
      "* Lower bound: -194905.12253416877\n",
      "********\n",
      "********\n",
      "* Benders' step 21:\n",
      "* Upper bound: -194905.00495542135\n",
      "* Lower bound: -194905.0276661433\n",
      "********\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'Demand cleared in DA market [MW]')"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import numpy as np\n",
    "\n",
    "# from benders_stochastic_master import Benders_Master\n",
    "\n",
    "sns.set_style('ticks')\n",
    "\n",
    "m = Benders_Master()\n",
    "m.model.Params.OutputFlag = False\n",
    "m.optimize()\n",
    "\n",
    "m.model.write(\"test.lp\")\n",
    "\n",
    "rtdf = pd.DataFrame({g: {m.data.demand_rt[s]: m.submodels[s].variables.gprod_rt[g].x for s in m.data.scenarios} for g in m.data.generators})\n",
    "updf = pd.DataFrame({g: {m.data.demand_rt[s]: m.submodels[s].variables.gprod_rt_up[g].x for s in m.data.scenarios} for g in m.data.generators})\n",
    "downdf = pd.DataFrame({g: {m.data.demand_rt[s]: m.submodels[s].variables.gprod_rt_down[g].x for s in m.data.scenarios} for g in m.data.generators})\n",
    "\n",
    "dacost = m.model.ObjVal - m.variables.alpha.x\n",
    "rscostseries = pd.Series({m.data.demand_rt[s]: sum(\n",
    "    m.data.geninfo.price[g]*m.submodels[s].variables.gprod_rt[g].x +\n",
    "    m.data.geninfo.uppremium[g]*m.submodels[s].variables.gprod_rt_up[g].x +\n",
    "    m.data.geninfo.downpremium[g]*m.submodels[s].variables.gprod_rt_down[g].x\n",
    "    for g in m.data.generators) for s in m.data.scenarios})\n",
    "\n",
    "\n",
    "plt.ion()\n",
    "\n",
    "plt.figure(figsize=(12, 8))\n",
    "ax = plt.subplot(221)\n",
    "rtdf.plot(ax=ax, marker='.')\n",
    "plt.xlabel('Realised real-time demand [MW]')\n",
    "plt.ylabel('Generator setting [MW]')\n",
    "\n",
    "ax = plt.subplot(222)\n",
    "rscostseries.plot(ax=ax, marker='.')\n",
    "plt.xlabel('Realised real-time demand [MW]')\n",
    "plt.ylabel('Final cost [$]')\n",
    "\n",
    "ax = plt.subplot(223)\n",
    "updf.plot(ax=ax, marker='.')\n",
    "plt.xlabel('Realised real-time demand [MW]')\n",
    "plt.ylabel('Generator upregulation [MW]')\n",
    "\n",
    "ax = plt.subplot(224)\n",
    "downdf.plot(ax=ax, marker='.')\n",
    "plt.xlabel('Realised real-time demand [MW]')\n",
    "plt.ylabel('Generator downregulation [MW]')\n",
    "plt.tight_layout()\n",
    "\n",
    "m.model.Params.OutputFlag = False\n",
    "m.params.verbose = False\n",
    "demands = np.linspace(160, 240, 81)\n",
    "costs = []\n",
    "for demand in demands:\n",
    "    m.variables.load_da.ub = demand\n",
    "    m.variables.load_da.lb = demand\n",
    "    m._clear_cuts()\n",
    "    m.optimize()\n",
    "    costs.append(-m.model.ObjVal)\n",
    "m.variables.load_da.ub = 200\n",
    "m.variables.load_da.lb = 0\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(demands, costs)\n",
    "plt.ylabel('Social Welfare [$]')\n",
    "plt.xlabel('Demand cleared in DA market [MW]')"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}