feat : use defaultprotection in place of next_grid function

yassine abdou · yassine abdou · commit a9d6ff06ced4 · 2025-03-07T15:46:31.000+01:00
diff --git a/grid2op/Backend/thermalLimits.py b/grid2op/Backend/thermalLimits.py
@@ -1,6 +1,12 @@
-from loguru import logger
 from typing import Union, List, Optional, Dict
+try:
+    from typing import Self
+except ImportError:
+    from typing_extensions import Self
+
+from loguru import logger
 import numpy as np
+import copy
 
 import grid2op
 from grid2op.dtypes import dt_float
@@ -126,6 +132,8 @@ def limits(self, new_limits: Union[np.ndarray, Dict[str, float]]):
                     self._thermal_limit_a[i] = tmp
 
     def env_limits(self, thermal_limit):
+        """
+        """
         if isinstance(thermal_limit, dict):
             tmp = np.full(self.n_line, fill_value=np.NaN, dtype=dt_float)
             for key, val in thermal_limit.items():
@@ -179,7 +187,7 @@ def env_limits(self, thermal_limit):
         self._thermal_limit_a = tmp
         logger.info("Env thermal limits successfully set.")
 
-    def update_limits(self, thermal_limit_a: np.ndarray) -> None:
+    def update_limits_from_vector(self, thermal_limit_a: np.ndarray) -> None:
         """
         Updates the thermal limits using a numpy array.
 
@@ -188,4 +196,16 @@ def update_limits(self, thermal_limit_a: np.ndarray) -> None:
         """
         thermal_limit_a = np.array(thermal_limit_a).astype(dt_float)
         self._thermal_limit_a = thermal_limit_a
