fix some bugs introduced when no detachment was allowed

Signed-off-by: DONNOT Benjamin <[email protected]>

Author: BDonnot

CHANGELOG.rst

@@ -135,6 +135,8 @@ Native multi agents support:
   `can_handle_XXX` functions (*eg* `can_handle_more_than_2_busbar()` or `can_handle_detachment()`)
 - [FIXED] an issue with `obs.get_forecast_env` with changeNothing and DoNothingHandler time series
 - [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)
 - [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(...)` 

grid2op/Action/_backendAction.py

@@ -881,6 +881,9 @@ def _assign_0_to_disco_el(self) -> None:
         Do not consider disconnected elements are modified for there active / reactive / voltage values
         """
         cls = type(self)
+        if not cls.detachment_is_allowed:
+            # is detachment is not allowed, this should not happen
+            return
         gen_changed = self.current_topo.changed[cls.gen_pos_topo_vect]
         gen_bus = self.current_topo.values[cls.gen_pos_topo_vect]
         self.prod_p.force_unchanged(gen_changed, gen_bus)

grid2op/Backend/pandaPowerBackend.py

@@ -867,7 +867,7 @@ def apply_action(self, backendAction: Union["grid2op.Action._backendAction._Back
             topo__,
             shunts__,
         ) = backendAction()
-
+        
         # handle bus status
         self._grid.bus["in_service"] = pd.Series(data=active_bus.T.reshape(-1),
                                                  index=np.arange(cls.n_sub * cls.n_busbar_per_sub),
@@ -1543,7 +1543,7 @@ def storages_info(self) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
         )
 
     def _storages_info(self):
-        if self.n_storage:
+        if self.n_storage > 0:
             # this is because we support "backward comaptibility" feature. So the storage can be
             # deactivated from the Environment...
             # p_storage = self._grid.res_storage["p_mw"].values.astype(dt_float)

grid2op/Environment/baseEnv.py

@@ -4132,7 +4132,7 @@ def fast_forward_chronics(self, nb_timestep, init_dt=None):
             raise EnvError("This environment is not intialized. "
                            "Have you called `env.reset()` after last game over ?")
         nb_timestep = int(nb_timestep)
-
+        
         # Go to the timestep requested minus one
         nb_timestep = max(1, nb_timestep - 1)
         self.chronics_handler.fast_forward(nb_timestep)

grid2op/Environment/environment.py

@@ -94,7 +94,7 @@ def __init__(
         rewardClass=FlatReward,
         legalActClass=AlwaysLegal,
         voltagecontrolerClass=ControlVoltageFromFile,
-        other_rewards={},
+        other_rewards=None,
         thermal_limit_a=None,
         with_forecast=True,
         epsilon_poly=1e-4,  # precision of the redispatching algorithm we don't recommend to go above 1e-4
@@ -107,9 +107,9 @@ def __init__(
         opponent_budget_class=NeverAttackBudget,
         opponent_attack_duration=0,
         opponent_attack_cooldown=99999,
-        kwargs_opponent={},
+        kwargs_opponent=None,
         attention_budget_cls=LinearAttentionBudget,
-        kwargs_attention_budget={},
+        kwargs_attention_budget=None,
         has_attention_budget=False,
         logger=None,
         kwargs_observation=None,
@@ -126,6 +126,15 @@ def __init__(
         _local_dir_cls=None,  # only set at the first call to `make(...)` after should be false
         _overload_name_multimix=None,
     ):
+        if other_rewards is None:
+            other_rewards = {}
+            
+        if kwargs_opponent is None:
+             kwargs_opponent = {}
+        
+        if kwargs_attention_budget is None:
+            kwargs_attention_budget = {}
+            
         BaseEnv.__init__(
             self,
             init_env_path=init_env_path,

grid2op/Observation/baseObservation.py

@@ -653,9 +653,9 @@ def __init__(self,
         self.gen_p_delta = np.empty(shape=cls.n_gen, dtype=dt_float)
 
         # detachment (>= 1.11.0)
-        self.load_detached = np.ones(shape=cls.n_load, dtype=dt_bool)
-        self.gen_detached = np.ones(shape=cls.n_gen, dtype=dt_bool)
-        self.storage_detached = np.ones(shape=cls.n_storage, dtype=dt_bool)
+        self.load_detached = np.zeros(shape=cls.n_load, dtype=dt_bool)
+        self.gen_detached = np.zeros(shape=cls.n_gen, dtype=dt_bool)
+        self.storage_detached = np.zeros(shape=cls.n_storage, dtype=dt_bool)
         self.load_p_detached = np.zeros(shape=cls.n_load, dtype=dt_float)
         self.load_q_detached = np.zeros(shape=cls.n_load, dtype=dt_float)
         self.gen_p_detached = np.zeros(shape=cls.n_gen, dtype=dt_float)
@@ -677,6 +677,7 @@ def _aux_copy(self, other : Self) -> None:
             "year",
             "delta_time",
             "_is_done",
+            "_prev_conn"
         ]
 
         attr_vect = [

grid2op/tests/test_shedding.py

@@ -432,7 +432,63 @@ def test_shedding_load_step(self):
         assert np.abs(self.env._delta_gen_p.sum() / self.env._gen_activeprod_t.sum()) <= 0.02  # less than 2% losses
 
 
+class TestSheddingActionsNoShedding(unittest.TestCase):
+    def setUp(self) -> None:
+        super().setUp()
+        p = Parameters()
+        p.MAX_SUB_CHANGED = 999999
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore")
+            self.env = grid2op.make("educ_case14_storage",
+                                    param=p,
+                                    action_class=CompleteAction,
+                                    allow_detachment=False,
+                                    test=True,
+                                    _add_to_name=type(self).__name__)
+        obs = self.env.reset(seed=0, options={"time serie id": 0}) # Reproducibility
+        
+    def tearDown(self) -> None:
+        self.env.close()
+        super().tearDown()        
+        
+    def test_load(self):
+        obs = self.env.reset()
+        assert not type(self.env).detachment_is_allowed
+        assert (~obs.load_detached).all()
+        
+        with self.assertRaises(UserWarning):
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
+                self.env.action_space({"detach_load": 0})
+        
+        obs, reward, done, info = self.env.step(self.env.action_space({"set_bus": {"loads_id": [(0, -1)]}}))
+        assert done
+        
+    def test_gen(self):
+        obs = self.env.reset()
+        assert not type(self.env).detachment_is_allowed
+        assert (~obs.gen_detached).all()
+        
+        with self.assertRaises(UserWarning):
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
+                self.env.action_space({"detach_gen": 0})
+        
+        obs, reward, done, info = self.env.step(self.env.action_space({"set_bus": {"generators_id": [(0, -1)]}}))
+        assert done
+        
+    def test_storage(self):
+        obs = self.env.reset()
+        assert not type(self.env).detachment_is_allowed
+        assert (~obs.storage_detached).all()
+        
+        with self.assertRaises(UserWarning):
+            with warnings.catch_warnings():
+                warnings.filterwarnings("error")
+                self.env.action_space({"detach_storage": 0})
 
+        obs, reward, done, info = self.env.step(self.env.action_space({"set_bus": {"storages_id": [(0, -1)]}, "set_storage": [(0, 1.)]}))
+        assert done
 
 
 # TODO with the env parameters STOP_EP_IF_GEN_BREAK_CONSTRAINTS and ENV_DOES_REDISPATCHING

grid2op/tests/test_ts_handlers.py

@@ -511,18 +511,18 @@ def tearDown(self) -> None:
         self.env.close()
         return super().tearDown()  
 
-    def _aux_test_obs(self, obs, max_it=12):
-        assert len(obs._forecasted_inj) == 13 # 12 + 1
+    def _aux_test_obs(self, obs, max_it=12, tol=1e-5):
+        assert len(obs._forecasted_inj) == max_it + 1 # 12 + 1
         init_obj = obs._forecasted_inj[0]
-        for el in obs._forecasted_inj:
+        for for_h, el in enumerate(obs._forecasted_inj):
             for k_ in ["load_p", "load_q"]:
-                assert np.all(el[1]["injection"][k_] == init_obj[1]["injection"][k_])
+                assert np.abs(el[1]["injection"][k_] - init_obj[1]["injection"][k_]).max() <= tol, f'iter {for_h} : {el[1]["injection"][k_]} vs {init_obj[1]["injection"][k_]}'
             k_ = "prod_p"  # because of slack...
             assert np.all(el[1]["injection"][k_][:-1] == init_obj[1]["injection"][k_][:-1]) 
 
-        obs.simulate(self.env.action_space(), 12)
+        obs.simulate(self.env.action_space(), max_it)
         with self.assertRaises(NoForecastAvailable):
-            obs.simulate(self.env.action_space(), 13)
+            obs.simulate(self.env.action_space(), max_it + 1)
 
     def test_step(self):
         obs = self.env.reset()