add a memory for the last known setpoints when object was connected

BDonnot · BDonnot · commit 6c6bcef14472 · 2025-03-03T15:26:59.000+01:00
Signed-off-by: DONNOT Benjamin &lt;benjamin.donnot@rte-france.com&gt;
diff --git a/grid2op/Environment/_env_prev_state.py b/grid2op/Environment/_env_prev_state.py
@@ -0,0 +1,137 @@
+# Copyright (c) 2025, RTE (https://www.rte-france.com)
+# See AUTHORS.txt
+# This Source Code Form is subject to the terms of the Mozilla Public License, version 2.0.
+# If a copy of the Mozilla Public License, version 2.0 was not distributed with this file,
+# you can obtain one at http://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+# This file is part of Grid2Op, Grid2Op a testbed platform to model sequential decision making in power systems.
+
+from typing import Optional, Type
+import numpy as np
+from grid2op.Space import GridObjects
+import grid2op.Backend
+from grid2op.Exceptions import Grid2OpException
+
+
+class _EnvPreviousState(object):
+    def __init__(self,
+                 grid_obj_cls: Type[GridObjects],
+                 init_load_p : np.ndarray,
+                 init_load_q : np.ndarray,
+                 init_gen_p : np.ndarray,
+                 init_gen_v : np.ndarray,
+                 init_topo_vect : np.ndarray,
+                 init_storage_p : np.ndarray,
+                 init_shunt_p : np.ndarray,
+                 init_shunt_q : np.ndarray,
+                 init_shunt_bus : np.ndarray):
+        self._can_modif = True
+        self._grid_obj_cls : Type[GridObjects] = grid_obj_cls
+        self._load_p : np.ndarray = 1. * init_load_p
+        self._load_q : np.ndarray = 1. * init_load_q
+        self._gen_p : np.ndarray = 1. * init_gen_p
+        self._gen_v : np.ndarray = 1. * init_gen_v
+        self._storage_p : np.ndarray = 1. * init_storage_p
+        self._topo_vect : np.ndarray = 1 * init_topo_vect
+        self._shunt_p : np.ndarray = 1. * init_shunt_p
+        self._shunt_q : np.ndarray = 1. * init_shunt_q
+        self._shunt_bus : np.ndarray = 1. * init_shunt_bus
+        
+    def update(self,
+               load_p : np.ndarray,
+               load_q : np.ndarray,
+               gen_p : np.ndarray,
+               gen_v : np.ndarray,
+               topo_vect : np.ndarray,
+               storage_p : Optional[np.ndarray],
+               shunt_p : Optional[np.ndarray],
+               shunt_q : Optional[np.ndarray],
+               shunt_bus : Optional[np.ndarray]):
+        if not self._can_modif:
+            raise Grid2OpException(f"Impossible to modifiy this _EnvPreviousState")
+        
+        self._aux_update(topo_vect[self._grid_obj_cls.load_pos_topo_vect],
+                         self._load_p,
+                         load_p,
+                         self._load_q,
+                         load_q)
+        self._aux_update(topo_vect[self._grid_obj_cls.gen_pos_topo_vect],
+                         self._gen_p,
+                         gen_p,
+                         self._gen_v,
+                         gen_v)
+        self._topo_vect[topo_vect > 0] = 1 * topo_vect[topo_vect > 0]
+        
+        # update storage units
+        if self._grid_obj_cls.n_storage > 0:
+            self._aux_update(topo_vect[self._grid_obj_cls.storage_pos_topo_vect],
+                            self._storage_p,
+                            storage_p)
+        
+        # handle shunts, if present
+        if shunt_p is not None:
+            self._aux_update(shunt_bus,
+                            self._shunt_p,
+                            shunt_p,
+                            self._shunt_q,
+                            shunt_q)
+            self._shunt_bus[shunt_bus > 0] = 1 * shunt_bus[shunt_bus > 0]
+    
+    def update_from_backend(self,
+                            backend: "grid2op.Backend.Backend"):
+        if not self._can_modif:
+            raise Grid2OpException(f"Impossible to modifiy this _EnvPreviousState")
+        topo_vect = backend.get_topo_vect()
+        load_p, load_q, *_ = backend.loads_info()
+        gen_p, gen_q, gen_v = backend.generators_info()
+        if self._grid_obj_cls.n_storage > 0:
+            storage_p, *_ = backend.storages_info()
+        else:
+            storage_p = None
+        if type(backend).shunts_data_available:
+            shunt_p, shunt_q, shunt_v, shunt_bus = backend.shunt_info()
+        else:
+            shunt_p, shunt_q, shunt_v, shunt_bus = None, None, None, None
+        self.update(load_p, load_q,
+                    gen_p, gen_v,
+                    topo_vect,
+                    storage_p,
+                    shunt_p, shunt_q, shunt_bus)
+    
+    def update_from_other(self, 
+                          other : "_EnvPreviousState"):
+        for attr_nm in ["_load_p",
+                        "_load_q",
+                        "_gen_p",
+                        "_gen_v",
+                        "_storage_p",
+                        "_topo_vect",
+                        "_shunt_p",
+                        "_shunt_q",
+                        "_shunt_bus"]:
+            getattr(self, attr_nm)[:] = getattr(other, attr_nm)
+            
+    def prevent_modification(self):
+        for attr_nm in ["_load_p",
+                        "_load_q",
+                        "_gen_p",
+                        "_gen_v",
+                        "_storage_p",
+                        "_topo_vect",
+                        "_shunt_p",
+                        "_shunt_q",
+                        "_shunt_bus"]:
+            getattr(self, attr_nm).flags.writeable = False
+        self._can_modif = False
+        
+    def _aux_update(self,
+                    el_topo_vect : np.ndarray,
+                    arr1 : np.ndarray,
+                    arr1_new : np.ndarray,
+                    arr2 : Optional[np.ndarray] = None,
+                    arr2_new : Optional[np.ndarray] = None):
+        el_co = el_topo_vect > 0
+        arr1[el_co] = 1. * arr1_new[el_co]
+        if arr2 is not None:
+            arr2[el_co] = 1. * arr2_new[el_co]
+        
diff --git a/grid2op/Environment/_obsEnv.py b/grid2op/Environment/_obsEnv.py
@@ -14,6 +14,7 @@
 
 import grid2op
 import grid2op.Action
