feat : use default and no protection in baseEnv, use protection in place of next_grid function from backend

Author: yassine abdou

grid2op/Backend/protectionScheme.py

@@ -32,11 +32,11 @@ def __init__(
         self.thermal_limits = thermal_limits
 
         self._thermal_limit_a = self.thermal_limits.limits if self.thermal_limits else None
-
+        self.backend.thermal_limit_a = self._thermal_limit_a
+        
         self._hard_overflow_threshold = self._get_value_from_parameters("HARD_OVERFLOW_THRESHOLD")
         self._soft_overflow_threshold = self._get_value_from_parameters("SOFT_OVERFLOW_THRESHOLD")
         self._nb_timestep_overflow_allowed = self._get_value_from_parameters("NB_TIMESTEP_OVERFLOW_ALLOWED")
-        self._no_overflow_disconnection = self._get_value_from_parameters("NO_OVERFLOW_DISCONNECTION")
 
         self.disconnected_during_cf = np.full(self.thermal_limits.n_line, fill_value=-1, dtype=dt_int)
         self._timestep_overflow = np.zeros(self.thermal_limits.n_line, dtype=dt_int)
@@ -81,9 +81,6 @@ def _disconnect_lines(self, lines_to_disconnect: np.ndarray, timestep: int) -> N
 
     def next_grid_state(self) -> Tuple[np.ndarray, List[Any], Union[None, Exception]]:
         try:
-            if self._no_overflow_disconnection: # détaché cela d'ici et si on simule pas 
-                return self._handle_no_protection()
-
             timestep = 0
             while True:
                 power_flow_result = self._run_power_flow()
@@ -105,24 +102,30 @@ def next_grid_state(self) -> Tuple[np.ndarray, List[Any], Union[None, Exception]
             logger.exception("Erreur inattendue dans le calcul de l'état du réseau.")
             return self.disconnected_during_cf, self.infos, e
 
-    def _handle_no_protection(self) -> Tuple[np.ndarray, List[Any], None]:
-        no_protection = NoProtection(self.thermal_limits)
-        return no_protection.handle_no_protection()
-
 class NoProtection:
     """
     Classe qui gère le cas où les protections de débordement sont désactivées.
     """
     def __init__(
             self,
+            backend: Backend,
             thermal_limits: ThermalLimits
         ):
+        self.backend = backend
+        self._validate_input(self.backend)
 
         self.thermal_limits = thermal_limits
+
+        self._thermal_limit_a = self.thermal_limits.limits if self.thermal_limits else None
+        self.backend.thermal_limit_a = self._thermal_limit_a
+
         self.disconnected_during_cf = np.full(self.thermal_limits.n_line, fill_value=-1, dtype=dt_int)
         self.infos = []
 
-    def handle_no_protection(self) -> Tuple[np.ndarray, List[Any], None]:
+    def _validate_input(self, backend: Backend) -> None:
+        if not isinstance(backend, Backend):
+            raise Grid2OpException(f"Argument 'backend' doit être de type 'Backend', reçu : {type(backend)}")
+    def next_grid_state(self) -> Tuple[np.ndarray, List[Any], None]:
         """
         Retourne l'état du réseau sans effectuer de déconnexions dues aux débordements.
         """

grid2op/Environment/baseEnv.py

@@ -571,7 +571,7 @@ def __init__(
 
         # Thermal limit and protection
         self._init_thermal_limit()
-        self.protection : protectionScheme.DefaultProtection = None
+        self.protection : protectionScheme = None
 
         # to change the parameters
         self.__new_param = None
@@ -681,12 +681,21 @@ def _init_thermal_limit(self):
 
     def _init_protection(self):
         # Initialize the protection system with the specified parameters
-        self.protection = protectionScheme.DefaultProtection(
-            backend=self.backend,
-            parameters=self.parameters,
-            thermal_limits=self.ts_manager,
-            is_dc=self._env_dc
-        ) 
+        self._no_overflow_disconnection: bool = (
+            self._parameters.NO_OVERFLOW_DISCONNECTION
+        )
+        if self._no_overflow_disconnection:
+            self.protection = protectionScheme.NoProtection(
+                backend=self.backend,
+                thermal_limits=self.ts_manager,
+            )
+        else:
+            self.protection = protectionScheme.DefaultProtection(
+                backend=self.backend,
+                parameters=self.parameters,
+                thermal_limits=self.ts_manager,
+                is_dc=self._env_dc
+            )
 
     @property
     def highres_sim_counter(self):
@@ -1869,51 +1878,52 @@ 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.observation_space.set_thermal_limit(thermal_limit=thermal_limit)
+        """
+        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.backend.thermal_limit_a = self.ts_manager.limits
+        self.observation_space.set_thermal_limit(self.ts_manager.limits)
 
     def _reset_redispatching(self):
         # redispatching

grid2op/MakeEnv/MakeFromPath.py

@@ -1069,8 +1069,7 @@ 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.ts_manager.env_limits(thermal_limits)
-        env.observation_space.ts_manager.env_limits(env.ts_manager.limits)
+        env.set_thermal_limit(thermal_limits)
 
     # Set graph layout if not None and not an empty dict
     if graph_layout is not None and graph_layout:

grid2op/Observation/observationSpace.py

@@ -399,11 +399,11 @@ def change_reward(self, reward_func):
                                "function when you cannot simulate (because the "
                                "backend could not be copied)")
 
-    # def set_thermal_limit(self, thermal_limit_a):
-    #     if self.obs_env is not None:
-    #         self.obs_env.set_thermal_limit(thermal_limit_a)
-    #     if self._backend_obs is not None:
-    #         self.obs_env.ts_manager.limits = thermal_limit_a
+    def set_thermal_limit(self, thermal_limit_a):
+        if self.obs_env is not None:
+            self.obs_env.ts_manager.env_limits(thermal_limit_a)
+        if self._backend_obs is not None:
+            self._backend_obs.thermal_limit_a = thermal_limit_a
 
     def reset_space(self):
         if self.with_forecast:

grid2op/tests/BaseBackendTest.py

@@ -1637,7 +1637,7 @@ def next_grid_state_no_overflow(self):
 
             )
 
-        disco, infos, conv_ = self.backend.next_grid_state(env, is_dc=False)
+        disco, infos, conv_ = env.protection.next_grid_state()
         assert conv_ is None
         assert not infos
 
@@ -1667,9 +1667,10 @@ def test_next_grid_state_1overflow(self):
         thermal_limit[self.id_first_line_disco] = (
             self.lines_flows_init[self.id_first_line_disco] / 2
         )
-        self.backend.set_thermal_limit(thermal_limit)
-
-        disco, infos, conv_ = self.backend.next_grid_state(env, is_dc=False)
+        env.ts_manager.limits = thermal_limit
+        env._init_protection()
+        
+        disco, infos, conv_ = env.protection.next_grid_state()
         assert conv_ is None
         assert len(infos) == 1  # check that i have only one overflow
         assert np.sum(disco >= 0) == 1
@@ -1704,9 +1705,10 @@ def test_next_grid_state_1overflow_envNoCF(self):
         thermal_limit[self.id_first_line_disco] = (
             lines_flows_init[self.id_first_line_disco] / 2
         )
-        self.backend.set_thermal_limit(thermal_limit)
+        env.ts_manager.limits = thermal_limit
+        env._init_protection()
 
-        disco, infos, conv_ = self.backend.next_grid_state(env, is_dc=False)
+        disco, infos, conv_ = env.protection.next_grid_state()
         assert conv_ is None
         assert not infos  # check that don't simulate a cascading failure
         assert np.sum(disco >= 0) == 0
@@ -1750,9 +1752,10 @@ def test_nb_timestep_overflow_disc0(self):
             lines_flows_init[self.id_first_line_disco] / 2
         )
         thermal_limit[self.id_2nd_line_disco] = 400
-        self.backend.set_thermal_limit(thermal_limit)
+        env.ts_manager.limits = thermal_limit
+        env._init_protection()
 
-        disco, infos, conv_ = self.backend.next_grid_state(env, is_dc=False)
+        disco, infos, conv_ = env.protection.next_grid_state()
         assert conv_ is None
         assert len(infos) == 2  # check that there is a cascading failure of length 2
         assert disco[self.id_first_line_disco] >= 0
@@ -1793,9 +1796,10 @@ def test_nb_timestep_overflow_nodisc(self):
             self.lines_flows_init[self.id_first_line_disco] / 2
         )
         thermal_limit[self.id_2nd_line_disco] = 400
-        self.backend.set_thermal_limit(thermal_limit)
+        env.ts_manager.limits = thermal_limit
+        env._init_protection()
 
-        disco, infos, conv_ = self.backend.next_grid_state(env, is_dc=False)
+        disco, infos, conv_ = env.protection.next_grid_state()
         assert conv_ is None
         assert len(infos) == 1  # check that don't simulate a cascading failure
         assert disco[self.id_first_line_disco] >= 0
@@ -1836,9 +1840,10 @@ def test_nb_timestep_overflow_nodisc_2(self):
             self.lines_flows_init[self.id_first_line_disco] / 2
         )
         thermal_limit[self.id_2nd_line_disco] = 400
-        self.backend.set_thermal_limit(thermal_limit)
+        env.ts_manager.limits = thermal_limit
+        env._init_protection()
 
-        disco, infos, conv_ = self.backend.next_grid_state(env, is_dc=False)
+        disco, infos, conv_ = env.protection.next_grid_state()
         assert conv_ is None
         assert len(infos) == 1  # check that don't simulate a cascading failure
         assert disco[self.id_first_line_disco] >= 0
@@ -1879,9 +1884,10 @@ def test_nb_timestep_overflow_disc2(self):
             self.lines_flows_init[self.id_first_line_disco] / 2
         )
         thermal_limit[self.id_2nd_line_disco] = 400
-        self.backend.set_thermal_limit(thermal_limit)
+        env.ts_manager.limits = thermal_limit
+        env._init_protection()
 
-        disco, infos, conv_ = self.backend.next_grid_state(env, is_dc=False)
+        disco, infos, conv_ = env.protection.next_grid_state()
         assert conv_ is None
         assert len(infos) == 2  # check that there is a cascading failure of length 2
         assert disco[self.id_first_line_disco] >= 0