getting_started/06_Redispatching_Curtailment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# In this notebook you will learn about the redispatching and curtailment capabilities offered by grid2op.\n",
    "Try me out interactively with: [![Binder](./img/badge_logo.svg)](https://mybinder.org/v2/gh/rte-france/Grid2Op/master)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Objectives**\n",
    "\n",
    "In the previous notebooks, we presented actions in a discrete action space. However, more actions are available in Grid2Op. Redispatching and curtailment are kind of continuous action that will be described here.\n",
    "\n",
    "This notebook will:\n",
    "\n",
    "- [I) Redispatching](#redispatching) details redispatching\n",
    "    - present what redispatching is\n",
    "    - show how it can be used in grid2op\n",
    "    - detail the redispatching actions\n",
    "    - show an example of a redispatching Agent\n",
    "- [II) Curtailment](#curtailment) explains the curtailment\n",
    "    - show the behaviour of the curtailment: how to perform it, what is does etc.\n",
    "    - expose some limits of this curtailment: it can break the grid easily !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://colab.research.google.com/assets/colab-badge.svg\" width=\"200\">\n",
    "Execute the cell below by removing the # character if you use google colab !\n",
    "\n",
    "Cell will look like:\n",
    "```python\n",
    "!pip install grid2op[optional]  # for use with google colab (grid2Op is not installed by default)\n",
    "```\n",
    "<img src=\"https://colab.research.google.com/assets/colab-badge.svg\" width=\"200\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install grid2op[optional]  # for use with google colab (grid2Op is not installed by default)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\thoma\\anaconda3\\envs\\MA\\Lib\\site-packages\\grid2op\\Backend\\pandaPowerBackend.py:32: UserWarning: Numba cannot be loaded. You will gain possibly massive speed if installing it by \n",
      "\tc:\\Users\\thoma\\anaconda3\\envs\\MA\\python.exe -m pip install numba\n",
      "\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import grid2op\n",
    "from grid2op.Agent import DoNothingAgent, BaseAgent\n",
    "from tqdm.notebook import tqdm  # for easy progress bar\n",
    "display_tqdm = False  # this is set to False for ease with the unitt test, feel free to set it to True\n",
    "import numpy as np\n",
    "max_iter = 100  # to make computation much faster we will only consider 100 time steps\n",
    "import pdb\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div id=\"my_id_menu_nb\">run previous cell, wait for 2 seconds</div>\n",
       "<script>\n",
       "function repeat_indent_string(n){\n",
       "    var a = \"\" ;\n",
       "    for ( ; n > 0 ; --n)\n",
       "        a += \"    \";\n",
       "    return a;\n",
       "}\n",
       "// look up into all sections and builds an automated menu //\n",
       "var update_menu_string = function(begin, lfirst, llast, sformat, send, keep_item, begin_format, end_format) {\n",
       "    var anchors = document.getElementsByClassName(\"section\");\n",
       "    if (anchors.length == 0) {\n",
       "        anchors = document.getElementsByClassName(\"text_cell_render rendered_html\");\n",
       "    }\n",
       "    var i,t;\n",
       "    var text_menu = begin;\n",
       "    var text_memo = \"<pre>\\nlength:\" + anchors.length + \"\\n\";\n",
       "    var ind = \"\";\n",
       "    var memo_level = 1;\n",
       "    var href;\n",
       "    var tags = [];\n",
       "    var main_item = 0;\n",
       "    var format_open = 0;\n",
       "    for (i = 0; i <= llast; i++)\n",
       "        tags.push(\"h\" + i);\n",
       "\n",
       "    for (i = 0; i < anchors.length; i++) {\n",
       "        text_memo += \"**\" + anchors[i].id + \"--\\n\";\n",
       "\n",
       "        var child = null;\n",
       "        for(t = 0; t < tags.length; t++) {\n",
       "            var r = anchors[i].getElementsByTagName(tags[t]);\n",
       "            if (r.length > 0) {\n",
       "child = r[0];\n",
       "break;\n",
       "            }\n",
       "        }\n",
       "        if (child == null) {\n",
       "            text_memo += \"null\\n\";\n",
       "            continue;\n",
       "        }\n",
       "        if (anchors[i].hasAttribute(\"id\")) {\n",
       "            // when converted in RST\n",
       "            href = anchors[i].id;\n",
       "            text_memo += \"#1-\" + href;\n",
       "            // passer à child suivant (le chercher)\n",
       "        }\n",
       "        else if (child.hasAttribute(\"id\")) {\n",
       "            // in a notebook\n",
       "            href = child.id;\n",
       "            text_memo += \"#2-\" + href;\n",
       "        }\n",
       "        else {\n",
       "            text_memo += \"#3-\" + \"*\" + \"\\n\";\n",
       "            continue;\n",
       "        }\n",
       "        var title = child.textContent;\n",
       "        var level = parseInt(child.tagName.substring(1,2));\n",
       "\n",
       "        text_memo += \"--\" + level + \"?\" + lfirst + \"--\" + title + \"\\n\";\n",
       "\n",
       "        if ((level < lfirst) || (level > llast)) {\n",
       "            continue ;\n",
       "        }\n",
       "        if (title.endsWith('¶')) {\n",
       "            title = title.substring(0,title.length-1).replace(\"<\", \"&lt;\")\n",
       "         .replace(\">\", \"&gt;\").replace(\"&\", \"&amp;\");\n",
       "        }\n",
       "        if (title.length == 0) {\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        while (level < memo_level) {\n",
       "            text_menu += end_format + \"</ul>\\n\";\n",
       "            format_open -= 1;\n",
       "            memo_level -= 1;\n",
       "        }\n",
       "        if (level == lfirst) {\n",
       "            main_item += 1;\n",
       "        }\n",
       "        if (keep_item != -1 && main_item != keep_item + 1) {\n",
       "            // alert(main_item + \" - \" + level + \" - \" + keep_item);\n",
       "            continue;\n",
       "        }\n",
       "        while (level > memo_level) {\n",
       "            text_menu += \"<ul>\\n\";\n",
       "            memo_level += 1;\n",
       "        }\n",
       "        text_menu += repeat_indent_string(level-2);\n",
       "        text_menu += begin_format + sformat.replace(\"__HREF__\", href).replace(\"__TITLE__\", title);\n",
       "        format_open += 1;\n",
       "    }\n",
       "    while (1 < memo_level) {\n",
       "        text_menu += end_format + \"</ul>\\n\";\n",
       "        memo_level -= 1;\n",
       "        format_open -= 1;\n",
       "    }\n",
       "    text_menu += send;\n",
       "    //text_menu += \"\\n\" + text_memo;\n",
       "\n",
       "    while (format_open > 0) {\n",
       "        text_menu += end_format;\n",
       "        format_open -= 1;\n",
       "    }\n",
       "    return text_menu;\n",
       "};\n",
       "var update_menu = function() {\n",
       "    var sbegin = \"\";\n",
       "    var sformat = '<a href=\"#__HREF__\">__TITLE__</a>';\n",
       "    var send = \"\";\n",
       "    var begin_format = '<li>';\n",
       "    var end_format = '</li>';\n",
       "    var keep_item = -1;\n",
       "    var text_menu = update_menu_string(sbegin, 2, 4, sformat, send, keep_item,\n",
       "       begin_format, end_format);\n",
       "    var menu = document.getElementById(\"my_id_menu_nb\");\n",
       "    menu.innerHTML=text_menu;\n",
       "};\n",
       "window.setTimeout(update_menu,2000);\n",
       "            </script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = None\n",
    "try:\n",
    "    from jyquickhelper import add_notebook_menu\n",
    "    res = add_notebook_menu()\n",
    "except ModuleNotFoundError:\n",
    "    print(\"Impossible to automatically add a menu / table of content to this notebook.\\nYou can download \\\"jyquickhelper\\\" package with: \\n\\\"pip install jyquickhelper\\\"\")\n",
    "res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# I) Redispatching  <a class=\"anchor\" id=\"redispatching\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to implement redispatch actions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Having a suitable environment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, some environments do not specify the cost of generators, their maximum and minimum production values, etc. In this case it is not possible to redispatch in grid2op.\n",
    "\n",
    "To know more about what is needed for using redispatching, it is advised to look at this help online : https://grid2op.readthedocs.io/en/latest/space.html#grid2op.Space.GridObjects.redispatching_unit_commitment_availble for the most recent documentation. When this notebook was created, the following were needed:\n",
    "\n",
    "- \"gen_type\": the type of generator\n",
    "- \"gen_pmin\": the minimum value a generator can produce\n",
    "- \"gen_pmax\" : the maximum value a generator can produce\n",
    "- \"gen_redispatchable\": whether this generator can be dispatched\n",
    "- \"gen_max_ramp_up\": the maximum increase of power a generator can have between two consecutive time steps\n",
    "- \"gen_max_ramp_down\": the maximum decrease of power a generator can have between two consecutive time steps\n",
    "- \"gen_min_uptime\": the minimum time a generator needs to be turned on (it's impossible to disconnect it if it's not connected for a least \"gen_min_uptime\" consecutive time step)\n",
    "- \"gen_min_downtime\": same as above, but for downtime\n",
    "- \"gen_cost_per_MW\": the generation cost. For each MW of electricity produced in a time step, this is the amount paid\n",
    "- \"gen_startup_cost\": the cost to start a generator\n",
    "- \"gen_shutdown_cost\": the cost to shutdown a generator\n",
    "\n",
    "We made available a dedicated environment, based on the IEEE case14 powergrid that has all this features. It is advised to use this small environment for testing and getting familiar with redispatching.\n",
    "\n",
    "This environment includes 5 generators, as the original case14 system. It has one solar generator and one wind generator (that cannot be dispatched), one nuclear powerplant (dispatchable) and 2 thermal generators (also dispatchable). Thus, redispatching is a problem of continuous control with 3 degress of freedom here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\thoma\\anaconda3\\envs\\MA\\Lib\\site-packages\\grid2op\\MakeEnv\\Make.py:438: UserWarning: You are using a development environment. This environment is not intended for training agents. It might not be up to date and its primary use if for tests (hence the \"test=True\" you passed as argument). Use at your own risk.\n",
      "  warnings.warn(_MAKE_DEV_ENV_WARN)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is this environment suitable for redispatching: True\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    from lightsim2grid import LightSimBackend\n",
    "    bk_cls = LightSimBackend\n",
    "except ImportError as exc:\n",
    "    print(f\"Error: {exc} when importing faster LightSimBackend\")\n",
    "    from grid2op.Backend import PandaPowerBackend\n",
    "    bk_cls = PandaPowerBackend\n",
    "\n",
    "env_name = \"l2rpn_case14_sandbox\"\n",
    "env = grid2op.make(env_name, test=True, backend=bk_cls())\n",
    "\n",
    "print(\"Is this environment suitable for redispatching: {}\".format(env.redispatching_unit_commitment_availble))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, this environment is suitable for redispatching. It means that all quantities described above are set (and visible).\n",
    "\n",
    "In the L2RPN 2019 challenges, we rewarded participants based on the use of the powerlines. In next challenges, or for other uses of this platform where redispatching should be considered, it's better to consider the economic cost of the sytem as an evaluation metric. However, usually a cost should be minimized, while a reward should be maximized. To take this into account, a simple reward named \"EconomicReward\" has been created. It has the following properties:\n",
    "\n",
    "- it returns -1 if there has been a game over\n",
    "- otherwise (there has been no game over, no errors, etc) it is always strictly positive\n",
    "- maximizing this reward is equivalent to minimizing the cost\n",
    "\n",
    "Note that this reward doesn't take into account the cost to perform a redispatching action. This reward can be used to build what is called an \"economic dispatch\", a problem that is particularly interesting for electricity producers but of lower interest for Transmission System Operators (as opposed to the topology).\n",
    "\n",
    "Compared to standard \"economic dispatch\" problems, for now storages are not implemented (coming soon) and we don't fully take into account the startup cost, shutdown cost, as well as minimum downtime and minimum uptime (even though all of these features are implemented). Also, note that redispatching is implemented in differences, meaning that you first need to provide an economic dispatch, and then think in terms of variations from that point onward. This is the usage that will be explained in this notebook. For real unit commitment / economic dispatch problems, the key words \"injections\" / \"prod_p\" for the action would probably be more suited."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Redispatching implementation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike topological actions which are always feasible (this is an assumption that is made in this package), redispatching actions are limited by physical constraints on the generators. For example:\n",
    "\n",
    "- it is not possible for a generator to produce more (resp. less) than pmax (resp. pmin). Unlike the curent flow on the powerline, this is a strict physical constraint.\n",
    "- it is not possible for the same physical limitations to increase (or decrease) too much the value between two consecutive time steps.\n",
    "- redispatching actions stack with one another. It means that if you ask to increase the production of the generator 1 by $10MW$ at time step t, and by $20MW$ at time step $t+1$, it means that the set point at time step $t+1$ will be $+30MW$ higher than if no redispatching had been made (it would have been only $+10MW$ higher if the second redispatching action had not been performed).\n",
    "\n",
    "That being said, much can happen that makes redispatching a bit less trivial than topology changes:\n",
    "- When you do a redispatching action, you don't know what the time series of the environment looks like. For example, say the pmax of generator 1 is 100. The setpoint of this generator at time t is $60MW$, and you want to increase its value by another $40MW$. This action is legal: $60+40 \\leq pmax (=100) $. So at time $t$ everything is fine. Now let's suppose that the environment also moved the setpoint of this same generator from $60$ to be at $70MW$ at time $t+1$. With the redispatching action, this would mean that the setpoint would be $70+40 = 110 > pmax$. This is not possible. In this case, the redispatching action will be capped : instead of the desired redispatching of $+40$, only a smaller redispatching of $+30$ will be implemented on the powergrid. \n",
    "- Another problem can arise with the fundamental principle of power grid: power energy cannot be stored in a grid. At each time we then have $\\sum \\text{Prod} = \\sum \\text{Load} + \\text{Losses}$. In this competition, the data is generated such that this condition holds (approximately) for all time steps. This means that if you ask for a redispatching of +xxx MW on a given generator, then the other ones must compensate and \"absorb\" xxx MW such that it sums to 0 overall.\n",
    "\n",
    "Out of simplicity for the participants, there are some built-in control mechanisms and functions (\"automatons\") that automatically transform an proposed redispatching action into a valid redispatching action. \n",
    "\n",
    "These automatons basically ensure that the two above-mentionned conditions hold. It explains the differences between \"target_redispatching\" which is the desired setpoint enter by the agent, and the \"actual_redispatching\" which is the one that has actually been implemented on the powergrid after it has been corrected by the automatons."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More cases for ambiguous actions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True, False, False, False,  True])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env.gen_redispatchable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above vector tells which generator is dispatchable and which is not. Any attempt to dispatch a generator that is not dispatchable leads to an ambiguous action."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True,\n",
       " Grid2OpException AmbiguousAction InvalidRedispatching InvalidRedispatching('Trying to apply a redispatching action on a non redispatchable generator'))"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "act = env.action_space({\"redispatch\": [(2, +10)]})\n",
    "act.is_ambiguous()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we see, this action is ambiguous because we are `Trying to apply a redispatching action on a non redispatchable generator`. Indeed, as shown above, the generator 2 is not dispatchable.\n",
    "\n",
    "Generators also have physical constraints. You cannot ask them to change the active production value too fast, this would damage the generator, and breaking a nuclear plant is often a terrible idea. In grid2op it is implemented as an ambiguous action. Trying to go beyond this value will result in an ambiguous action.\n",
    "\n",
    "This value is called the \"ramp\" and it's available through the \"max_ramp_up\" attribute. On the next cell, you can see that the ramp is $5MW$ for the first generator and $10MW$ for the second one and the last one. For the other 2 it's irrelevant because they are not dispatchable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5., 10.,  0.,  0.,  0., 15.], dtype=float32)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env.gen_max_ramp_up"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any attempt to go beyond this value will raise an ambiguous error :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True,\n",
       " Grid2OpException AmbiguousAction InvalidRedispatching InvalidRedispatching('Some redispatching amount are above the maximum ramp up'))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "act = env.action_space({\"redispatch\": [(0, +10)]})\n",
    "act.is_ambiguous()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous action, we asked the generator 0 to increase its setpoint by $10MW$. However, its maximum ramp up is only $5MW$. Thus, this action is ambiguous.\n",
    "\n",
    "Of course, there are some perfectly valid redispatching actions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, None)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "act = env.action_space({\"redispatch\": [(1, +10)]})\n",
    "act.is_ambiguous()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The (desired) setpoint is not the actual setpoint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As said in the preamble of this section, the target dispatching, what we want to achieve (the target), is not equal to the implemented dispatching. So that we can see the operations that are actually being performed, both of these values are present in the observation, as shown in the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "actual dispatch at time step 0: [-5.        2.000002  0.        0.        0.        2.999998]\n"
     ]
    }
   ],
   "source": [
    "observed = []\n",
    "# perform a valid redispatching action\n",
    "env.set_id(0)  # make sure to use the same environment input data.\n",
    "obs_init = env.reset()  # reset the environment\n",
    "act = env.action_space()\n",
    "act = env.action_space({\"redispatch\": [(0, -5)]})\n",
    "obs, reward, done, info = env.step(act)\n",
    "print(\"actual dispatch at time step 0: {}\".format(obs.actual_dispatch))\n",
    "observed.append(obs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The target dispatch is exactly what we wanted, e.g. the generator 0 has decreased its production by $5MW$. To compensate for this increase, both generator 1 has increase its production of 2MW and generator 5 of 3 MW.\n",
    "\n",
    "Let's plot the generators' base productions in this environment data (*ie* without any intervention from the agent), and what is implemented with the current redispatching :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a matplot figure\n",
    "redisp_fig = plt.figure()\n",
    "ax = redisp_fig.add_axes([0,0,1,1])\n",
    "# X axis is the generators\n",
    "x_gens = np.arange(obs.n_gen)\n",
    "# Y axis is the production in MW\n",
    "y_scenario_p = obs.gen_p - obs.actual_dispatch\n",
    "y_redisp_p = obs.gen_p\n",
    "# Blue bars for scenario productions\n",
    "ax.bar(x_gens - 0.2, y_scenario_p, width = 0.4)\n",
    "# Red bars for production with redispatch\n",
    "ax.bar(x_gens + 0.2, y_redisp_p, width = 0.4)\n",
    "# Set some legend to describe what's above\n",
    "ax.set_ylabel('MW')\n",
    "ax.set_xlabel('Generator ID')\n",
    "_ = ax.legend(labels=['Generation in scenario', 'Generation after redispatched'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following cell, we won't be performing any redispatching action. We will simply do nothing. This example is here to illustrate that grid2op will continue to apply the previous redispatching configuration over time, until the original redispatching action is removed (i.e. until the opposite command is sent)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "actual dispatch at time step 1: [-5.        2.000002  0.        0.        0.        2.999998]\n",
      "actual dispatch at time step 2: [-5.        2.000002  0.        0.        0.        2.999998]\n",
      "actual dispatch at time step 2: [-5.        2.000002  0.        0.        0.        2.999998]\n"
     ]
    }
   ],
   "source": [
    "donothing = env.action_space()\n",
    "obs1, reward, done, info = env.step(donothing)\n",
    "print(\"actual dispatch at time step 1: {}\".format(obs1.actual_dispatch))\n",
    "observed.append(obs1)\n",
    "obs2, reward, done, info = env.step(donothing)\n",
    "print(\"actual dispatch at time step 2: {}\".format(obs2.actual_dispatch))\n",
    "observed.append(obs2)\n",
    "obs3, reward, done, info = env.step(donothing)\n",
    "print(\"actual dispatch at time step 2: {}\".format(obs2.actual_dispatch))\n",
    "observed.append(obs3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the original redispatching action was to increase the setpoint of generator 0 by $5MW$. If we want to remove this, we need to decrease its setpoint by $5MW$ :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "actual dispatch at time step 3: [-0.3999439   0.19997184  0.          0.          0.          0.19997205]\n"
     ]
    }
   ],
   "source": [
    "act = env.action_space({\"redispatch\": [(0, 5)]})\n",
    "obs3, reward, done, info = env.step(act)\n",
    "print(\"actual dispatch at time step 3: {}\".format(obs3.actual_dispatch))\n",
    "observed.append(obs3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we see in the cell above, there are still residuals on the dispatch. \n",
    "\n",
    "This is because of the physical limit of the ramp of the generator 0. \n",
    "\n",
    "We wanted it to return to its original setpoint value, but at the same time step, the \"environment\" (representing a market for example) also modified the setpoint of this generator by +0.3MW. \n",
    "\n",
    "Therefore, the total desired increase for the setpoint of generator 0 was $5+0.4 = 5.4 > max\\_ramp\\_down$. The action (that would increase the production of 5.4 MW) could not completely performed. Grid2op \"capped\" the redispatch occuring at this timestep to $5MW$ (max\\_ramp\\_down) leaving a remaining of -0.4MW (instead of the initial -5.)\n",
    "\n",
    "That is why we can see a small part of the dispatch left. If we wait for another timestep and do nothing, the generator will likely be in order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "actual dispatch at time step 4: [ 0.          0.03999412  0.          0.          0.         -0.03999412]\n",
      "actual dispatch at time step 5: [ 0.          0.03999412  0.          0.          0.         -0.03999412]\n"
     ]
    }
   ],
   "source": [
    "obs4, reward, done, info = env.step(donothing)\n",
    "print(\"actual dispatch at time step 4: {}\".format(obs4.actual_dispatch))\n",
    "observed.append(obs4)\n",
    "obs5, reward, done, info = env.step(donothing)\n",
    "print(\"actual dispatch at time step 5: {}\".format(obs5.actual_dispatch))\n",
    "observed.append(obs5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now everything is set up as it should be. The system is back to its original state. Let's see what happens if we ask to decrease again the value of this generator 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "actual dispatch at time step 6: [-4.4000516  1.740022   0.         0.         0.         2.6600296]\n",
      "actual dispatch at time step 7: [-5.         1.9800016  0.         0.         0.         3.0199986]\n",
      "actual dispatch at time step 8: [-5.         1.9800016  0.         0.         0.         3.0199986]\n"
     ]
    }
   ],
   "source": [
    "act = env.action_space({\"redispatch\": [(0, -5.)]})\n",
    "obs6, reward, done, info = env.step(act)\n",
    "print(\"actual dispatch at time step 6: {}\".format(obs6.actual_dispatch))\n",
    "observed.append(obs6)\n",
    "obs7, reward, done, info = env.step(donothing)\n",
    "print(\"actual dispatch at time step 7: {}\".format(obs7.actual_dispatch))\n",
    "observed.append(obs7)\n",
    "obs8, reward, done, info = env.step(donothing)\n",
    "print(\"actual dispatch at time step 8: {}\".format(obs8.actual_dispatch))\n",
    "observed.append(obs8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This time we see that the full (valid) redispatching action is not applied completely. \n",
    "\n",
    "This is due to the same phenomenon that occurred previously. The environment (*eg* a market or a central authority) decreased the value of this generator and at the same time, we (=an agent operating the grid in real time) also asked to decrease it by its \"max ramp up\" value. \n",
    "\n",
    "Consequently, our action was \"capped\" and only  4.4MW (out of 5MW) were indeed removed to the generator's production. \n",
    "\n",
    "At the next time step (step 7), the action is fully implemented.\n",
    "\n",
    "To conclude on redispatching, we saw that there is a difference between the value we ask for, and the value that is implemented by the environment. This is mainly because:\n",
    "\n",
    "- the implemented vector should sum to 0.\n",
    "- if a redispatching is close to the maximum value it can take (due to ramping limitation or hard limitations) and if at the same time the environment itself \"wants\" to increase this value, physical limitations have to be respected.\n",
    "\n",
    "Redispatching actions also last in time. One action must be explicitely canceled to be reset to 0. This cancellation can take a few time steps to be fully effective as of the limitations mentionned above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To summarize, we can look at the productions over time for generators 0 & 5:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x900 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a matplot figure\n",
    "redisp_fig = plt.figure(figsize=(16, 9))\n",
    "# X axis is the timesteps\n",
    "x_gens = np.arange(len(observed), dtype=np.int32)\n",
    "# Y axis is the production in MW\n",
    "y_scenario_p_0 = [o.gen_p[0] - o.actual_dispatch[0] for o in observed] \n",
    "y_redisp_p_0 = [o.gen_p[0] for o in observed]\n",
    "y_scenario_p_4 = [o.gen_p[5] - o.actual_dispatch[5] for o in observed] \n",
    "y_redisp_p_4 = [o.gen_p[5] for o in observed]\n",
    "# Blue lines for gen 0\n",
    "plt.plot(x_gens, y_scenario_p_0, 'b', x_gens, y_redisp_p_0, 'b--')\n",
    "# Red lines for gen 4\n",
    "plt.plot(x_gens, y_scenario_p_4, 'r', x_gens, y_redisp_p_4, 'r--')\n",
    "# Set some legend to describe what's above\n",
    "plt.ylabel('MW')\n",
    "plt.xlabel('Timesteps')\n",
    "_ = plt.legend(labels=['Scenario gen 0', 'Redispatched gen 0', 'Scenario gen 5', 'Redispatched gen 5'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example of use: economic dispatch problem\n",
    "\n",
    "**NB** This is an illustration of an economic dispatch problem that can use grid2op. The problems modeled in the L2RPN competitions are NOT economic dispatch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The cumulative reward with this agent is 7040\n"
     ]
    }
   ],
   "source": [
    "agent = DoNothingAgent(env.action_space)\n",
    "done = False\n",
    "reward = env.reward_range[0]\n",
    "\n",
    "env.set_id(0)  # make sure to evaluate the models on the same experiments\n",
    "obs = env.reset()\n",
    "cum_reward = 0\n",
    "nrow = env.chronics_handler.max_timestep() if max_iter <= 0 else max_iter\n",
    "gen_p = np.zeros((nrow, env.n_gen))\n",
    "gen_p_setpoint = np.zeros((nrow, env.n_gen))\n",
    "load_p = np.zeros((nrow, env.n_load))\n",
    "rho = np.zeros((nrow, env.n_line))\n",
    "i = 0\n",
    "with tqdm(total=max_iter, desc=\"step\", disable=not display_tqdm) as pbar:\n",
    "    while not done:\n",
    "        act = agent.act(obs, reward, done)\n",
    "        obs, reward, done, info = env.step(act)\n",
    "        data_generator = env.chronics_handler.real_data.data\n",
    "        gen_p_setpoint[i,:] = data_generator.prod_p[data_generator.current_index, :]\n",
    "        gen_p[i,:] = obs.gen_p\n",
    "        load_p[i,:] = obs.load_p\n",
    "        rho[i,:] = obs.rho\n",
    "        cum_reward += reward\n",
    "        i += 1\n",
    "        pbar.update(1)\n",
    "        if i >= max_iter:\n",
    "            break\n",
    "print(\"The cumulative reward with this agent is {:.0f}\".format(cum_reward))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's try to redispatch as much production as possible to the cheapest generator, and leave the rest unchanged."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The cumulative reward with this agent is 5369\n"
     ]
    }
   ],
   "source": [
    "class GreedyEconomic(BaseAgent):\n",
    "    def __init__(self, action_space):\n",
    "        super().__init__(action_space)\n",
    "        self.do_nothing = action_space()\n",
    "        \n",
    "    def act(self, obs, reward, done):\n",
    "        act = self.do_nothing\n",
    "        if obs.gen_p[0] < obs.gen_pmax[0] - 1 and \\\n",
    "        obs.target_dispatch[0] < (obs.gen_pmax[0] - obs.gen_max_ramp_up[0]) - 1 and\\\n",
    "        obs.gen_p[0] > 0.:\n",
    "            # if the cheapest generator is significantly bellow its maximum cost\n",
    "            if obs.target_dispatch[0] < obs.gen_pmax[0]:\n",
    "                #in theory i can still ask for more\n",
    "                act = env.action_space({\"redispatch\": [(0, obs.gen_max_ramp_up[0])]})\n",
    "        return act\n",
    "    \n",
    "agent = GreedyEconomic(env.action_space)\n",
    "done = False\n",
    "reward = env.reward_range[0]\n",
    "\n",
    "env.set_id(0) # reset the env to the same id\n",
    "obs = env.reset()\n",
    "cum_reward = 0\n",
    "nrow = env.chronics_handler.max_timestep() if max_iter <= 0 else max_iter\n",
    "gen_p = np.zeros((nrow, env.n_gen))\n",
    "gen_p_setpoint = np.zeros((nrow, env.n_gen))\n",
    "load_p = np.zeros((nrow, env.n_load))\n",
    "rho = np.zeros((nrow, env.n_line))\n",
    "i = 0\n",
    "with tqdm(total=max_iter, desc=\"step\", disable=not display_tqdm) as pbar:\n",
    "    while not done:\n",
    "        act = agent.act(obs, reward, done)\n",
    "        obs, reward, done, info = env.step(act)\n",
    "        data_generator = env.chronics_handler.real_data.data\n",
    "        gen_p_setpoint[i,:] = data_generator.prod_p[data_generator.current_index, :]\n",
    "        gen_p[i,:] = obs.gen_p\n",
    "        load_p[i,:] = obs.load_p\n",
    "        rho[i,:] = obs.rho\n",
    "        cum_reward += reward\n",
    "        i += 1\n",
    "        pbar.update(1)\n",
    "        if i >= max_iter:\n",
    "            break\n",
    "            \n",
    "print(\"The cumulative reward with this agent is {:.0f}\".format(cum_reward))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, that second agent performed worse than the `DoNothing` agent, demonstrating that having the cheapest generators produce the most energy is not always the best solution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# II Curtailment  <a class=\"anchor\" id=\"curtailment\"></a>\n",
    "\n",
    "Quite like redispatching, curtailment is a type of action that can act on generators. As opposed to redispatching it acts on generators coming from renewable energy sources.\n",
    "\n",
    "The idea behind the curtailment is to limit the production of some generators to a certain upper bound. In real world application, such actions can be performed in case of emergency: when a powerline evacuating a wind farm is on overflow, it can be necassary to reduce the production the this wind farm even though we could have produced more.\n",
    "\n",
    "**NB** As for everything related to grid2op, we adopt the TSO point of view and model real time. This implies that the offer / demand equilibrium has been already computed. If the agent can not act, then the offer matches the demand already. Curtailment here is to understand as a real time security measure.\n",
    "\n",
    "If you want a detailed description of the modeling of the curtailment you can visit the official documentation [here](https://grid2op.readthedocs.io/en/latest/modeled_elements.html#generators)\n",
    "\n",
    "First let's see how you can apply a curtailment action in mainly 4 different ways. For the sake of the example, imagine we limit the production of the generator 2 at 10% of its maximum generation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\thoma\\anaconda3\\envs\\MA\\Lib\\site-packages\\grid2op\\MakeEnv\\Make.py:438: UserWarning: You are using a development environment. This environment is not intended for training agents. It might not be up to date and its primary use if for tests (hence the \"test=True\" you passed as argument). Use at your own risk.\n",
      "  warnings.warn(_MAKE_DEV_ENV_WARN)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This action will:\n",
      "\t - NOT change anything to the injections\n",
      "\t - NOT perform any redispatching action\n",
      "\t - NOT modify any storage capacity\n",
      "\t - Perform the following curtailment:\n",
      "\t \t - Limit unit \"gen_5_2\" to 10.0% of its Pmax (setpoint: 0.100)\n",
      "\t - NOT force any line status\n",
      "\t - NOT switch any line status\n",
      "\t - NOT switch anything in the topology\n",
      "\t - NOT force any particular bus configuration\n"
     ]
    }
   ],
   "source": [
    "import grid2op\n",
    "from grid2op.Action import PlayableAction\n",
    "from grid2op.Parameters import Parameters\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "param = Parameters()\n",
    "param.NO_OVERFLOW_DISCONNECTION = True\n",
    "env1 = grid2op.make(\"educ_case14_storage\",\n",
    "                    test=True,\n",
    "                    action_class=PlayableAction,\n",
    "                    param=param,\n",
    "                    backend=bk_cls())\n",
    "\n",
    "gen_id = 2  # because we want to act on generator 2\n",
    "amount_ratio = 0.1  # that is the 7% of the limit\n",
    "\n",
    "# method 1\n",
    "curtail_act_1 = env1.action_space({\"curtail\": [(gen_id, amount_ratio)]})\n",
    "\n",
    "# method 2\n",
    "curtail_vect = np.zeros(env1.n_gen) - 1.\n",
    "curtail_vect[gen_id] = amount_ratio\n",
    "curtail_act_2 = env1.action_space({\"curtail\": curtail_vect})\n",
    "\n",
    "# method 3\n",
    "curtail_act_3 = env1.action_space()\n",
    "curtail_act_3.curtail = [(gen_id, amount_ratio)]\n",
    "\n",
    "\n",
    "# method 4\n",
    "curtail_act_4 = env1.action_space()\n",
    "curtail_act_4.curtail = curtail_vect\n",
    "\n",
    "# all these actions are equal\n",
    "print(curtail_act_4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One \"side effect\" of applying a curtailment action can be redispatching. Indeed, the balance between production and load should maintain. The data (before curtailment) meets this criteria. This means that whatever curtailment is performed should be absorbed somehow. \n",
    "\n",
    "We decided to have the dispatchable generators produce more to compensate the curtailment. This behaviour is showed in the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Amount of MW curtailed for generator 2: 9.90 MW\n",
      "Sum of redispatched generator: 9.90 MW\n"
     ]
    }
   ],
   "source": [
    "env1.set_id(0)\n",
    "obs_init = env1.reset()\n",
    "obs, *_ = env1.step(curtail_act_1)\n",
    "print(f\"Amount of MW curtailed for generator {gen_id}: {obs.curtailment_mw[gen_id]:.2f} MW\")\n",
    "print(f\"Sum of redispatched generator: {obs.actual_dispatch.sum():.2f} MW\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, curtailment action will perdure on time. This means that if you perform a curtailment action on a step, unless you modify it later on. \n",
    "\n",
    "In this example above, the generator with id 2 will be constrained to produce less than 15% of its maximum production until you change that.\n",
    "\n",
    "We explain it in the cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Curtailment setpoint for generator 2: 0.10 (7.00 MW)\n",
      "Curtailment setpoint for generator 2 (after do nothing action): 0.10 (7.00 MW)\n",
      "Curtailment setpoint for generator 2 (after a second do nothing action): 0.10 (7.00 MW)\n",
      "Curtailment setpoint for generator 2 (after a third do nothing action): 0.10 (7.00 MW)\n",
      "Curtailment setpoint for generator 2 (after setting the curtailment to 100% again): 1.00 (70.00 MW)\n",
      "Curtailment setpoint for generator 2 (after a third do nothing action): 1.00 (70.00 MW)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(f\"Curtailment setpoint for generator {gen_id}: {obs.curtailment_limit[gen_id]:.2f} \"\n",
    "      f\"({obs.curtailment_limit_mw[gen_id]:.2f} MW)\")\n",
    "\n",
    "# we perform a do nothing action\n",
    "obs0, *_ = env1.step(env1.action_space())\n",
    "print(f\"Curtailment setpoint for generator {gen_id} (after do nothing action): \"\n",
    "      f\"{obs0.curtailment_limit[gen_id]:.2f} \"\n",
    "      f\"({obs0.curtailment_limit_mw[gen_id]:.2f} MW)\")\n",
    "# we perform a do nothing action\n",
    "obs1, *_ = env1.step(env1.action_space())\n",
    "print(f\"Curtailment setpoint for generator {gen_id} (after a second do nothing action): \"\n",
    "      f\"{obs1.curtailment_limit[gen_id]:.2f} \"\n",
    "      f\"({obs1.curtailment_limit_mw[gen_id]:.2f} MW)\")\n",
    "# we perform a do nothing action\n",
    "obs2, *_ = env1.step(env1.action_space())\n",
    "print(f\"Curtailment setpoint for generator {gen_id} (after a third do nothing action): \"\n",
    "      f\"{obs2.curtailment_limit[gen_id]:.2f} \"\n",
    "      f\"({obs2.curtailment_limit_mw[gen_id]:.2f} MW)\")\n",
    "\n",
    "# we perform an action to remove the curtailment\n",
    "curtail_act_reset = env1.action_space({\"curtail\": [(gen_id, 1.0)]})\n",
    "obs3, *_ = env1.step(curtail_act_reset)\n",
    "print(f\"Curtailment setpoint for generator {gen_id} (after setting the curtailment to 100% again): \"\n",
    "      f\"{obs3.curtailment_limit[gen_id]:.2f} \"\n",
    "      f\"({obs3.curtailment_limit_mw[gen_id]:.2f} MW)\")\n",
    "\n",
    "# we perform another do nothing action\n",
    "obs4, *_ = env1.step(env1.action_space())\n",
    "print(f\"Curtailment setpoint for generator {gen_id} (after a third do nothing action): \"\n",
    "      f\"{obs4.curtailment_limit[gen_id]:.2f} \"\n",
    "      f\"({obs4.curtailment_limit_mw[gen_id]:.2f} MW)\")\n",
    "\n",
    "# and we can even plot it to see what's going on\n",
    "plt.figure(figsize=(15,10))\n",
    "plt.vlines(list([1, 5]), ymin=0., ymax=18, label=\"an action occured just before this step\", alpha=0.5)\n",
    "plt.plot([obs_init.gen_p[gen_id],\n",
    "          obs.gen_p[gen_id],\n",
    "          obs0.gen_p[gen_id],\n",
    "          obs1.gen_p[gen_id],\n",
    "          obs2.gen_p[gen_id],\n",
    "          obs3.gen_p[gen_id],\n",
    "          obs4.gen_p[gen_id],],\n",
    "         label=\"generation limit\", linestyle=\"-.\")\n",
    "plt.legend()\n",
    "plt.ylim([0., 18])\n",
    "plt.xlabel(\"step\")\n",
    "plt.title(f\"Evolution of the generation of generator {gen_id}\")\n",
    "_ = plt.ylabel(f\"Generation for generator {gen_id} (MW)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An example of the behaviour of this feature is provided bellow. In this example, we perform 4 curtailment actions at 4 different steps (showed by vertical bars in the final graphs) and show, for generator 2:\n",
    "- generation limit (this is the maximum allowed by the curtailment)\n",
    "- effective curtailment (this is the total amount of MW that has been curtailed)\n",
    "- reference generation (generation there would have been without curtailment)\n",
    "- actual generation (the generation observed for this generator, the power that is really injected on the grid)\n",
    "- sum of dispatch (total power absorbed by the dispatchable generator to compensate for the curtailment)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\thoma\\anaconda3\\envs\\MA\\Lib\\site-packages\\grid2op\\MakeEnv\\Make.py:438: UserWarning: You are using a development environment. This environment is not intended for training agents. It might not be up to date and its primary use if for tests (hence the \"test=True\" you passed as argument). Use at your own risk.\n",
      "  warnings.warn(_MAKE_DEV_ENV_WARN)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "env1 = grid2op.make(\"educ_case14_storage\", \n",
    "                    test=True,\n",
    "                    action_class=PlayableAction,\n",
    "                    param=param,\n",
    "                    backend=bk_cls())\n",
    "\n",
    "gen_id = 2\n",
    "ratios_max = [0.25, 0.24, 0.23, 0.25]  # don't change it\n",
    "n_steps = 40 # don't change it\n",
    "acts = []\n",
    "prod1 = []\n",
    "prod2 = []\n",
    "curtailment_limit = []\n",
    "curtail_gen1 = []\n",
    "sum_disp = []\n",
    "li_id_xplt = set()\n",
    "for ratio in ratios_max:\n",
    "    acts.append(env1.action_space({\"curtail\": [(gen_id, ratio)]}))\n",
    "    \n",
    "for step in range(n_steps):\n",
    "    if step % 10 == 0:\n",
    "        # execute a curtailment action\n",
    "        li_id = step // 10\n",
    "        li_id_xplt.add(step)\n",
    "        ratio_max = ratios_max[li_id]\n",
    "        obs1_3, reward1_3, done1_3, info1_3 = env1.step(acts[li_id])\n",
    "    else:\n",
    "        obs1_3, reward1_3, done1_3, info1_3 = env1.step(env1.action_space())\n",
    "        \n",
    "    if done1_3:\n",
    "        raise RuntimeError(\"Environment did game over, this is not normal\")\n",
    "    if info1_3[\"exception\"]:\n",
    "        raise RuntimeError(\"Exception for info1_3\")\n",
    "\n",
    "    prod1.append(obs1_3.gen_p[gen_id])\n",
    "    prod2.append(obs1_3.gen_p_before_curtail[gen_id])\n",
    "    curtail_gen1.append(obs1_3.curtailment_mw[gen_id])\n",
    "    curtailment_limit.append(obs1_3.curtailment_limit_mw[gen_id])\n",
    "    sum_disp.append(obs1_3.actual_dispatch.sum())\n",
    "    \n",
    "plt.figure(figsize=(15,10))\n",
    "plt.vlines(list(li_id_xplt), ymin=0., ymax=18., label=\"an action occured at this step\", alpha=0.5)\n",
    "plt.plot(curtailment_limit, label=\"generation limit\", linestyle=\"-.\")\n",
    "plt.plot(curtail_gen1, label=\"effective curtailment\")\n",
    "plt.plot(prod2, label=\"reference generation (without curt.)\", linestyle=\"--\")\n",
    "plt.plot(prod1, label=\"actual generation (with curt.)\", linestyle=\":\", linewidth=3)\n",
    "plt.plot(sum_disp, label=\"sum of dispatch\", linestyle=\":\", linewidth=3)\n",
    "plt.legend()\n",
    "plt.xlabel(\"step\")\n",
    "plt.title(f\"Evolution of the generation of generator {gen_id}\")\n",
    "_ = plt.ylabel(f\"Generation for generator {gen_id} (MW)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Important limit to the curtailment\n",
    "\n",
    "As always in grid2op, we suppose that the \"time series data\" (the one the agent has no access to, present in the environment and representing the \"optimal\" generator setpoint from the \"market\" - or a central authority) are balanced. This means that, without any intervention from any agent, the total generation exactly match the total demand plus the losses.\n",
    "\n",
    "When an agent perform a redispatching or a curtailment, it will affect this equilibrium. This is why grid2op \"compensate\" the action of the agent by ensuring that the \"global action\" (*ie* the sum of all modifications made by the agent) sums up to 0.\n",
    "\n",
    "To do this, the environment will modify the **controllable** generators. One key consequence is that you can take curtailment action that would \"overload\" the grid and lead directly to game over.\n",
    "\n",
    "For example, say an agent curtails 50MW of renewable energy, but the available \"ramp up\" of controlable generators is only 40MW (*ie* you can increase the controlable generators of at most 40MW between two consecutive steps). In this case the environment cannot simply create the missing 10 MW and it directly lead to a game over, as showed below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is the environment done: True\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'disc_lines': array([-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n",
       "        -1, -1, -1]),\n",
       " 'is_illegal': False,\n",
       " 'is_ambiguous': False,\n",
       " 'is_dispatching_illegal': True,\n",
       " 'is_illegal_reco': False,\n",
       " 'reason_alarm_illegal': None,\n",
       " 'reason_alert_illegal': None,\n",
       " 'opponent_attack_line': None,\n",
       " 'opponent_attack_sub': None,\n",
       " 'opponent_attack_duration': 0,\n",
       " 'exception': [Grid2OpException AmbiguousAction InvalidRedispatching InvalidRedispatching('\\nThis is an attempt to explain why the dispatch did not succeed and caused a game over.\\nTo compensate the increase of loads and / or decrease of renewable energy (due to naturl causes but also through curtailment) and / or variation in the storage units, the generators should increase their total production of 38.40MW (in total).\\nBut, if you take into account the generator constraints (pmax and max_ramp_up) you can have at most 30.00MW.\\nIndeed at time t, generators are in state:\\n\\t[73.2 71.7 70.9]\\ntheir ramp max is:\\n\\t[ 5. 10. 15.]\\n and pmax is:\\n\\t[140. 120. 100.]\\nWrapping up, each generator can increase at maximum of:\\n\\t[ 5. 10. 15.]\\nNB: if you did not do any dispatch during this episode, it would have been possible to meet these constraints. This situation is caused by not having enough degree of freedom to \"compensate\" the variation of the load due to (most likely) an \"over usage\" of redispatching feature (some generators stuck at pmax as a consequence of your redispatching. They can\\'t increase their productions to meet the increase in demand or decrease of renewables)'),\n",
       "  Grid2OpException AmbiguousAction InvalidRedispatching InvalidRedispatching('Game over due to infeasible redispatching state. The routine used to compute the \"next state\" has diverged. This means that there is no way to compute a physically valid generator state (one that meets all pmin / pmax - ramp min / ramp max with the information provided. As one of the physical constraints would be violated, this means that a generator would be damaged in real life. This is a game over.')],\n",
       " 'time_series_id': 'c:\\\\Users\\\\thoma\\\\anaconda3\\\\envs\\\\MA\\\\Lib\\\\site-packages\\\\grid2op\\\\data\\\\l2rpn_case14_sandbox\\\\chronics\\\\0000',\n",
       " 'rewards': {}}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env.set_id(0)\n",
    "obs = env.reset()\n",
    "act = env.action_space({\"curtail\": [(el, 0.) for el in range(env.n_gen) if env.gen_renewable[el]]})\n",
    "obs, reward, done, info = env.step(act)\n",
    "print(f\"Is the environment done: {done}\")\n",
    "info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same phenomenon occurs when you \"undo\" the curtailment, for example when you start from a situation where curtailment is really strong (you limited the curtailment to a really low level) and you suddently remove all curtailment, you might end up with issues due to ramps down, as shown bellow:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is the environment done: True\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'disc_lines': array([-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n",
       "        -1, -1, -1]),\n",
       " 'is_illegal': False,\n",
       " 'is_ambiguous': False,\n",
       " 'is_dispatching_illegal': True,\n",
       " 'is_illegal_reco': False,\n",
       " 'reason_alarm_illegal': None,\n",
       " 'reason_alert_illegal': None,\n",
       " 'opponent_attack_line': None,\n",
       " 'opponent_attack_sub': None,\n",
       " 'opponent_attack_duration': 0,\n",
       " 'exception': [Grid2OpException AmbiguousAction InvalidRedispatching InvalidRedispatching('\\nThis is an attempt to explain why the dispatch did not succeed and caused a game over.\\nTo compensate the decrease of loads and / or increase of renewable energy (due to naturl causes but also through curtailment) and / or variation in the storage units, the generators should decrease their total production of -35.00MW (in total).\\nBut, if you take into account the generator constraints (pmin and max_ramp_down) you can have at most -30.00MW.\\nIndeed at time t, generators are in state:\\n\\t[79.79 84.59 88.32]\\ntheir ramp max is:\\n\\t[ 5. 10. 15.]\\n and pmax is:\\n\\t[0. 0. 0.]\\nWrapping up, each generator can decrease at minimum of:\\n\\t[ 5.   10.   11.68]\\nNB: if you did not do any dispatch during this episode, it would have been possible to meet these constraints. This situation is caused by not having enough degree of freedom to \"compensate\" the variation of the load due to (most likely) an \"over usage\" of redispatching feature (some generators stuck at pmin as a consequence of your redispatching. They can\\'t increase their productions to meet the decrease in demand or increase of renewables)'),\n",
       "  Grid2OpException AmbiguousAction InvalidRedispatching InvalidRedispatching('Game over due to infeasible redispatching state. The routine used to compute the \"next state\" has diverged. This means that there is no way to compute a physically valid generator state (one that meets all pmin / pmax - ramp min / ramp max with the information provided. As one of the physical constraints would be violated, this means that a generator would be damaged in real life. This is a game over.')],\n",
       " 'time_series_id': 'c:\\\\Users\\\\thoma\\\\anaconda3\\\\envs\\\\MA\\\\Lib\\\\site-packages\\\\grid2op\\\\data\\\\l2rpn_case14_sandbox\\\\chronics\\\\0000',\n",
       " 'rewards': {}}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "env.set_id(0)\n",
    "obs = env.reset()\n",
    "# gradually decrease the total generation from renewable sources\n",
    "act = env.action_space({\"curtail\": [(el, 0.13) for el in range(env.n_gen) if env.gen_renewable[el]]})\n",
    "obs, reward, done, info = env.step(act)\n",
    "act = env.action_space({\"curtail\": [(el, 0.0) for el in range(env.n_gen) if env.gen_renewable[el]]})\n",
    "obs, reward, done, info = env.step(act)\n",
    "\n",
    "# increase it \"at once\"\n",
    "act = env.action_space({\"curtail\": [(el, 1.) for el in range(env.n_gen) if env.gen_renewable[el]]})\n",
    "obs, reward, done, info = env.step(act)\n",
    "print(f\"Is the environment done: {done}\")\n",
    "info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To alleviate this issue, you have two possibilities:\n",
    "- make the environment more tolerant to these \"bad\" actions. In this case, the environment will \"limit\" the amount of MW curtailed in your action (using a heuristic not detailed here) and preventing you to \"break\" the grid. This can be used only if you create yourself your environment (so this is not suitable at the evaluation time of the l2rpn competitions) and is particularly useful if you envisage \"curiculum learning\" (*ie* start learning with an easier environment and when your agent achieves good performances change the environment parameters closer to the evaluation parameters)\n",
    "- do not change the environment at all, but call the `act.limit_curtail_storage(...)` to... limit the curtailment (and the storage) part of your action and keep it \"manageable\" (hopefully) by the environment.\n",
    "\n",
    "We explain the two methods in the sub sub sections bellow.\n",
    "\n",
    "#### modify the parameters of the environment\n",
    "\n",
    "As you see here, setting the `LIMIT_INFEASIBLE_CURTAILMENT_STORAGE_ACTION` to ``True`` solves the issue. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is the environment done: False\n"
     ]
    }
   ],
   "source": [
    "param = env.parameters\n",
    "param.LIMIT_INFEASIBLE_CURTAILMENT_STORAGE_ACTION = True\n",
    "env.change_parameters(param)\n",
    "\n",
    "env.set_id(0)\n",
    "obs = env.reset()\n",
    "act = env.action_space({\"curtail\": [(el, 0.) for el in range(env.n_gen) if env.gen_renewable[el]]})\n",
    "obs, reward, done, info = env.step(act)\n",
    "print(f\"Is the environment done: {done}\")\n",
    "\n",
    "# set back the parameters to orignal value\n",
    "param = env.parameters\n",
    "param.LIMIT_INFEASIBLE_CURTAILMENT_STORAGE_ACTION = False\n",
    "env.change_parameters(param)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With this method you should be guaranteed to have a valid action that will not lead to a game over (because of curtailment, you can still \"game over\" because of every other reasons)\n",
    "\n",
    "#### modify the action\n",
    "\n",
    "We developed an method of an action that can limit its impact and keep it \"small enough\" so that it does not overflow.\n",
    "\n",
    "To use it you need:\n",
    "- an observation: it will be used to compute the amount of MW that can be absorbed / produced by the controlable generators\n",
    "- a \"margin\": when the limitation is done by the environment, the environment knows exactly the amount of MW the generators can increase or decrease (this is not exactly the ramps because even if the agent does nothing, the generator will increase / decrease their production). If you put the \"margin\" to 0. (which we do not recommend), the \"limit the action\" will act as if the generators will not increase / decrease their production. Basically you can think of it of a \"safety margin\": the higher it is the more your action will be impacted but the less likely"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is the environment done (without the limit_curtail_storage(...) ): True\n",
      "Is the environment done (with limit_curtail_storage(...) ): False\n",
      "Is the environment done (with limit_curtail_storage(...) and not enough margin ): True\n"
     ]
    }
   ],
   "source": [
    "# if you don't limit the action, it breaks\n",
    "env.set_id(0)\n",
    "obs = env.reset()\n",
    "act = env.action_space({\"curtail\": [(el, 0.) for el in range(env.n_gen) if env.gen_renewable[el]]})\n",
    "obs, reward, done, info = env.step(act)\n",
    "print(f\"Is the environment done (without the limit_curtail_storage(...) ): {done}\")  # of course it is...\n",
    "\n",
    "# if you limit the action, it's ok\n",
    "env.set_id(0)\n",
    "obs = env.reset()\n",
    "act = env.action_space({\"curtail\": [(el, 0.) for el in range(env.n_gen) if env.gen_renewable[el]]})\n",
    "act.limit_curtail_storage(obs, margin=10.)\n",
    "obs, reward, done, info = env.step(act)\n",
    "print(f\"Is the environment done (with limit_curtail_storage(...) ): {done}\")  # of course it is...\n",
    "\n",
    "# if limit the action, but does not take enough \"margin\", it breaks again\n",
    "env.set_id(0)\n",
    "obs = env.reset()\n",
    "act = env.action_space({\"curtail\": [(el, 0.) for el in range(env.n_gen) if env.gen_renewable[el]]})\n",
    "act.limit_curtail_storage(obs, margin=0.)\n",
    "obs, reward, done, info = env.step(act)\n",
    "print(f\"Is the environment done (with limit_curtail_storage(...) and not enough margin ): {done}\")  # of course it is..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nothing prevents you to use the `act.limit_curtail_storage(obs, margin=...)` in your code, when training your agent (for example as a \"heuristic\" like in the `GymEnvWithRecoWithDN` showed in notebook [04_TrainingAnAgent](./04_TrainingAnAgent.ipynb)). In this case you only need to properly set the `margin` parameter as shown above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}