-        logger.info("Thermal limits updated from vector.")
+        logger.info("Thermal limits updated from vector.")
+
+    def update_limits(self, env : "grid2op.Environment.BaseEnv") -> None:
+        pass
+
+    def copy(self) -> Self:
+        """
+        Creates a deep copy of the current ThermalLimits instance.
+
+        :return: ThermalLimits
+            A new instance with the same attributes.
+        """
+        return copy.deepcopy(self)
diff --git a/grid2op/Environment/_obsEnv.py b/grid2op/Environment/_obsEnv.py
@@ -116,7 +116,6 @@ def __init__(
         self.current_obs_init = None
         self.current_obs = None
 
-        self._init_thermal_limit()
 
         self._init_backend(
             chronics_handler=_ObsCH(),
@@ -128,7 +127,6 @@ def __init__(
             legalActClass=legalActClass,
         )
 
-        self.ts_manager = copy.deepcopy(self._observation_space.ts_manager)
 
         self.delta_time_seconds = delta_time_seconds
         ####
diff --git a/grid2op/Environment/baseEnv.py b/grid2op/Environment/baseEnv.py
@@ -570,8 +570,8 @@ def __init__(
         self.debug_dispatch = False
 
         # Thermal limit and protection
-        self.ts_manager : thermalLimits.ThermalLimits = None
-        self.protection = protectionScheme.NoProtection = None
+        self._init_thermal_limit()
+        self.protection : protectionScheme.DefaultProtection = None
 
         # to change the parameters
         self.__new_param = None
@@ -673,18 +673,8 @@ def __init__(
     
 
     def _init_thermal_limit(self):
-
-        if self._thermal_limit_a is None:
-            if hasattr(self.ts_manager, '_thermal_limit_a') and isinstance(self.ts_manager.limits, np.ndarray):
-                _thermal_limits = self.ts_manager.limits.astype(dt_float)
-            else:
-                raise ValueError("Thermal limits not provided and 'self.ts_manager.limits' is unavailable or invalid.")
-        else:
-            _thermal_limits = self._thermal_limit_a
-        
-        # Update the thermal limits manager for protection scheme
         self.ts_manager = thermalLimits.ThermalLimits(
-            _thermal_limit_a = _thermal_limits,
+            _thermal_limit_a = self._thermal_limit_a,
             n_line=self.n_line,
             line_names=self.name_line
         )
@@ -770,6 +760,7 @@ def _custom_deepcopy_for_copy(self, new_obj, dict_=None):
         new_obj._backend_action = copy.deepcopy(self._backend_action)
 
         # specific to Basic Env, do not change
+        new_obj.backend = self.backend.copy()
         new_obj.ts_manager = self.ts_manager.copy()
         if self._thermal_limit_a is not None:
             new_obj.ts_manager.limits = self._thermal_limit_a
@@ -1878,52 +1869,51 @@ def _init_backend(
         """
         pass
 
-    def set_thermal_limit(self, thermal_limit):
-        """
-        Set the thermal limit effectively.
+    # def set_thermal_limit(self, thermal_limit):
+    #     """
+    #     Set the thermal limit effectively.
 
-        Parameters
-        ----------
-        thermal_limit: ``numpy.ndarray``
-            The new thermal limit. It must be a numpy ndarray vector (or convertible to it). For each powerline it
-            gives the new thermal limit.
+    #     Parameters
+    #     ----------
+    #     thermal_limit: ``numpy.ndarray``
+    #         The new thermal limit. It must be a numpy ndarray vector (or convertible to it). For each powerline it
+    #         gives the new thermal limit.
 
-            Alternatively, this can be a dictionary mapping the line names (keys) to its thermal limits (values). In
-            that case, all thermal limits for all powerlines should be specified (this is a safety measure
-            to reduce the odds of misuse).
+    #         Alternatively, this can be a dictionary mapping the line names (keys) to its thermal limits (values). In
+    #         that case, all thermal limits for all powerlines should be specified (this is a safety measure
+    #         to reduce the odds of misuse).
 
-        Examples
-        ---------
+    #     Examples
+    #     ---------
 
-        This function can be used like this:
+    #     This function can be used like this:
 
-        .. code-block:: python
+    #     .. code-block:: python
 
-            import grid2op
+    #         import grid2op
 
-            # I create an environment
-            env = grid2op.make(""l2rpn_case14_sandbox"", test=True)
+    #         # I create an environment
+    #         env = grid2op.make(""l2rpn_case14_sandbox"", test=True)
 
-            # i set the thermal limit of each powerline to 20000 amps
-            env.set_thermal_limit([20000 for _ in range(env.n_line)])
+    #         # i set the thermal limit of each powerline to 20000 amps
+    #         env.set_thermal_limit([20000 for _ in range(env.n_line)])
 
-        Notes
-        -----
-        As of grid2op > 1.5.0, it is possible to set the thermal limit by using a dictionary with the keys being
-        the name of the powerline and the values the thermal limits.
+    #     Notes
+    #     -----
+    #     As of grid2op > 1.5.0, it is possible to set the thermal limit by using a dictionary with the keys being
+    #     the name of the powerline and the values the thermal limits.
 
-        """
-        if self.__closed:
-            raise EnvError("This environment is closed, you cannot use it.")
-        if not self.__is_init:
-            raise Grid2OpException(
-                "Impossible to set the thermal limit to a non initialized Environment. "
-                "Have you called `env.reset()` after last game over ?"
-            )
-        # update n_line and name_line of ts_manager (old : self.ts_manager.n_line = -1 and self.ts_manager.name_line = None)
-        self.ts_manager.env_limits(thermal_limit=thermal_limit)
-        self.ts_manager.limits = self._thermal_limit_a
-        self.observation_space.set_thermal_limit(self._thermal_limit_a)
+    #     """
+    #     if self.__closed:
+    #         raise EnvError("This environment is closed, you cannot use it.")
+    #     if not self.__is_init:
+    #         raise Grid2OpException(
+    #             "Impossible to set the thermal limit to a non initialized Environment. "
+    #             "Have you called `env.reset()` after last game over ?"
+    #         )
+    #     # update n_line and name_line of ts_manager (old : self.ts_manager.n_line = -1 and self.ts_manager.name_line = None)
+    #     self.ts_manager.env_limits(thermal_limit=thermal_limit)
+    #     self.observation_space.set_thermal_limit(thermal_limit=thermal_limit)
 
     def _reset_redispatching(self):
         # redispatching
@@ -2588,33 +2578,33 @@ def get_obs(self, _update_state=True, _do_copy=True):
         else:
             return self._last_obs
 
-    def get_thermal_limit(self):
-        """
-        Get the current thermal limit in amps registered for the environment.
+    # def get_thermal_limit(self):
+    #     """
+    #     Get the current thermal limit in amps registered for the environment.
 
-        Examples
-        ---------
+    #     Examples
+    #     ---------
 
-        It can be used like this:
+    #     It can be used like this:
 
-        .. code-block:: python
+    #     .. code-block:: python
 
-            import grid2op
+    #         import grid2op
 
-            # I create an environment
-            env = grid2op.make("l2rpn_case14_sandbox")
+    #         # I create an environment
+    #         env = grid2op.make("l2rpn_case14_sandbox")
 
-            thermal_limits = env.get_thermal_limit()
+    #         thermal_limits = env.get_thermal_limit()
 
-        """
-        if self.__closed:
-            raise EnvError("This environment is closed, you cannot use it.")
-        if not self.__is_init:
-            raise EnvError(
-                "This environment is not initialized. It has no thermal limits. "
-                "Have you called `env.reset()` after last game over ?"
-            )
-        return 1.0 * self._thermal_limit_a
+    #     """
+    #     if self.__closed:
+    #         raise EnvError("This environment is closed, you cannot use it.")
+    #     if not self.__is_init:
+    #         raise EnvError(
+    #             "This environment is not initialized. It has no thermal limits. "
+    #             "Have you called `env.reset()` after last game over ?"
+    #         )
+    #     return 1.0 * self._thermal_limit_a
 
     def _withdraw_storage_losses(self):
         """
@@ -3155,7 +3145,7 @@ def _update_alert_properties(self, action, lines_attacked, subs_attacked):
     def _aux_register_env_converged(self, disc_lines, action, init_line_status, new_p) -> Optional[Grid2OpException]:
         beg_res = time.perf_counter()
         # update the thermal limit, for DLR for example
-        self.ts_manager.update_limits(thermal_limit_a=self._thermal_limit_a) # old code : self.backend.update_thermal_limit(self)
+        self.ts_manager.update_limits(self) # old code : self.backend.update_thermal_limit(self)
 
         overflow_lines = self.backend.get_line_overflow()
         # save the current topology as "last" topology (for connected powerlines)
@@ -3252,11 +3242,10 @@ def _aux_register_env_converged(self, disc_lines, action, init_line_status, new_
         self._time_extract_obs += time.perf_counter() - beg_res
         return None
 
-    def _backend_next_grid_state(self):
+    def _protection_next_grid_state(self):
         """overlaoded in MaskedEnv"""
         self._init_thermal_limit()
         self._init_protection()
-        return self.protection.next_grid_state()
     
     def _aux_run_pf_after_state_properly_set(
         self, action, init_line_status, new_p, except_
@@ -3286,7 +3275,8 @@ def _aux_run_pf_after_state_properly_set(
         try:
             # compute the next _grid state
             beg_pf = time.perf_counter()
-            disc_lines, detailed_info, conv_ = self._backend_next_grid_state()
+            self._protection_next_grid_state()
+            disc_lines, detailed_info, conv_ = self.protection.next_grid_state()
             self._disc_lines[:] = disc_lines
             self._time_powerflow += time.perf_counter() - beg_pf
             if conv_ is None:
diff --git a/grid2op/Environment/environment.py b/grid2op/Environment/environment.py
@@ -26,7 +26,7 @@
 from grid2op.Observation import CompleteObservation, ObservationSpace, BaseObservation
 from grid2op.Reward import FlatReward, RewardHelper, BaseReward
 from grid2op.Rules import RulesChecker, AlwaysLegal, BaseRules
-from grid2op.Backend import Backend, protectionScheme, thermalLimits
+from grid2op.Backend import Backend, thermalLimits
 from grid2op.Chronics import ChronicsHandler
 from grid2op.VoltageControler import ControlVoltageFromFile, BaseVoltageController
 from grid2op.Environment.baseEnv import BaseEnv
@@ -85,6 +85,7 @@ def __init__(
         chronics_handler,
         backend,
         parameters,
+        ts_manager: thermalLimits.ThermalLimits = None,
         name="unknown",
         n_busbar:N_BUSBAR_PER_SUB_TYPING=DEFAULT_N_BUSBAR_PER_SUB,
         allow_detachment:bool=DEFAULT_ALLOW_DETACHMENT,
@@ -207,19 +208,19 @@ def __init__(
         self._init_backend(
             chronics_handler,
             backend,
+            ts_manager,
             names_chronics_to_backend,
             actionClass,
             observationClass,
             rewardClass,
             legalActClass,
         )
-        self.ts_manager : thermalLimits.ThermalLimits = copy.deepcopy(self.ts_manager)
-        self.protection : protectionScheme.DefaultProtection = copy.deepcopy(self.protection)
         
     def _init_backend(
         self,
         chronics_handler,
         backend,
+        ts_manager,
         names_chronics_to_backend,
         actionClass,
         observationClass,
@@ -249,7 +250,13 @@ def _init_backend(
                         type(rewardClass)
                     )
                 )
-
+        #thermalLimits:
+        ts_manager = ts_manager or self.ts_manager
+        if not isinstance(ts_manager, thermalLimits.ThermalLimits):
+            raise Grid2OpException(
+                'Parameter "ts_manager" used to build the Environment should derived form the '
+                'grid2op.Backend.thermalLimits class, type provided is "{}"'.format(type(ts_manager))
+            )
         # backend
         if not isinstance(backend, Backend):
             raise Grid2OpException(
@@ -326,11 +333,13 @@ def _init_backend(
         self._line_status = np.ones(shape=self.n_line, dtype=dt_bool)
         self._disc_lines = np.zeros(shape=self.n_line, dtype=dt_int) - 1
 
+        self.ts_manager.n_line = self.n_line
+        self.ts_manager.name_line = self.name_line
         if self._thermal_limit_a is None:
-            self._thermal_limit_a = self.backend.thermal_limit_a.astype(dt_float)
+            self.ts_manager.limits = self.backend.thermal_limit_a.astype(dt_float)
+            self._thermal_limit_a = self.ts_manager.limits
         else:
-            self.backend.set_thermal_limit(self._thermal_limit_a.astype(dt_float))
-
+            self.ts_manager.limits = self._thermal_limit_a.astype(dt_float)
         *_, tmp = self.backend.generators_info()
 
         # rules of the game
@@ -1582,7 +1591,8 @@ def get_kwargs(self,
         res["legalActClass"] = self._legalActClass
         res["epsilon_poly"] = self._epsilon_poly
         res["tol_poly"] = self._tol_poly
-        res["thermal_limit_a"] = self._thermal_limit_a
+        # res["thermal_limit_a"] = self._thermal_limit_a
+        res["ts_manager"] = self.ts_manager
         res["voltagecontrolerClass"] = self._voltagecontrolerClass
         res["other_rewards"] = {k: v.rewardClass for k, v in self.other_rewards.items()}
         res["name"] = self.name
@@ -2204,7 +2214,8 @@ def get_params_for_runner(self):
         if self.chronics_handler.max_iter is not None:
             res["max_iter"] = self.chronics_handler.max_iter
         res["gridStateclass_kwargs"] = dict_
-        res["thermal_limit_a"] = self._thermal_limit_a
+        # res["thermal_limit_a"] = self._thermal_limit_a
+        res["ts_manager"] = self.ts_manager
         res["voltageControlerClass"] = self._voltagecontrolerClass
         res["other_rewards"] = {k: v.rewardClass for k, v in self.other_rewards.items()}
         res["grid_layout"] = self.grid_layout
diff --git a/grid2op/Episode/EpisodeReboot.py b/grid2op/Episode/EpisodeReboot.py
@@ -244,9 +244,7 @@ def _assign_state(self, obs):
         # # TODO check that the "stored" "last bus for when the powerline were connected" are
         # # kept there (I might need to do a for loop)
         self.env.backend.update_from_obs(obs)
-        disc_lines, detailed_info, conv_ = self.env.backend.next_grid_state(
-            env=self.env
-        )
+        disc_lines, detailed_info, conv_ = self.env.protection.next_grid_state()
         if conv_ is None:
             self.env._backend_action.update_state(disc_lines)
         self.env._backend_action.reset()
diff --git a/grid2op/MakeEnv/MakeFromPath.py b/grid2op/MakeEnv/MakeFromPath.py
@@ -1069,8 +1069,9 @@ def make_from_dataset_path(
         env._do_not_erase_local_dir_cls = do_not_erase_cls
     # Update the thermal limit if any
     if thermal_limits is not None:
-        env.set_thermal_limit(thermal_limits)
-        
+        env.ts_manager.env_limits(thermal_limits)
+        env.observation_space.ts_manager.env_limits(env.ts_manager.limits)
+
     # Set graph layout if not None and not an empty dict
     if graph_layout is not None and graph_layout:
         try:
diff --git a/grid2op/Observation/baseObservation.py b/grid2op/Observation/baseObservation.py
diff --git a/grid2op/Observation/observationSpace.py b/grid2op/Observation/observationSpace.py
diff --git a/grid2op/Runner/runner.py b/grid2op/Runner/runner.py
