fixing some issues and implement test when reconnecting powerlines

BDonnot · BDonnot · commit a27c850bb49f · 2025-03-04T15:23:22.000+01:00
Signed-off-by: DONNOT Benjamin &lt;benjamin.donnot@rte-france.com&gt;
diff --git a/CHANGELOG.rst b/CHANGELOG.rst
@@ -137,6 +137,9 @@ Native multi agents support:
 - [FIXED] a bug in updating the shunt in PandaPowerBackend (depdending on pandas version)
 - [FIXED] a bug when action that reconnect loads, storage units or shunts are done
   in the "obs.simulate" (results could depend from previous "obs.simulate" calls)
+- [FIXED] a bug in "obs.simulate" and "obs.get_forecast_env" : when a line was disconnected
+  and the user tried to reconnect it (without specifying on which bus) it could do something
+  different than "env.step" (with the same action)
 - [ADDED] possibility to set the "thermal limits" when calling `env.reset(..., options={"thermal limit": xxx})`
 - [ADDED] possibility to retrieve some structural information about elements with
   with `gridobj.get_line_info(...)`, `gridobj.get_load_info(...)`, `gridobj.get_gen_info(...)` 
diff --git a/grid2op/Backend/backend.py b/grid2op/Backend/backend.py
@@ -36,6 +36,8 @@
     Grid2OpException,
 )
 from grid2op.Space import GridObjects, ElTypeInfo, DEFAULT_N_BUSBAR_PER_SUB, DEFAULT_ALLOW_DETACHMENT
+import grid2op.Observation  # for type hints
+import grid2op.Action  # for type hints
 
 
 # TODO method to get V and theta at each bus, could be in the same shape as check_kirchoff
@@ -1920,7 +1922,7 @@ def get_action_to_set(self) -> "grid2op.Action.CompleteAction":
 
     def update_from_obs(self,
                         obs: "grid2op.Observation.CompleteObservation",
-                        force_update: Optional[bool]=False):
+                        force_update: Optional[bool]=False) -> "grid2op.Action._BackendAction._BackendAction":
         """
         Takes an observation as input and update the internal state of `self` to match the state of the backend
         that produced this observation.
@@ -1954,18 +1956,18 @@ def update_from_obs(self,
             )
 
         cls = type(self)
-        backend_action = cls.my_bk_act_class()
+        backend_action : "grid2op.Action._BackendAction._BackendAction" = cls.my_bk_act_class()        
         act = cls._complete_action_class()
         line_status = self._aux_get_line_status_to_set(obs.line_status)
         # skip the action part and update directly the backend action !
         dict_ = {
             "set_bus": obs.topo_vect,
             "set_line_status": line_status,
             "injection": {
-                "prod_p": obs.prod_p,
-                "prod_v": obs.prod_v,
-                "load_p": obs.load_p,
-                "load_q": obs.load_q,
+                "prod_p": obs._get_gen_p_for_forecasts(),
+                "prod_v": obs._get_gen_v_for_forecasts(),
+                "load_p": obs._get_load_p_for_forecasts(),
+                "load_q": obs._get_load_q_for_forecasts(),
             },
         }
 
@@ -1991,6 +1993,7 @@ def update_from_obs(self,
         act.update(dict_)
         backend_action += act
         self.apply_action(backend_action)
+        return backend_action
 
     def assert_grid_correct(self, _local_dir_cls=None) -> None:
         """
