def __init__(self, gridobj):
"""
See the definition of :func:`BaseAction.__init__` and of :class:`BaseAction` for more information. Nothing more is done
in this constructor.
"""
BaseAction.__init__(self, gridobj)
# the injection keys is not authorized, meaning it will send a warning is someone try to implement some
# modification injection.
self.authorized_keys = set([k for k in self.authorized_keys
if k != "injection" and k != "set_bus" and "set_line_status"])
def init(self, new_state_action, time_stamp, timestep_overflow):
"""
Initialize a "forecasted grid state" based on the new injections, possibly new topological modifications etc.
Parameters
----------
new_state_action: :class:`grid2op.Action`
The action that is performed on the powergrid to get the forecast at the current date. This "action" is
NOT performed by the user, it's performed internally by the BaseObservation to have a "forecasted" powergrid
with the forecasted values present in the chronics.
time_stamp: ``datetime.datetime``
The time stamp of the forecast, as a datetime.datetime object. NB this is not the time stamp at which the
forecast is produced, but the time stamp of the powergrid forecasted.
timestep_overflow: ``numpy.ndarray``
The see :attr:`grid2op.Env.timestep_overflow` for a better description of this argument.
Returns
-------
``None``
"""
if self.is_init:
return
# update the action that set the grid to the real value
self._action = BaseAction(gridobj=self)
self._action.update({
"set_line_status": np.array(self._line_status),
"set_bus": self._topo_vect,
"injection": {
"prod_p": self._prod_p,
"prod_v": self._prod_v,
"load_p": self._load_p,
"load_q": self._load_q
}
})
self._action += new_state_action
self.is_init = True
self.current_obs = None
self.time_stamp = time_stamp
self.timestep_overflow = timestep_overflow
class ObsEnv(_BasicEnv):
"""
This class is an 'Emulator' of a :class:`grid2op.Environment` used to be able to 'simulate' forecasted grid states.
It should not be used outside of an :class:`grid2op.BaseObservation` instance, or one of its derivative.
It contains only the most basic element of an Environment. See :class:`grid2op.Environment` for more details.
This class is reserved for internal use. Do not attempt to do anything with it.
"""
def __init__(self,
backend_instanciated,
parameters,
reward_helper,
obsClass,
action_helper,
thermal_limit_a,
legalActClass,
donothing_act,
other_rewards={}):
_BasicEnv.__init__(self,
parameters,
thermal_limit_a,
other_rewards=other_rewards)
self.donothing_act = donothing_act
self.reward_helper = reward_helper
self.obsClass = None
self._action = None
self.init_grid(backend_instanciated)
self.init_backend(init_grid_path=None,
chronics_handler=_ObsCH(),
backend=backend_instanciated,
names_chronics_to_backend=None,
actionClass=action_helper.actionClass,
observationClass=obsClass,
rewardClass=None,
legalActClass=legalActClass)
self.no_overflow_disconnection = parameters.NO_OVERFLOW_DISCONNECTION
self._load_p, self._load_q, self._load_v = None, None, None
self._prod_p, self._prod_q, self._prod_v = None, None, None
self._topo_vect = None
# convert line status to -1 / 1 instead of false / true
self._line_status = None
self.is_init = False
def init_backend(self, init_grid_path, chronics_handler, backend,
names_chronics_to_backend, actionClass, observationClass,
rewardClass, legalActClass):
"""
backend should not be the backend of the environment!!!
Parameters
----------
init_grid_path
chronics_handler
backend
names_chronics_to_backend
actionClass
observationClass
rewardClass
legalActClass
Returns
-------
"""
self.env_dc = self.parameters.FORECAST_DC
self.chronics_handler = chronics_handler
self.backend = backend
self.init_grid(self.backend)
self._has_been_initialized()
self.obsClass = observationClass
if not issubclass(legalActClass, BaseRules):
raise Grid2OpException(
"Parameter \"legalActClass\" used to build the Environment should derived form the "
"grid2op.BaseRules class, type provided is \"{}\"".format(
type(legalActClass)))
self.game_rules = RulesChecker(legalActClass=legalActClass)
self.legalActClass = legalActClass
self.helper_action_player = self._do_nothing
self.backend.set_thermal_limit(self._thermal_limit_a)
self._create_opponent()
def _do_nothing(self, x):
return self.donothing_act
def _update_actions(self):
"""
Retrieve the actions to perform the update of the underlying powergrid represented by
the :class:`grid2op.Backend`in the next time step.
A call to this function will also read the next state of :attr:`chronics_handler`, so it must be called only
once per time step.
Returns
--------
res: :class:`grid2op.Action.Action`
The action representing the modification of the powergrid induced by the Backend.
"""
# TODO consider disconnecting maintenance forecasted :-)
# This "environment" doesn't modify anything
return self.donothing_act, None
def copy(self):
"""
Implement the deep copy of this instance.
Returns
-------
res: :class:`ObsEnv`
A deep copy of this instance.
"""
backend = self.backend
self.backend = None
res = copy.deepcopy(self)
res.backend = backend.copy()
self.backend = backend
return res
def init(self, new_state_action, time_stamp, timestep_overflow):
"""
Initialize a "forecasted grid state" based on the new injections, possibly new topological modifications etc.
Parameters
----------
new_state_action: :class:`grid2op.Action`
The action that is performed on the powergrid to get the forecast at the current date. This "action" is
NOT performed by the user, it's performed internally by the BaseObservation to have a "forecasted" powergrid
with the forecasted values present in the chronics.
time_stamp: ``datetime.datetime``
The time stamp of the forecast, as a datetime.datetime object. NB this is not the time stamp at which the
forecast is produced, but the time stamp of the powergrid forecasted.
timestep_overflow: ``numpy.ndarray``
The see :attr:`grid2op.Env.timestep_overflow` for a better description of this argument.
Returns
-------
``None``
"""
if self.is_init:
return
# update the action that set the grid to the real value
self._action = BaseAction(gridobj=self)
self._action.update({
"set_line_status": np.array(self._line_status),
"set_bus": self._topo_vect,
"injection": {
"prod_p": self._prod_p,
"prod_v": self._prod_v,
"load_p": self._load_p,
"load_q": self._load_q
}
})
self._action += new_state_action
self.is_init = True
self.current_obs = None
self.time_stamp = time_stamp
self.timestep_overflow = timestep_overflow
def simulate(self, action):
"""
This function is the core method of the :class:`ObsEnv`. It allows to perform a simulation of what would
give and action if it were to be implemented on the "forecasted" powergrid.
It has the same signature as :func:`grid2op.Environment.Environment.step`. One of the major difference is that
it doesn't
check whether the action is illegal or not (but an implementation could be provided for this method). The
reason for this is that there is not one single and unique way to "forecast" how the thermal limit will behave,
which lines will be available or not, which actions will be done or not between the time stamp at which
"simulate" is called, and the time stamp that is simulated.
Parameters
----------
action: :class:`grid2op.Action.Action`
The action to test
Returns
-------
observation: :class:`grid2op.Observation.Observation`
agent's observation of the current environment
reward: ``float``
amount of reward returned after previous action
done: ``bool``
whether the episode has ended, in which case further step() calls will return undefined results
info: ``dict``
contains auxiliary diagnostic information (helpful for debugging, and sometimes learning). It is a
dictionnary with keys:
- "disc_lines": a numpy array (or ``None``) saying, for each powerline if it has been disconnected
due to overflow
- "is_illegal" (``bool``) whether the action given as input was illegal
- "is_ambiguous" (``bool``) whether the action given as input was ambiguous.
"""
self.backend.set_thermal_limit(self._thermal_limit_a)
self.backend.apply_action(self._action)
return self.step(action)
def get_obs(self):
"""
Method to retrieve the "forecasted grid" as a valid observation object.
Returns
-------
res: :class:`grid2op.Observation.Observation`
The observation available.
"""
self.current_obs = self.obsClass(gridobj=self.backend,
seed=None,
obs_env=None,
action_helper=None)
self.current_obs.update(self)
res = self.current_obs
return res
def update_grid(self, env):
"""
Update this "emulated" environment with the real powergrid.
Parameters
----------
env: :class:`grid2op.Environement._BasicEnv`
A reference to the environement
Returns
-------
"""
real_backend = env.backend
self._load_p, self._load_q, self._load_v = real_backend.loads_info()
self._prod_p, self._prod_q, self._prod_v = real_backend.generators_info(
)
self._topo_vect = real_backend.get_topo_vect()
# convert line status to -1 / 1 instead of false / true
self._line_status = real_backend.get_line_status().astype(
np.int) # false -> 0 true -> 1
self._line_status *= 2 # false -> 0 true -> 2
self._line_status -= 1 # false -> -1; true -> 1
self.is_init = False
# Make a copy of env state for simulation
self._thermal_limit_a = env._thermal_limit_a
self.gen_activeprod_t[:] = env.gen_activeprod_t[:]
self.times_before_line_status_actionable[:] = env.times_before_line_status_actionable[:]
self.times_before_topology_actionable[:] = env.times_before_topology_actionable[:]
self.time_remaining_before_line_reconnection[:] = env.time_remaining_before_line_reconnection[:]
self.time_next_maintenance[:] = env.time_next_maintenance[:]
self.duration_next_maintenance[:] = env.duration_next_maintenance[:]
self.target_dispatch[:] = env.target_dispatch[:]
self.actual_dispatch[:] = env.actual_dispatch[:]
backend.load_grid("matpower_case5.json") # this method has to be implemented
# NB the format of data can change of course :-)
# i converted it using pandapower converter to .mat using
# "pandapower.converter.to_mpc" (https://pandapower.readthedocs.io/en/v1.2.0/converter/matpower.html)
# we'll worry later on how to handle multiple files ;-)
## internal and performed automatically
backend.set_env_name("example") # this has not to be implemented
# now we list all "set" data
# but first we need to create the object that will allow to interact with the backend
from grid2op.Action._BackendAction import _BackendAction # internal
bk_class = _BackendAction.init_grid(backend) # internal, done automatically
env_to_backend = bk_class() # internal, done automatically
action_class = BaseAction.init_grid(backend) # internal, done automatically
my_action = action_class() # internal, done automatically
# do a powerflow
print("TEST MAKE POWERFLOW...")
converged = backend.runpf() # need to be implemented
assert converged
# I reading back the data
print("TEST READ DATA...")
prod_p, prod_q, prod_v = backend.generators_info(
) # this method has to be implemented
# it gives the values for each generator, and put it all to a vector
assert np.all(np.abs(prod_p - [10., 21.72983]) <= tol)
load_p, load_q, laod_v = backend.loads_info(