Simulator

This page is organized as follow:

Objectives

The “Simulator” class is used to interact, with a grid2op “api-like” (the concept of action and observation) with a powergrid simulator that is independant of the one used by the environment.

This can for example be used for “model based reinforcement learning” or to assess the “validity” of an action in some “more extreme” conditions.

It behaves similarly to env.step(…) or obs.simulate(…) with a few key differences:

  • you can “chain” the call to simulator: simulator.predict(…).predict(…).predict(…)

  • it does not take into account the “time”: no cooldown on lines nor substation, storage “state of charge” (energy) does not decrease when you use them

  • no automatic line disconnection: lines are not disconnected when they are above their limit

  • no opponent will act on the grid

Usage

You can use it to assess if the grid state is “resilient enough” if the loads and generators increase of 5% :

import grid2op
env_name = ...  # any environment name available (eg. "l2rpn_case14_sandbox")
env = grid2op.make(env_name)

obs = env.reset()

#### later in the code, for example in an Agent:

simulator = obs.get_simulator()

load_p_stressed = obs.load_p * 1.05
gen_p_stressed = obs.gen_p * 1.05
do_nothing = env.action_space()
simulator_stressed = simulator.predict(act=do_nothing, new_gen_p=gen_p_stressed, new_load_p=load_p_stressed)
if not simulator_stressed.converged:
    # the solver fails to find a solution for this action
    # you are likely to run into trouble if you use that...
    ...  # do something
obs_stressed = simulator_stressed.current_obs

You can also “chain” the call to simulators, usefull for “model based” strategies

import grid2op
env_name = ...  # any environment name available (eg. "l2rpn_case14_sandbox")
env = grid2op.make(env_name)

obs = env.reset()

#### later in the code, for example in an Agent:

simulator = obs.get_simulator()

load_p_stressed = obs.load_p * 1.05
gen_p_stressed = obs.gen_p * 1.05
do_nothing = env.action_space()
simulator_stressed = simulator.predict(act=do_nothing, new_gen_p=gen_p_stressed, new_load_p=load_p_stressed)
if not simulator_stressed.converged:
    # the solver fails to find a solution for this action
    # you are likely to run into trouble if you use that...
    ...  # do something

act1 = ...
simulator_afteract1 = simulator_stressed.predict(act=act1)
act2 = ...
simulator_afteract2 = simulator_stressed.predict(act=act2)
# etc.