+from grid2op.Environment._env_prev_state import _EnvPreviousState
 import grid2op.Observation  # for type hints
 from grid2op.typing_variables import STEP_INFO_TYPING
 from grid2op.dtypes import dt_int, dt_float, dt_bool
@@ -61,18 +62,22 @@ def __init__(
         tol_poly,
         max_episode_duration,
         delta_time_seconds,
-        other_rewards={},
+        other_rewards=None,
         has_attention_budget=False,
         attention_budget_cls=LinearAttentionBudget,
-        kwargs_attention_budget={},
+        kwargs_attention_budget=None,
         logger=None,
         highres_sim_counter=None,
         _complete_action_cls=None,
         allow_detachment:bool=DEFAULT_ALLOW_DETACHMENT,
         _ptr_orig_obs_space=None,
-        _local_dir_cls=None,  # only set at the first call to `make(...)` after should be false
+        _local_dir_cls=None,
         _read_from_local_dir=None,
     ):
+        if other_rewards is None:
+            other_rewards = {}
+        if kwargs_attention_budget is None:
+            kwargs_attention_budget = {}
         BaseEnv.__init__(
             self,
             init_env_path=init_env_path,
@@ -153,12 +158,12 @@ def __init__(
         if self.__unusable:
             self._backend_action_set = None
         else:
-            self._backend_action_set = self._backend_action_class()
+            self._backend_action_set : grid2op.Action._BackendAction._BackendAction = self._backend_action_class()
 
         if self.__unusable:
             self._disc_lines = np.zeros(shape=0, dtype=dt_int) - 1
         else:
-            self._disc_lines = np.zeros(shape=self.n_line, dtype=dt_int) - 1
+            self._disc_lines = np.zeros(shape=cls.n_line, dtype=dt_int) - 1
             
         self._max_episode_duration = max_episode_duration
 
@@ -321,7 +326,7 @@ def init(
         new_state_action : "grid2op.Action.BaseAction",
         time_stamp: datetime.datetime,
         obs : "grid2op.Observation.CompleteObservation",
-        time_step : int=1
+        time_step : int=1,
     ):
         """
         INTERNAL
@@ -384,8 +389,10 @@ def init(
         else:
             set_status = self._line_status_me
             topo_vect = self._topo_vect
+        
         # TODO set the shunts here
         # update the action that set the grid to the real value
+        self._previous_conn_state.update_from_other(obs._prev_conn)
         gen_p = obs._get_gen_p_for_forecasts()
         gen_v = obs._get_gen_v_for_forecasts()
         load_p = obs._get_load_p_for_forecasts()
@@ -407,7 +414,6 @@ def init(
         if time_step > 0:
             self._backend_action_set.storage_power.values[:] = 0.0
         self._backend_action_set.all_changed()
-        self._backend_action_set._assign_0_to_disco_el()
         self._backend_action = copy.deepcopy(self._backend_action_set)
         # for curtailment
         if self._env_modification is not None:
@@ -417,7 +423,7 @@ def init(
         self.current_obs.reset()
         self.time_stamp = time_stamp
 
-    def _get_new_prod_setpoint(self, action):
+    def _get_new_prod_setpoint(self, action : "grid2op.Action.BaseAction"):
         new_p = 1.0 * self._backend_action_set.prod_p.values
         if "prod_p" in action._dict_inj:
             tmp = action._dict_inj["prod_p"]
@@ -490,7 +496,7 @@ def simulate(self, action : "grid2op.Action.BaseAction") -> Tuple["grid2op.Obser
         obs, reward, done, info = self.step(action)
         return obs, reward, done, info
 
-    def get_obs(self, _update_state=True, _do_copy=True):
+    def get_obs(self, _update_state=True, _do_copy=True) -> "grid2op.Observation.BaseObservation":
         """
         INTERNAL
 
@@ -515,7 +521,7 @@ def get_obs(self, _update_state=True, _do_copy=True):
             res = self.current_obs
         return res
 
-    def update_grid(self, env):
+    def update_grid(self, env : BaseEnv):
         """
         INTERNAL
 
diff --git a/grid2op/Environment/baseEnv.py b/grid2op/Environment/baseEnv.py
@@ -22,6 +22,7 @@
 from scipy.optimize import (minimize, LinearConstraint)
 
 from abc import ABC, abstractmethod
+from grid2op.Environment._env_prev_state import _EnvPreviousState
 from grid2op.Observation import (BaseObservation,
                                  ObservationSpace,
                                  HighResSimCounter)
@@ -665,7 +666,11 @@ def __init__(
         
         # slack (1.11.0)
         self._delta_gen_p = None
-    
+        
+        # required in 1.11.0 : the previous state when the element was last connected
+        self._previous_conn_state = None
+        self._cst_prev_state_at_init = None
+        
     @property
     def highres_sim_counter(self):
         return self._highres_sim_counter
@@ -985,6 +990,10 @@ def _custom_deepcopy_for_copy(self, new_obj, dict_=None):
         # slack (1.11.0)
         new_obj._delta_gen_p = 1. * self._delta_gen_p
         
+        # previous connected state
+        new_obj._previous_conn_state = copy.deepcopy(self._previous_conn_state)
+        new_obj._cst_prev_state_at_init = self._cst_prev_state_at_init  # no need to deep copy this
+        
     def get_path_env(self):
         """
         Get the path that allows to create this environment.
@@ -1454,7 +1463,28 @@ def _has_been_initialized(self):
         
         # slack (1.11.0)
         self._delta_gen_p =  np.zeros(bk_type.n_gen, dtype=dt_float)
-
+        
+        # previous state (complete)
+        self._previous_conn_state = _EnvPreviousState(bk_type,
+                                                      np.zeros(bk_type.n_load, dtype=dt_float),
+                                                      np.zeros(bk_type.n_load, dtype=dt_float),
+                                                      np.zeros(bk_type.n_gen, dtype=dt_float),
+                                                      np.zeros(bk_type.n_gen, dtype=dt_float),
+                                                      np.zeros(bk_type.dim_topo, dtype=dt_int),
+                                                      np.zeros(bk_type.n_storage, dtype=dt_float),
+                                                      np.zeros(bk_type.n_shunt, dtype=dt_float),
+                                                      np.zeros(bk_type.n_shunt, dtype=dt_float),
+                                                      np.zeros(bk_type.n_shunt, dtype=dt_int),
+                                                      )
+        try:
+            self._previous_conn_state.update_from_backend(self.backend)
+        except Exception as exc_:
+            # nothing to do in this case
+            self.logger.warning(f"Impossible to retrieve the initial state of the grid before running the initial powerflow: {exc_}")
+            self._previous_conn_state._topo_vect[:] = 1  # I force assign everything to busbar 1 by default...
+        self._cst_prev_state_at_init = copy.deepcopy(self._previous_conn_state)
+        self._cst_prev_state_at_init.prevent_modification()
+        
     def _update_parameters(self):
         """update value for the new parameters"""
         self._parameters = self.__new_param
@@ -3168,7 +3198,11 @@ def _update_alert_properties(self, action, lines_attacked, subs_attacked):
         # TODO after alert budget will be implemented !
         # self._is_alert_illegal
     
-    def _aux_register_env_converged(self, disc_lines, action, init_line_status, new_p) -> Optional[Grid2OpException]:
+    def _aux_register_env_converged(self,
+                                    disc_lines,
+                                    action: BaseAction,
+                                    init_line_status,
+                                    new_p) -> Optional[Grid2OpException]:
         cls = type(self)
         beg_res = time.perf_counter()
         # update the thermal limit, for DLR for example
@@ -3272,6 +3306,10 @@ def _aux_register_env_converged(self, disc_lines, action, init_line_status, new_
         # finally, build the observation (it's a different one at each step, we cannot reuse the same one)
         # THIS SHOULD BE DONE AFTER EVERYTHING IS INITIALIZED !
         self.current_obs = self.get_obs(_do_copy=False)
+        
+        # update the previous state
+        self._previous_conn_state.update_from_backend(self.backend)
+        
         self._time_extract_obs += time.perf_counter() - beg_res
         return None
 
diff --git a/grid2op/Environment/environment.py b/grid2op/Environment/environment.py
@@ -945,10 +945,11 @@ def reset_grid(self,
         If the thermal has been modified, it also modify them into the new backend.
 
         """
-        self.backend.reset(
-            self._init_grid_path,
-        )  # the real powergrid of the environment
+        # the real powergrid of the environment
+        self.backend.reset(self._init_grid_path)  
+        
         # self.backend.assert_grid_correct()
+        self._previous_conn_state.update_from_other(self._cst_prev_state_at_init)
 
         if self._thermal_limit_a is not None:
             self.backend.set_thermal_limit(self._thermal_limit_a.astype(dt_float))
diff --git a/grid2op/Observation/baseObservation.py b/grid2op/Observation/baseObservation.py
diff --git a/grid2op/tests/test_detached_simulate.py b/grid2op/tests/test_detached_simulate.py
