Some experiments on a 5 substations test case

To demonstrate the use of the grid2op framework, we propose here to show how to make some quick studies on a purely fictious test case, a 5 bus system.

This system should not be used for deep research purpose. It is provided here as an example and a tool to get used to how some analyses can be performed using grid2op.

First, we can create a environment:

In [1]:
import grid2op
from tqdm.notebook import tqdm  # for easy progress bar
from grid2op.PlotGrid import PlotMatplot
env = grid2op.make("rte_case5_example", test=True)
/home/benjamin/Documents/grid2op_dev/getting_started/grid2op/MakeEnv/ UserWarning:

You are using a development environment. This environment is not intended for training agents.

Inspect the powergrid

In grid2op, to make more concrete the powergrid, we also added some visual capabilities to represent, for example, the names of the objects on the grid, or the thermal limit, or any other data you want. All of that is for now only available in the matplotlib "plot helper" and can be accessed as followed.

Plotting the layout of the graph

This utility function allows you to visualize where are the object located on the map. Each object has its own color, and is represented with its name and its id (id starts at 0, following python convention).

In [2]:
plot_helper = PlotMatplot(env.observation_space)
In [3]:
_ = plot_helper.plot_layout()

Visualizing data on the grid

It is, with the same method, also possible to visualize any data on the powergrid, for example, we can inspect the thermal limit (line property) as follow:

In [4]:
_ = plot_helper.plot_info(line_values=env._thermal_limit_a)

Similarly, it is possible to display some data about the generators, for example the maximum value of power they can produce.

In [5]:
_ = plot_helper.plot_info(gen_values=env.gen_pmax)

Of course we can also project on the powergrid some information about the loads, for example their ID

In [6]:
_ = plot_helper.plot_info(load_values=[el for el in range(env.n_load)])

Create an agent

Now we can see how well the "do nothing" agent (the most basic imaginable) can performe, using some "gym like" methods

In [7]:
from grid2op.Agent import DoNothingAgent
my_agent = DoNothingAgent(env.action_space)

Now do the standard gym loop, and we save all the observations:

In [8]:
all_obs = []
obs = env.reset()
reward = env.reward_range[0]
done = False
nb_step = 0
with tqdm(total=env.chronics_handler.max_timestep()) as pbar:
    while True:
        action = my_agent.act(obs, reward, done)
        obs, reward, done, _ = env.step(action)
        if done:
        nb_step += 1

We can check if the episode has been completed, or if there has been a game over:

In [9]:
print("Number of timesteps computed: {}".format(nb_step))
print("Total maximum number of timesteps possible: {}".format(env.chronics_handler.max_timestep()))
Number of timesteps computed: 94
Total maximum number of timesteps possible: 2016

As we see here, there is a game over: the agent successfully managed 94 timesteps, while the episode could have lasted 2016.

Let's try to investigate this, for example by plotting the last observation. First we need to create a utilities that will make the plot:

In [10]:
last_obs = all_obs[-1]
_ = plot_helper.plot_obs(last_obs)

As we can see, the last obsevation is pretty clear: 4 powerlines have been disconnected, thus isolating the load on the bottom right. This lead to a game over.

It's also possible, of course, to inspect the previous state, just before this one:

In [11]:
previous_obs = all_obs[-2]
_ = plot_helper.plot_obs(previous_obs)

And now we can know the cause for this problem: all the powerlines that could provide power on the bottom right load are overloaded in this situation, so the protection worked and disconnect them to prevent hurting the surroundings.

Highly non linear, non local effects

The previous case was particularly suited to get started with the problem adressed by the grid2op platform. On this second section we will show what is the principal way of acting on a grid and illustrate why it is rather difficult to do so.

For that we will use the "rte_case14_realistic" grid showed bellow

In [26]:
env_14 = grid2op.make("rte_case14_realistic", test=True)
plot_helper_14 = PlotMatplot(env_14.observation_space)
_ = plot_helper_14.plot_layout()
/home/benjamin/Documents/grid2op_dev/getting_started/grid2op/MakeEnv/ UserWarning:

You are using a development environment. This environment is not intended for training agents.

Now let's, like before, plot an observation

In [27]:
obs_before = env_14.reset()
_ = plot_helper_14.plot_obs(obs_before)

As stated in the previous notebooks, there are 2 main types of actions in grid2op: action that consists in changing the status of the powerlines. Note that connecting / disconnecting powerline has a global, really non linear impact on the powergrid as illustrated below, when we disconnect the powerline of id 17 going from substation 4 to substations 5.

The way we interact with the environment is described in detail in notebook 3_Action_GridManipulation, so we focus here only on the consequences of these actions.

In [28]:
act = env_14.action_space.disconnect_powerline(line_name='4_5_17')
obs_after, reward, done, info = env_14.step(act)
_ = plot_helper_14.plot_obs(obs_after)

We can have a "quick" look on the effect of this action.

First let's look at the bottom right part of the grid. We can see that flow there did not change too much:

origin extremity flow before flow after
0 1 46.01% 43.42%
0 4 36.85% 33.96%
1 4 77.39% 71.06%
1 2 28.35% 28.43%
1 3 40.10% 42.33%
2 3 15.65% 17.80%
4 3 36.42% 56.29%

Though some of these powerlines are really close (in terms of graph distance) they don't seemed to be impacted too much (especially powerlines going from 0 to 4 and the one going from 1 to 4).

On the other hand, if you look at the topmost part of the grid, you can spot really high differences, though these power are extremely far (in terms of graph distance **) from the powerline disconnected (3 or 4 substations apart for some).

origin extremity flow before flow after
3 8 22.72% 37.84%
8 9 7.35% 144.79% (opposite direction)
9 10 41.52% 42.61% (opposite direction)
8 13 45.53% 97.78%

To recap, to recap some powerline next to the disconnected have approximately the same flows (36.85% to 33.96% for example) while some others "really far away"* are dramatically impacted by this changes, seeing their flow completely blows up from $\approx 7\%$ to more than $\approx 140\%$.

* the maximum "graph distance"** between two powerlines on this graph is 4 (between line 1->2 and 12->13 for example)

** when we mention distance on graph it's more of a figure of speech rather a true mathematical definition. We can say intuitively that the "graph distance" between two powerlines is the smallest on powerline i need to "walk one" if i want to move from one to the other.

In [ ]:
In [16]:
array(['0_1_0', '0_4_1', '1_2_2', '1_3_3', '1_4_4', '2_3_5', '3_4_6',
       '5_10_7', '5_11_8', '5_12_9', '8_9_10', '8_13_11', '9_10_12',
       '11_12_13', '12_13_14', '3_6_15', '3_8_16', '4_5_17', '6_7_18',
       '6_8_19'], dtype='<U8')