Another use (though you might need to use dedicated tools for such purpose such as https://lightsim2grid.readthedocs.io/en/latest/security_analysis.html ) is to check whether your grid is “N-1 secure” which means that if a powerline were to be disconnected (for example by the opponent) then the state it is in would not be too dangerous:

import numpy as np
import grid2op
env_name = ...  # any environment name available (eg. "l2rpn_case14_sandbox")
env = grid2op.make(env_name)

obs = env.reset()

#### later in the code, for example in an Agent:
simulator = obs.get_simulator()
act1 = ...  # the action your agent has selected
simulator_afteract1 = simulator.predict(act=act1)

for line_id in range(obs.n_line):
    act_disco_line = env.action_space()
    act_disco_line.set_line_status = [(line_id, -1)]
    sim_after_disco_line = simulator_afteract1.predict(act_disco_line)
    if sim_after_disco_line.converged:
        obs_after_disco = sim_after_disco_line.current_obs
        # and for example check the current on all line is bellow the limit
        if np.any(obs_after_disco.rho > 1.):
            # your action does not make the grid "N-1" safe,
            # because if you disconnect line `line_id` you got some overflow
            ...  # do something
    else:
        # the simulator has not found any solution, it is likely that this will lead
        # to a game over in "real time"
        # your grid is not "N-1" safe because disconnection of line `line_id` lead
        # to a non feasible grid state
            ...  # do something

Warning

This module is still under development, if you need any functionality, let us know with a github “feature request” (https://github.com/rte-france/Grid2Op/issues/new?assignees=&labels=enhancement&template=feature_request.md&title=)

Detailed Documentation by class

Classes:

Simulator(backend[, env, tol_redisp])

This class represents a "simulator".

class grid2op.simulator.Simulator(backend: Optional[grid2op.Backend.Backend.Backend], env: Optional[grid2op.Environment.BaseEnv.BaseEnv] = None, tol_redisp=1e-06)[source]

Bases: object

This class represents a “simulator”. It allows to check the impact on this or that on th powergrid, quite like what human operators have at their disposal in control rooms.

It behaves similarly to env.step(…) or obs.simulate(…) with a few key differences:

  • you can “chain” the call to simulator: simulator.predict(…).predict(…).predict(…)

  • it does not take into account the “time”: no cooldown on lines nor substation, storage “state of charge” (energy) does not decrease when you use them

  • no automatic line disconnection: lines are not disconnected when they are above their limit

  • no opponent will act on the grid

Please see the documentation for usage examples.

Methods:

__init__(backend[, env, tol_redisp])

change_backend(backend)

You can use this function in case you want to change the "solver" use to perform the computation.

change_backend_type(backend_type, grid_path, ...)

It allows to change the type of the backend used

close()

close the underlying backend

copy()

Allows to perform a (deep) copy of the simulator.

predict(act[, new_gen_p, new_gen_v, ...])

Predict the state of the grid after a given action has been taken.

set_state([obs, do_powerflow, new_gen_p, ...])

Set the state of the simulator to a given state described by an observation (and optionally some new loads and generation)

Attributes:

__weakref__

list of weak references to the object (if defined)

converged

returns: Whether or not the powerflow has converged :rtype: bool

__init__(backend: Optional[grid2op.Backend.Backend.Backend], env: Optional[grid2op.Environment.BaseEnv.BaseEnv] = None, tol_redisp=1e-06)[source]
__weakref__

list of weak references to the object (if defined)

change_backend(backend: grid2op.Backend.Backend.Backend)[source]

You can use this function in case you want to change the “solver” use to perform the computation.

For example, you could use a machine learning based model to do the computation (to accelerate them), provided that you have at your disposal such an algorithm.

Warning

The backend you pass as argument should be initialized with the same grid as the one currently in use.

Notes

Once changed, all the “simulator” that “derived” from this simulator will use the same backend types.

Parameters

backend (Backend) – Another grid2op backend you can use to perform the computation.

Raises

SimulatorError – When you do not pass a correct backend.

change_backend_type(backend_type: type, grid_path: os.PathLike, **kwargs)[source]

It allows to change the type of the backend used

Parameters
  • backend_type (type) – The new backend type

  • grid_path (os.PathLike) – The path from where to load the powergrid

  • kwargs – Extra arguments used to build the backend.

Notes

Once changed, all the “simulator” that “derived” from this simulator will use the same backend types.

Raises

SimulatorError – if something went wrong (eg you do not pass a type, your type does not inherit from Backend, the file located at grid_path does not exists etc.)

close()[source]

close the underlying backend

property converged: bool

returns: Whether or not the powerflow has converged :rtype: bool

copy() grid2op.simulator.simulator.Simulator[source]

Allows to perform a (deep) copy of the simulator.

Returns

A (deep) copy of the simulator you want to copy.

Return type

Simulator

Raises

SimulatorError – In case the simulator is not initialized.

predict(act: grid2op.Action.BaseAction.BaseAction, new_gen_p: Optional[numpy.ndarray] = None, new_gen_v: Optional[numpy.ndarray] = None, new_load_p: Optional[numpy.ndarray] = None, new_load_q: Optional[numpy.ndarray] = None, do_copy: bool = True) grid2op.simulator.simulator.Simulator[source]

Predict the state of the grid after a given action has been taken.

Parameters
  • act (BaseAction) – The action you want to take

  • new_gen_p (np.ndarray, optional) – the new production active setpoint, by default None

  • new_gen_v (np.ndarray, optional) – the new production voltage setpoint, by default None

  • new_load_p (np.ndarray, optional) – the new consumption active values, by default None

  • new_load_q (np.ndarray, optional) – the new consumption reactive values, by default None

  • do_copy (bool, optional) – Whether to make a copy or not, by default True

Returns

The new simulator representing the grid state after the simulation of the action.

Return type

Simulator

set_state(obs: Optional[grid2op.Observation.baseObservation.BaseObservation] = None, do_powerflow: bool = True, new_gen_p: Optional[numpy.ndarray] = None, new_gen_v: Optional[numpy.ndarray] = None, new_load_p: Optional[numpy.ndarray] = None, new_load_q: Optional[numpy.ndarray] = None)[source]

Set the state of the simulator to a given state described by an observation (and optionally some new loads and generation)

Parameters
  • obs (Optional[BaseObservation], optional) – The observation to get the state from, by default None

  • do_powerflow (bool, optional) – Whether to use the underlying backend to get a consistent state after this modification or not, by default True

  • new_gen_p (np.ndarray, optional) – new generator active setpoint, by default None

  • new_gen_v (np.ndarray, optional) – new generator voltage setpoint, by default None

  • new_load_p (np.ndarray, optional) – new load active consumption, by default None

  • new_load_q (np.ndarray, optional) – new load reactive consumption, by default None

Raises

SimulatorError – In case the current simulator is not initialized.

If you still can’t find what you’re looking for, try in one of the following pages:

Still trouble finding the information ? Do not hesitate to send a github issue about the documentation at this link: Documentation issue template