diff --git a/grid2op/Environment/_env_prev_state.py b/grid2op/Environment/_env_prev_state.py
@@ -118,8 +118,21 @@ def update_from_other(self,
                 tmp[:] = getattr(other, attr_nm)
             else:
                 setattr(self, attr_nm, getattr(other, attr_nm))
-            
+        
     def prevent_modification(self):
+        self._aux_modif()
+        self._can_modif = False
+        
+    def force_update(self, other: "_EnvPreviousState"):
+        """This is used when initializing the forecast env. This removes the "cst" part, 
+        set it to the value given by other, and then assign it to const.
+        """
+        self._can_modif = True
+        self._aux_modif(True)
+        self.update_from_other(other)
+        self.prevent_modification()
+    
+    def _aux_modif(self, writeable_flag=False):
         for attr_nm in ["_load_p",
                         "_load_q",
                         "_gen_p",
@@ -132,8 +145,7 @@ def prevent_modification(self):
             tmp = getattr(self, attr_nm)
             if tmp.size > 1:
                 # can't set flags on array of size 1 apparently
-                tmp.flags.writeable = False
-        self._can_modif = False
+                tmp.flags.writeable = writeable_flag
         
     def _aux_update(self,
                     el_topo_vect : np.ndarray,
diff --git a/grid2op/Environment/_obsEnv.py b/grid2op/Environment/_obsEnv.py
@@ -393,6 +393,8 @@ def init(
         # 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)
+        # remember the last connection state
+        self._backend_action_set.last_topo_registered.values[:] = obs._prev_conn._topo_vect
         gen_p = obs._get_gen_p_for_forecasts()
         gen_v = obs._get_gen_v_for_forecasts()
         load_p = obs._get_load_p_for_forecasts()
diff --git a/grid2op/Environment/baseEnv.py b/grid2op/Environment/baseEnv.py
@@ -1476,14 +1476,26 @@ def _has_been_initialized(self):
                                                       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()
+        
+        if self._init_obs is None:
+            # regular environment, initialized from scratch
+            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()
+        else:
+            # environment initialized from an observation, eg forecast_env
+            self._cst_prev_state_at_init = copy.deepcopy(self._init_obs._prev_conn)
+            self._cst_prev_state_at_init.prevent_modification()
+            self._previous_conn_state.update_from_other(self._cst_prev_state_at_init)
+            # TODO this has to be done also in "_reset_to_orig_state" but I don't know why...
+            
+        # update backend_action with the "last known" state
+        self._backend_action.last_topo_registered.values[:] = self._previous_conn_state._topo_vect
         
     def _update_parameters(self):
         """update value for the new parameters"""
@@ -4626,6 +4638,11 @@ def _reset_to_orig_state(self, obs):
         
         # soft overflow
         self._timestep_overflow[:] = obs.timestep_overflow
+        
+        # previous "connected" state of all elements
+        self._previous_conn_state.update_from_other(obs._prev_conn)  # already done with _cst_prev_XXX
+        self._backend_action.last_topo_registered.values[:] = obs._prev_conn._topo_vect
+        # self._backend_action.current_topo.values[:] = obs._prev_conn._topo_vect
 
     def forecasts(self):
         # ensure that the "env.chronics_handler.forecasts" is called at most once per step
diff --git a/grid2op/Environment/environment.py b/grid2op/Environment/environment.py
@@ -34,7 +34,6 @@
 from grid2op.operator_attention import LinearAttentionBudget
 from grid2op.Space import DEFAULT_N_BUSBAR_PER_SUB, DEFAULT_ALLOW_DETACHMENT, GRID2OP_CURRENT_VERSION_STR
 from grid2op.typing_variables import RESET_OPTIONS_TYPING, N_BUSBAR_PER_SUB_TYPING
-from grid2op.MakeEnv.PathUtils import USE_CLASS_IN_FILE
 
 
 class Environment(BaseEnv):
@@ -202,6 +201,7 @@ def __init__(
         self._allow_loaded_backend : bool = _allow_loaded_backend
 
         # for gym compatibility (action_spacen and observation_space initialized below)
+        # for plotting
         self.reward_range = None
         self._viewer = None
         self.metadata = None
@@ -212,7 +212,8 @@ def __init__(
         # needs to be done before "_init_backend" otherwise observationClass is not defined in the
         # observation space (real_env_kwargs)
         self._observationClass_orig = observationClass
-        # for plotting
+        
+        # init the backend
         self._init_backend(
             chronics_handler,
             backend,
@@ -533,6 +534,14 @@ def _init_backend(
         # reset everything to be consistent
         self._reset_vectors_and_timings()
         
+        # 1.11 and detachement: forecasted env
+        if self._init_obs is not None:
+            # update the backend
+            self._backend_action = self.backend.update_from_obs(self._init_obs)
+            self._backend_action.last_topo_registered.values[:] = self._init_obs._prev_conn._topo_vect
+            self._cst_prev_state_at_init.force_update(self._init_obs._prev_conn)
+            self._previous_conn_state.update_from_other(self._init_obs._prev_conn)
+        
     def max_episode_duration(self):
         """
         Return the maximum duration (in number of steps) of the current episode.
@@ -963,11 +972,14 @@ def reset_grid(self,
         if self._thermal_limit_a is not None:
             self.backend.set_thermal_limit(self._thermal_limit_a.astype(dt_float))
 
-        self._backend_action = self._backend_action_class()
         self.nb_time_step = -1  # to have init obs at step 1 (and to prevent 'setting to proper state' "action" to be illegal)
         
         if self._init_obs is not None:
-            self.backend.update_from_obs(self._init_obs)
+            # update the backend
+            self._backend_action = self.backend.update_from_obs(self._init_obs)
+            self._backend_action.last_topo_registered.values[:] = self._init_obs._prev_conn._topo_vect
+        else:
+            self._backend_action = self._backend_action_class()
             
         init_action = None
         if not self._parameters.IGNORE_INITIAL_STATE_TIME_SERIE:
