{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![MOSEK ApS](https://www.mosek.com/static/images/branding/webgraphmoseklogocolor.png )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Unit Commitment Problem (UCP)\n",
    "\n",
    "The Unit Commitment Problem is an optimization problem in electrical power production. The goal is to assign production levels and switch-on/switch-off times to generators in a network so that the total production at any time meets the predicted demand for electricity. In this demonstration we consider minimizing production cost subject to constraints on the generating units: minimal/maximal production levels, minimum uptime/downtime and maximum ramp-up/ramp-down. The cost consists of quadratic production costs, fixed operating cost and start-up costs. That makes our version of UCP a Mixed Integer Conic Quadratic Optimization problem (MICQO).\n",
    "\n",
    "These are the most basic constraint types for a UCP model, see for example [this paper](http://pierrepinson.com/docs/HeideJorgensenetal2016.pdf) and references therein. We only model the total power generation of thermal units with constant startup costs, but not the storage capacity of hydro units nor cascades, power flow or bidding aspects; see for instance [a more thorough real-world model](https://www.ferc.gov/legal/staff-reports/rto-COMMITMENT-TEST.pdf). Many of those features could be added by extending our linear model. We use examples derived from datasets from the [OR-library](http://people.brunel.ac.uk/~mastjjb/jeb/info.html) (data is modified to fit into our framework). They are loaded with the script:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ucpParser"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The source file and examples are available in the GitHub repository containing this notebook. \n",
    "\n",
    "We demonstrate such aspects of working with MOSEK as:\n",
    "* setting up a model,\n",
    "* using variable slices to effectively write constraints,\n",
    "* retrieving optimizer statistics,\n",
    "* reoptimization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.cm as cm\n",
    "import numpy as np\n",
    "import sys\n",
    "from mosek.fusion import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem formulation\n",
    "\n",
    "In the UCP problem we are given a number $N$ of generators (*units*), a time horizon of $T$ *periods* (usually hours or half-hours) and initial conditions (see later). The goal is to determine electricity production levels for all units and all periods so that a total predicted *demand* is satisfied in each period. The operation of the units is subject to technical constraints which will be introduced below. The operating costs are known for each unit and can be split into *production costs*, *fixed operating costs* when the unit is on and *startup costs* incurred when the unit is switched on.\n",
    "\n",
    "We can model this setup using these simple variables:\n",
    "\n",
    "* a continous variable $p\\in\\mathbb{R}_+^{N\\times T}$ such that $p_{i,t}$ is the power generation of unit $i$ at time $t$,\n",
    "* a binary variable $u\\in\\{0,1\\}^{N\\times T}$, where $u_{i,t}$ indicates if unit $i$ is *on* (producing energy) at time $t$,\n",
    "* a binary variable $v\\in\\{0,1\\}^{N\\times T}$, where $v_{i,t}$ indicates if unit $i$ has been started (switched from *off* to *on*) at time $t$, in other words $v_{i,t}=\\max(u_{i,t}-u_{i-1,t},\\ 0)$.\n",
    "\n",
    "It will be convenient to declare variables of size $N\\times(T+1)$ and use the first column for initial conditions, that is production levels and on/off status at the beginning of the simulation. The code that initializes a Fusion model is shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class UCP:\n",
    "    # Initialize with input data\n",
    "    def __init__(self, T, N):\n",
    "        self.T, self.N = T, N\n",
    "        self.M = Model()\n",
    "\n",
    "        # Production level --- p_ih\n",
    "        self.p = self.M.variable([self.N, self.T+1], Domain.greaterThan(0.0))   \n",
    "        # Is active? --- u_ih\n",
    "        self.u = self.M.variable([self.N, self.T+1], Domain.binary())   \n",
    "        # Is at startup? --- v_ih >= u_ih-u_(i-1)h\n",
    "        self.v = self.M.variable([self.N, self.T+1], Domain.binary())   \n",
    "        self.M.constraint(Expr.sub(\n",
    "                            self.v.slice([0,1],[N,T+1]), \n",
    "                            Expr.sub(self.u.slice([0,1], [N,T+1]), self.u.slice([0,0], [N,T]))), \n",
    "                          Domain.greaterThan(0.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how we use slicing to express the constraint $v_{i,t}\\geq u_{i,t}-u_{i-1,t}$ simultaneously for all $i,t$. The two slices of $u$ have the same dimensions but are shifted by $1$ with respect to each other. The $i,t$-entry of the constraint expression is now just $v_{i,t}-(u_{i,t}-u_{i-1,t})\\geq 0$ as required. We are going to use this type of slicing heavily in what follows. Beacuse most of the operational constraints of the units will need to be broadcasted to all time periods, this repeat method will come in handy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a matrix with R columns each equal to v (horizontal repeat)\n",
    "def repeat(v, R):\n",
    "    return np.repeat(v, R).reshape(len(v), R)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Production constraints\n",
    "\n",
    "Each unit, when in use, operates between a minimal and maximal power level $p^{\\textrm{min}}_i$ and $p^{\\textrm{max}}_i$. If the unit is off, its production is $0$:\n",
    "\n",
    "$$p^{\\textrm{min}}_i u_{i,t}\\leq p_{i,t}\\leq p^{\\textrm{max}}_i u_{i,t}.$$\n",
    "\n",
    "Moreover, at each time $t$ the total production must satisfy the current demand $d_t$:\n",
    "\n",
    "$$\\sum_i p_{i,t} \\geq d_t,\\quad t=1,\\ldots,T.$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Production constraints\n",
    "def consProd(ucp, pmin, pmax, demand):\n",
    "    N, T, p, u, v = ucp.N, ucp.T, ucp.p, ucp.u, ucp.v\n",
    "    # Maximal and minimal production of each unit\n",
    "    ucp.M.constraint(Expr.sub(p, Expr.mulElm(repeat(pmax, T+1), u)), Domain.lessThan(0.0))\n",
    "    ucp.M.constraint(Expr.sub(p, Expr.mulElm(repeat(pmin, T+1), u)), Domain.greaterThan(0.0))\n",
    "    # Total demand in periods is achieved\n",
    "    ucp.M.constraint(Expr.sum(p, 0).slice(1,T+1), Domain.greaterThan(demand))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we used the ``Expr.sum(p, 0)`` operator to sum the $p$ matrix along the $0$-th dimension i.e. to compute sums within each column."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ramp constraints\n",
    "\n",
    "Ramp-up and ramp-down constraints indicate that the output of a generator cannot vary too rapidly between periods. \n",
    "\n",
    "$$p_{i-1,t}-r^{\\textrm{down}}_i\\leq p_{i,t}\\leq p_{i-1,t}+r^{\\textrm{up}}_i.$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ramp constraints \n",
    "def consRamp(ucp, rdown, rup):\n",
    "    N, T, p, u, v = ucp.N, ucp.T, ucp.p, ucp.u, ucp.v\n",
    "    Delta = Expr.sub(p.slice([0,1], [N,T+1]), p.slice([0,0], [N,T]))\n",
    "    ucp.M.constraint(Delta, Domain.lessThan(repeat(rup, T)))\n",
    "    ucp.M.constraint(Delta, Domain.greaterThan(-repeat(rdown, T)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initial values\n",
    "\n",
    "We also input the state of the system in the last period before the start of the simulation. We will load that information by fixing the values in the $0$-th column of the variables. For each generator the initial state is described by the values $p_{i,0}$ and $u_{i,0}$ as well as $l_i$ - the number of periods the unit has already spent in its current state (on/off). This will be required to properly handle the initial uptime/downtime constraint (see next)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initial values\n",
    "def consInit(ucp, p0, u0, l0):\n",
    "    N, T, p, u, v = ucp.N, ucp.T, ucp.p, ucp.u, ucp.v\n",
    "    # Fix production in the immediately preceeding period\n",
    "    ucp.M.constraint(p.slice([0,0],[N,1]), Domain.equalsTo(p0).withShape([N,1]))\n",
    "    ucp.M.constraint(u.slice([0,0],[N,1]), Domain.equalsTo(u0).withShape([N,1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Minimal downtime/uptime\n",
    "\n",
    "When a large thermal unit is turned on/off it will often be impossible to turn it back off/on before a minimal uptime/downtime $m^{\\textrm{up}}_i/m^{\\textrm{down}}_i$ (measured in periods) has elapsed. \n",
    "\n",
    "These conditions are modelled with the binary variable $u$. If the $i$-th unit is off at two times $t$ and $t+w$ with $w<m^{\\textrm{up}}_i$ then it must be off at all times $s$ in between not to violate the minimum uptime condition. This is equivalent to\n",
    "\n",
    "$$u_{i,t}+u_{i,t+w}\\geq u_{i,t+s},\\quad 1 < s< w < m^{\\textrm{up}}_i.$$\n",
    "\n",
    "This condition can again be expressed by combining three slices of $u$ with offsets $0,s,w$ (this time separately for each row of $u$). A similar linear inequality is used to model minimum downtime.\n",
    "\n",
    "Finally the initial condition $l_i$ may require fixing some $u_{i,t}$ for small $t$ if historically a unit was not on/off long enough to fill the minimum uptime/downtime conditions at the beginning of the process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Minimal downtime/uptime requirements\n",
    "def consMinT(ucp, mdown, mup, u0, l0):\n",
    "    N, T, p, u, v = ucp.N, ucp.T, ucp.p, ucp.u, ucp.v\n",
    "    # Different units will have different requirements\n",
    "    for unit in range(N):\n",
    "        # First, take care of neighbourhood of initial conditions\n",
    "        if u0[unit] == 0 and l0[unit] < mdown[unit]:\n",
    "            ucp.M.constraint(u.slice([unit,1],[unit+1,mdown[unit]-l0[unit]+1]), Domain.equalsTo(0))\n",
    "        if u0[unit] == 1 and l0[unit] < mup[unit]:\n",
    "            ucp.M.constraint(u.slice([unit,1],[unit+1,mup[unit]-l0[unit]+1]), Domain.equalsTo(1))\n",
    "        # If we are off in i and i+w (w<mup), we must be off in between:\n",
    "        for w in range(1,mup[unit]):\n",
    "            for s in range(1,w):\n",
    "                ucp.M.constraint(\n",
    "                    Expr.sub(\n",
    "                        Expr.add(u.slice([unit,0],[unit+1,T-w+1]), \n",
    "                                 u.slice([unit,w],[unit+1,T+1])),\n",
    "                        u.slice([unit,s],[unit+1,T-w+1+s])),\n",
    "                    Domain.greaterThan(0))\n",
    "        # If we are on in i and i+w (w<mdown), we must be on in between:\n",
    "        for w in range(1,mdown[unit]):\n",
    "            for s in range(1,w):\n",
    "                ucp.M.constraint(\n",
    "                    Expr.sub(\n",
    "                        Expr.add(u.slice([unit,0],[unit+1,T-w+1]), \n",
    "                                 u.slice([unit,w],[unit+1,T+1])),\n",
    "                        u.slice([unit,s],[unit+1,T-w+1+s])),\n",
    "                    Domain.lessThan(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Objective: cost minimization\n",
    "\n",
    "We consider three types of power generation costs per unit $i$ per period:\n",
    "\n",
    "* production cost $C_i(p) = a_ip^2+b_ip+c_i$ depending quadratically on power generation $p$,\n",
    "* a fixed cost of $\\textrm{fx}_i$ when in production ($u_{i,t}=1$),\n",
    "* a fixed startup cost $\\textrm{sc}_i$ whenever the unit is being switched on ($v_{i,t}=1$).\n",
    "\n",
    "The total cost is the sum of all these costs. The costs associated to $b, \\textrm{fx}, \\textrm{sc}$ can be added up simply using inner product (note that the ``Expr.dot`` does the right thing for any two objects of the same shape). The quadratic terms (optional) are upper-bounded using auxiliary variables $t_i$ with rotated quadratic cone inequalities:\n",
    "\n",
    "$$2\\cdot\\frac12\\cdot t_i\\geq \\sum_{t}p_{i,t}^2.$$\n",
    "\n",
    "There is one such constraint per row, but they are bundled together in matrix form."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Objective\n",
    "def objective(ucp, a, b, c, fx, sc, onlyLinear=False):\n",
    "    N, T, p, u, v = ucp.N, ucp.T, ucp.p, ucp.u, ucp.v\n",
    "    # Startup costs and fixed operating costs\n",
    "    scCost = Expr.dot(v.slice([0,1],[N,T+1]), repeat(sc, T))\n",
    "    fxCost = Expr.dot(u.slice([0,1],[N,T+1]), repeat(fx, T))\n",
    "    # Linear part of production cost bp\n",
    "    bCost = Expr.sum(Expr.mul(b, p.slice([0,1],[N,T+1])))\n",
    "    allCosts = [bCost, Expr.constTerm(sum(c)*ucp.T), fxCost, scCost]\n",
    "    # Quadratic part of production cost ap^2\n",
    "    if not onlyLinear:\n",
    "        t = ucp.M.variable(ucp.N) \n",
    "        ucp.M.constraint(Expr.hstack(Expr.constTerm(N, 0.5), t, p.slice([0,1],[N,T+1])), Domain.inRotatedQCone())\n",
    "        aCost = Expr.dot(a, t)\n",
    "        allCosts.append(aCost)\n",
    "    # Total\n",
    "    ucp.M.objective(ObjectiveSense.Minimize, Expr.add(allCosts))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example\n",
    "\n",
    "The available datasets span over a time horizon of $T=24$ hours, but the parser allows to extend them by repeating periodically over a given number of days. We load the data and apply all the constraints defined previously."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "example='RCUC/T-Ramp/20_0_3_w.mod'\n",
    "numDays = 3\n",
    "\n",
    "T, N, demand, pmin, pmax, rdown, rup, mdown, mup, a, b, c, sc, fx, p0, u0, l0 = ucpParser.loadModel(example, numDays)\n",
    "\n",
    "ucp = UCP(T, N)\n",
    "consProd(ucp, pmin, pmax, demand)\n",
    "consRamp(ucp, rdown, rup)\n",
    "consInit(ucp, p0, u0, l0)\n",
    "consMinT(ucp, mdown, mup, u0, l0)\n",
    "objective(ucp, a, b, c, fx, sc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now solve the model. It is recommended to relax termination critieria for the mixed-integer optimizer using MOSEK parameters. Here we will accept solutions with relative optimality tolerance $0.6\\%$, i.e. $0.6\\%$ from the objective bound. Another option is to set a time limit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Problem\n",
      "  Name                   :                 \n",
      "  Objective sense        : min             \n",
      "  Type                   : CONIC (conic optimization problem)\n",
      "  Constraints            : 45186           \n",
      "  Cones                  : 20              \n",
      "  Scalar variables       : 5880            \n",
      "  Matrix variables       : 0               \n",
      "  Integer variables      : 2920            \n",
      "\n",
      "Optimizer started.\n",
      "Mixed integer optimizer started.\n",
      "Threads used: 20\n",
      "Presolve started.\n",
      "Presolve terminated. Time = 0.60\n",
      "Presolved problem: 4202 variables, 23928 constraints, 68589 non-zeros\n",
      "Presolved problem: 6 general integer, 2722 binary, 1474 continuous\n",
      "Clique table size: 264\n",
      "BRANCHES RELAXS   ACT_NDS  DEPTH    BEST_INT_OBJ         BEST_RELAX_OBJ       REL_GAP(%)  TIME  \n",
      "0        1        0        0        NA                   1.0194202063e+07     NA          2.1   \n",
      "0        1        0        0        1.0274207592e+07     1.0194202063e+07     0.78        4.2   \n",
      "0        1        0        0        1.0273069330e+07     1.0194202063e+07     0.77        6.7   \n",
      "Cut generation started.\n",
      "0        2        0        0        1.0273069330e+07     1.0194202076e+07     0.77        11.8  \n",
      "Cut generation terminated. Time = 2.10\n",
      "15       18       16       3        1.0273069330e+07     1.0195441291e+07     0.76        20.6  \n",
      "31       34       32       4        1.0273069330e+07     1.0196172229e+07     0.75        23.9  \n",
      "51       54       52       5        1.0273069330e+07     1.0196172229e+07     0.75        28.1  \n",
      "91       94       92       6        1.0273069330e+07     1.0196440912e+07     0.75        36.6  \n",
      "171      174      172      9        1.0273069330e+07     1.0196888331e+07     0.74        57.6  \n",
      "331      334      332      17       1.0273069330e+07     1.0196888331e+07     0.74        97.6  \n",
      "585      588      586      30       1.0253254768e+07     1.0196888331e+07     0.55        161.4 \n",
      "An optimal solution satisfying the relative gap tolerance of 6.00e-01(%) has been located.\n",
      "The relative gap is 5.50e-01(%).\n",
      "\n",
      "Objective of best integer solution : 1.025325476809e+07      \n",
      "Best objective bound               : 1.019688833111e+07      \n",
      "Construct solution objective       : Not employed\n",
      "Construct solution # roundings     : 0\n",
      "User objective cut value           : 0\n",
      "Number of cuts generated           : 0\n",
      "Number of branches                 : 585\n",
      "Number of relaxations solved       : 588\n",
      "Number of interior point iterations: 26487\n",
      "Number of simplex iterations       : 0\n",
      "Time spend presolving the root     : 0.60\n",
      "Time spend in the heuristic        : 0.00\n",
      "Time spend in the sub optimizers   : 0.00\n",
      "  Time spend optimizing the root   : 1.40\n",
      "Mixed integer optimizer terminated. Time: 161.56\n",
      "\n",
      "Optimizer terminated. Time: 161.75  \n",
      "\n",
      "\n",
      "Integer solution solution summary\n",
      "  Problem status  : PRIMAL_FEASIBLE\n",
      "  Solution status : INTEGER_OPTIMAL\n",
      "  Primal.  obj: 1.0253254768e+07    nrm: 5e+06    Viol.  con: 7e-15    var: 0e+00    cones: 1e-08    itg: 0e+00  \n"
     ]
    }
   ],
   "source": [
    "ucp.M.setLogHandler(sys.stdout)\n",
    "ucp.M.setSolverParam(\"mioTolRelGap\", 0.03) # 3%\n",
    "#ucp.M.setSolverParam(\"mioMaxTime\", 30.0)   # 30 sec.\n",
    "ucp.M.solve()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we print some solution statistics and fetch the solution values for $p$ and $u$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solution status: SolutionStatus.Optimal\n",
      "Relative optimiality gap: 0.55%\n",
      "Total solution time: 161.75s\n"
     ]
    }
   ],
   "source": [
    "# Fetch results\n",
    "def results(ucp):\n",
    "    N, T, p, u, v = ucp.N, ucp.T, ucp.p, ucp.u, ucp.v\n",
    "    # Check if problem is feasible\n",
    "    if ucp.M.getProblemStatus(SolutionType.Default) in [ProblemStatus.PrimalFeasible]:\n",
    "        # For time-constrained optimization it may be wise to accept any feasible solution\n",
    "        ucp.M.acceptedSolutionStatus(AccSolutionStatus.Feasible)\n",
    "        \n",
    "        # Some statistics:\n",
    "        print('Solution status: {0}'.format(ucp.M.getPrimalSolutionStatus()))\n",
    "        print('Relative optimiality gap: {:.2f}%'.format(100*ucp.M.getSolverDoubleInfo(\"mioObjRelGap\")))\n",
    "        print('Total solution time: {:.2f}s'.format(ucp.M.getSolverDoubleInfo(\"optimizerTime\")))\n",
    "\n",
    "        return p.level().reshape([N,T+1]), u.level().reshape([N,T+1])\n",
    "    else:\n",
    "        raise ValueError(\"No solution\")\n",
    "\n",
    "pVal, uVal = results(ucp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The solution status is reported as optimal because we previously requested that solutions with relative optimiality gap less than $0.6\\%$ are treated as such. We can also plot interesting statistics. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faacc512c18>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Display some statistics\n",
    "def displayProduction(ucp, pVal, uVal, pmax):\n",
    "    N, T, p, u, v = ucp.N, ucp.T, ucp.p, ucp.u, ucp.v    \n",
    "    f, axarr = plt.subplots(5, sharex=True, figsize=[10,10])\n",
    "    # Production relative to global maximum\n",
    "    axarr[0].imshow(pVal/max(pmax), extent=(0,T+1,0,N),\n",
    "               interpolation='nearest', cmap=cm.YlOrRd,\n",
    "               vmin=0, vmax=1, aspect='auto')\n",
    "    # Production relative to maximum of each unit\n",
    "    axarr[1].imshow(pVal/repeat(pmax, T+1), extent=(0,T+1,0,N),\n",
    "               interpolation='nearest', cmap=cm.YlOrRd,\n",
    "               vmin=0, vmax=1, aspect='auto')\n",
    "    # On/off status\n",
    "    axarr[2].imshow(uVal, extent=(0,T+1,0,N),\n",
    "               interpolation='nearest', cmap=cm.YlOrRd,\n",
    "               vmin=0, vmax=1, aspect='auto')    \n",
    "    # Number of units in operation\n",
    "    axarr[3].plot(np.sum(uVal, axis=0))\n",
    "    # Demand coverage and spinning reserve\n",
    "    axarr[4].plot(demand, 'r', np.sum(repeat(pmax,T)*uVal[:,1:], axis=0), 'g')\n",
    "\n",
    "    plt.show()\n",
    "    \n",
    "displayProduction(ucp, pVal, uVal, pmax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The horizontal axis is time. In the first three plots the history of each unit is represented by a single row. From top to bottom the five plots are:\n",
    "\n",
    "1. Production level of each unit relative to the maximal possible production of any unit ($\\frac{p_{i,t}}{\\max_i(p^{\\textrm{max}}_i)}$).\n",
    "2. Production level of each unit relative to its own maximal possible production ($\\frac{p_{i,t}}{p^{\\textrm{max}}_i}$).\n",
    "3. Which units are active/inactive ($u_{i,t}$).\n",
    "4. The number of active units.\n",
    "5. Red - the demand at time periods. Green - the maximal total power of all units active at any given period. The difference is the *spinning reserve* of the system."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reoptimization\n",
    "\n",
    "We can easily add new constraints to an existing Fusion model. For example, we could generate a list of random failures by declaring certain $u_{i,t}$ to be $0$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Random switch-off of some generators\n",
    "np.random.seed(0)\n",
    "def consSOff(ucp, num):\n",
    "    N, T, p, u, v = ucp.N, ucp.T, ucp.p, ucp.u, ucp.v   \n",
    "    ucp.M.constraint(u.pick(list(np.random.randint(0,N,size=num)), list(np.random.randint(5,T,size=num))), \n",
    "        Domain.equalsTo(0.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now reoptimize the old model with the extra new constraints:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Problem\n",
      "  Name                   :                 \n",
      "  Objective sense        : min             \n",
      "  Type                   : CONIC (conic optimization problem)\n",
      "  Constraints            : 45196           \n",
      "  Cones                  : 20              \n",
      "  Scalar variables       : 5880            \n",
      "  Matrix variables       : 0               \n",
      "  Integer variables      : 2920            \n",
      "\n",
      "Optimizer started.\n",
      "Mixed integer optimizer started.\n",
      "Threads used: 20\n",
      "Presolve started.\n",
      "Presolve terminated. Time = 1.05\n",
      "Presolved problem: 4172 variables, 23792 constraints, 67807 non-zeros\n",
      "Presolved problem: 18 general integer, 2692 binary, 1462 continuous\n",
      "Clique table size: 680\n",
      "BRANCHES RELAXS   ACT_NDS  DEPTH    BEST_INT_OBJ         BEST_RELAX_OBJ       REL_GAP(%)  TIME  \n",
      "0        1        0        0        NA                   1.0237076498e+07     NA          2.2   \n",
      "0        1        0        0        1.0298496877e+07     1.0237076498e+07     0.60        4.3   \n",
      "An optimal solution satisfying the relative gap tolerance of 7.00e-01(%) has been located.\n",
      "The relative gap is 5.96e-01(%).\n",
      "\n",
      "Objective of best integer solution : 1.029849687703e+07      \n",
      "Best objective bound               : 1.023707649758e+07      \n",
      "Construct solution objective       : Unsuccessful\n",
      "Construct solution # roundings     : 0\n",
      "User objective cut value           : 0\n",
      "Number of cuts generated           : 0\n",
      "Number of branches                 : 0\n",
      "Number of relaxations solved       : 1\n",
      "Number of interior point iterations: 49\n",
      "Number of simplex iterations       : 0\n",
      "Time spend presolving the root     : 1.05\n",
      "Time spend in the heuristic        : 0.00\n",
      "Time spend in the sub optimizers   : 0.00\n",
      "  Time spend optimizing the root   : 1.12\n",
      "Mixed integer optimizer terminated. Time: 4.29\n",
      "\n",
      "Optimizer terminated. Time: 4.31    \n",
      "\n",
      "\n",
      "Integer solution solution summary\n",
      "  Problem status  : PRIMAL_FEASIBLE\n",
      "  Solution status : INTEGER_OPTIMAL\n",
      "  Primal.  obj: 1.0298496877e+07    nrm: 4e+06    Viol.  con: 7e-15    var: 0e+00    cones: 1e-08    itg: 0e+00  \n",
      "Solution status: SolutionStatus.Optimal\n",
      "Relative optimiality gap: 0.60%\n",
      "Total solution time: 4.31s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7faacd8f2cf8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "consSOff(ucp, 10)\n",
    "ucp.M.setSolverParam(\"mioTolRelGap\", 0.02) # 2%\n",
    "ucp.M.solve()\n",
    "pVal, uVal = results(ucp)\n",
    "displayProduction(ucp, pVal, uVal, pmax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\"><img alt=\"Creative Commons License\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by/4.0/80x15.png\" /></a><br />This work is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\">Creative Commons Attribution 4.0 International License</a>. The **MOSEK** logo and name are trademarks of <a href=\"http://mosek.com\">Mosek ApS</a>. The code is provided as-is. Compatibility with future release of **MOSEK** or the `Fusion API` are not guaranteed. For more information contact our [support](mailto:support@mosek.com). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}