fix some issues in the tests

BDonnot · BDonnot · commit b07265792aca · 2025-04-04T15:14:16.000+02:00
Signed-off-by: DONNOT Benjamin &lt;benjamin.donnot@rte-france.com&gt;
diff --git a/grid2op/Action/_backendAction.py b/grid2op/Action/_backendAction.py
@@ -669,6 +669,14 @@ def set_redispatch(self, new_redispatching):
             This is called by the environment, do not alter.
         """
         self.prod_p.change_val(new_redispatching)
+        
+    def set_storage(self, new_storage):
+        """
+        .. warning:: /!\\\\ Internal, do not use unless you know what you are doing /!\\\\
+            
+            This is called by the environment, do not alter.
+        """
+        self.storage_power.set_val(new_storage)
 
     def _aux_iadd_inj(self, dict_injection):
         """
diff --git a/grid2op/Environment/baseEnv.py b/grid2op/Environment/baseEnv.py
@@ -3103,6 +3103,7 @@ def _aux_apply_redisp(self,
                           gen_curtailed: np.ndarray,
                           except_: List[Exception],
                           powerline_status):
+        cls = type(self)
         is_illegal_redisp = False
         is_done = False
         is_illegal_reco = False
@@ -3121,12 +3122,12 @@ def _aux_apply_redisp(self,
             action.reset_cache_topological_impact()
             action = self._action_space({})
             _ = action.get_topological_impact(powerline_status, _store_in_cache=True, _read_from_cache=False)
-            if type(self).dim_alerts:
+            if cls.dim_alerts:
                 action.raise_alert = orig_action.raise_alert
             is_illegal_redisp = True
             except_.append(except_tmp)
 
-            if type(self).n_storage > 0:
+            if cls.n_storage > 0:
                 # TODO curtailment: cancel it here too !
                 self._storage_current_charge[:] = self._storage_previous_charge
                 self._amount_storage -= self._amount_storage_prev
@@ -3155,7 +3156,7 @@ def _aux_apply_redisp(self,
             action.reset_cache_topological_impact()
             res_action = self._action_space({})
             _ = res_action.get_topological_impact(powerline_status, _store_in_cache=True, _read_from_cache=False)
-            if type(self).dim_alerts:
+            if cls.dim_alerts:
                 res_action.raise_alert = action.raise_alert
             is_illegal_redisp = True
             except_.append(except_tmp)
@@ -3179,7 +3180,7 @@ def _aux_apply_redisp(self,
             action.reset_cache_topological_impact()
             res_action = self._action_space({})
             _ = res_action.get_topological_impact(powerline_status, _store_in_cache=True, _read_from_cache=False)
-            if type(self).dim_alerts:
+            if cls.dim_alerts:
                 res_action.raise_alert = action.raise_alert
             except_.append(except_tmp)
         else:
@@ -3196,19 +3197,22 @@ def _aux_update_backend_action(self,
         # the environment must make sure it's a zero-sum action.
         # same kind of limit for the storage
         res_exc_ = None
-        # cancel the redisp tag (storage should be kept for topology)
+        # cancel the redisp and storage tags (set later in the code)
         tag_redisp = action._modif_redispatch
+        tag_storage = action._modif_storage
         action._modif_redispatch = False
+        action._modif_storage = False
         # cancel the values
-        action._redispatch[:] = 0.0  # redispatch is added in _aux_apply_redisp a bit later in the code
-        action._storage_power[:] = self._storage_power
+        action._redispatch[:] = 0.0  # redispatch is added after everything in the code (even after the opponent)
+        action._storage_power[:] = 0.0  # storage is also added after everything
         # add the action
         self._backend_action += action
         # put initial value
         action._storage_power[:] = action_storage_power
         action._redispatch[:] = init_disp
         # put back the tags
         action._modif_redispatch = tag_redisp
+        action._modif_storage = tag_storage
         return res_exc_
 
     def _update_alert_properties(self, action, lines_attacked, subs_attacked):
@@ -3689,6 +3693,7 @@ def step(self, action: BaseAction) -> Tuple[BaseObservation,
                 # TODO storage: check the original action, even when replaced by do nothing is not modified
                 self._backend_action += self._env_modification
                 self._backend_action.set_redispatch(self._actual_dispatch)
+                self._backend_action.set_storage(self._storage_power)
 
                 # now get the new generator voltage setpoint
                 voltage_control_act = self._voltage_control(action, prod_v_chronics)
diff --git a/grid2op/tests/test_detached_properly_updated.py b/grid2op/tests/test_detached_properly_updated.py
@@ -22,8 +22,12 @@ def setUp(self) -> None:
                                      test=True,
                                      allow_detachment=True,
                                      action_class=CompleteAction)
-        self.env.reset(seed=0, options={"time serie id": 0})
-        obs = self.env.reset()
+        parameters = self.env.parameters
+        parameters.ENV_DOES_REDISPATCHING = False
+        self.env.change_parameters(parameters)
+        self.env.change_forecast_parameters(parameters)
+        # values are hard coded for time serie id = 1, do not modify
+        self.obs = self.env.reset(seed=0, options={"time serie id": 1})
         return super().setUp()
     
     def tearDown(self) -> None:
@@ -38,31 +42,34 @@ def test_disco_gen(self):
                 "set_bus": {"generators_id": [(gen_id, -1)]}
             }
         ))
-        assert not done
+        assert not done, info["exception"]
+        assert not info["exception"]
         assert obs.gen_detached[gen_id]
         assert obs.gen_p[gen_id] == 0.
         assert obs.gen_v[gen_id] == 0.
         assert obs.gen_q[gen_id] == 0.
         assert obs.gen_theta[gen_id] == 0., f"{obs.gen_theta[gen_id]} vs 0."
-        assert abs(obs.gen_p_detached[gen_id] - 79.8) <= 1e-5
+        assert abs(obs.gen_p_detached[gen_id] - 79.8) <= 1e-5, f"{obs.gen_p_detached[gen_id]} vs {79.8}"
         
         obs1, _, done, info = self.env.step(self.env.action_space({}))
-        assert not done
+        assert not done, info["exception"]
+        assert not info["exception"]
         assert obs.gen_detached[gen_id]
         assert obs1.gen_p[gen_id] == 0.
         assert obs1.gen_v[gen_id] == 0.
         assert obs1.gen_q[gen_id] == 0.
         assert obs1.gen_theta[gen_id] == 0., f"{obs1.gen_theta[gen_id]} vs 0."
-        assert abs(obs1.gen_p_detached[gen_id] - 80.5) <= 1e-5
+        assert abs(obs1.gen_p_detached[gen_id] - 80.5) <= 1e-5, f"{obs.gen_p_detached[gen_id]} vs {80.5}"
         
         obs2, _, done, info = self.env.step(self.env.action_space({}))
-        assert not done
+        assert not done, info["exception"]
+        assert not info["exception"]
         assert obs.gen_detached[gen_id]
         assert obs2.gen_p[gen_id] == 0.
         assert obs2.gen_v[gen_id] == 0.
         assert obs2.gen_q[gen_id] == 0.
         assert obs2.gen_theta[gen_id] == 0., f"{obs2.gen_theta[gen_id]} vs 0."
-        assert abs(obs2.gen_p_detached[gen_id] - 80.5) <= 1e-5
+        assert abs(obs2.gen_p_detached[gen_id] - 80.5) <= 1e-5, f"{obs.gen_p_detached[gen_id]} vs {80.5}"
         
     def test_disco_load(self):
         """test i can disconnect a load"""
diff --git a/grid2op/tests/test_detached_simulate.py b/grid2op/tests/test_detached_simulate.py
@@ -6,9 +6,8 @@
 # SPDX-License-Identifier: MPL-2.0
 # This file is part of Grid2Op, Grid2Op a testbed platform to model sequential decision making in power systems.
 
-import copy
+
 import grid2op
-from grid2op.Agent import BaseAgent
 from grid2op.Action import CompleteAction
 from grid2op.Chronics import ChangeNothing
 import unittest
@@ -29,12 +28,14 @@ def setUp(self):
                                     chronics_class=ChangeNothing,
                                     data_feeding_kwargs={"h_forecast": [5, 10, 15, 20, 25, 30]},
                                     )
-        paramerters = self.env.parameters
-        paramerters.MAX_SUB_CHANGED = 99999
-        paramerters.MAX_LINE_STATUS_CHANGED = 99999
-        paramerters.NB_TIMESTEP_COOLDOWN_LINE = 0
-        paramerters.NB_TIMESTEP_COOLDOWN_SUB = 0
-        self.env.change_parameters(paramerters)
+        parameters = self.env.parameters
+        parameters.MAX_SUB_CHANGED = 99999
+        parameters.MAX_LINE_STATUS_CHANGED = 99999
+        parameters.NB_TIMESTEP_COOLDOWN_LINE = 0
+        parameters.NB_TIMESTEP_COOLDOWN_SUB = 0
+        parameters.ENV_DOES_REDISPATCHING = False
+        self.env.change_parameters(parameters)
+        self.env.change_forecast_parameters(parameters)
         self.init_obs = self.env.reset(seed=0, options={"time serie id": 0})
         
     def tearDown(self):
@@ -48,71 +49,71 @@ def test_detach_gen(self, tol=1e-5):
         act_deco = self.env.action_space({"set_bus": {"generators_id": [(gen_id, -1)]}})
         act_reco = self.env.action_space({"set_bus": {"generators_id": [(gen_id, +1)]}})
         next_obs, reward, done, info = self.env.step(act_deco)
-        assert not done
-        assert len(info["exception"]) == 0
+        assert not done, info["exception"]
+        assert len(info["exception"]) == 0, info["exception"]
         assert next_obs.gen_detached[gen_id]
         assert next_obs.gen_v[gen_id] == 0.
         assert next_obs.gen_p[gen_id] == 0.
         
         # test simulate
         next_obs_sim00, reward, done, info = next_obs.simulate(self.env.action_space())
-        assert not done
-        assert len(info["exception"]) == 0
+        assert not done, info["exception"]
+        assert len(info["exception"]) == 0, info["exception"]
         assert next_obs_sim00.gen_detached[gen_id]
         assert next_obs_sim00.gen_v[gen_id] == 0.
         assert next_obs_sim00.gen_p[gen_id] == 0.
         next_obs_sim0, reward, done, info = next_obs.simulate(act_reco)
-        assert not done
-        assert len(info["exception"]) == 0
+        assert not done, info["exception"]
+        assert len(info["exception"]) == 0, info["exception"]
         assert not next_obs_sim0.gen_detached[gen_id]
         assert np.abs(next_obs_sim0.gen_v[gen_id] - normal_v[gen_id]) <= tol, f"error {np.abs(next_obs_sim0.gen_v[gen_id] - normal_v[gen_id]).max()}"
         assert np.abs(next_obs_sim0.gen_p[gen_id] - normal_p[gen_id]) <= tol, f"error {np.abs(next_obs_sim0.gen_p[gen_id] - normal_p[gen_id]).max()}"
         next_obs_sim1, reward, done, info = next_obs.simulate(act_deco)
-        assert not done
-        assert len(info["exception"]) == 0
+        assert not done, info["exception"]
+        assert len(info["exception"]) == 0, info["exception"]
         assert next_obs_sim1.gen_detached[gen_id]
         assert next_obs_sim1.gen_v[gen_id] == 0.
         assert next_obs_sim1.gen_p[gen_id] == 0.
         next_obs_sim2, reward, done, info = next_obs.simulate(self.env.action_space())
-        assert not done
-        assert len(info["exception"]) == 0
+        assert not done, info["exception"]
+        assert len(info["exception"]) == 0, info["exception"]
         assert next_obs_sim2.gen_detached[gen_id]
         assert next_obs_sim2.gen_v[gen_id] == 0.
         assert next_obs_sim2.gen_p[gen_id] == 0.
         next_obs_sim3, reward, done, info = next_obs.simulate(act_reco)
-        assert not done
-        assert len(info["exception"]) == 0
+        assert not done, info["exception"]
+        assert len(info["exception"]) == 0, info["exception"]
         assert not next_obs_sim3.gen_detached[gen_id]
         assert np.abs(next_obs_sim3.gen_v[gen_id] - normal_v[gen_id]) <= tol, f"error {np.abs(next_obs_sim3.gen_v[gen_id] - normal_v[gen_id]).max()}"
         assert np.abs(next_obs_sim3.gen_p[gen_id] - normal_p[gen_id]) <= tol, f"error {np.abs(next_obs_sim3.gen_p[gen_id] - normal_p[gen_id]).max()}"
         # now change the setpoint
         next_obs_sim4, reward, done, info = next_obs.simulate(act_reco + self.env.action_space({"injection": {"prod_v": normal_v * 1.01}}))
-        assert not done
-        assert len(info["exception"]) == 0
+        assert not done, info["exception"]
+        assert len(info["exception"]) == 0, info["exception"]
         assert not next_obs_sim4.gen_detached[gen_id]
         assert np.abs(next_obs_sim4.gen_v[gen_id] - 1.01 * normal_v[gen_id]) <= tol, f"error {np.abs(next_obs_sim4.gen_v[gen_id] - 1.01 * normal_v[gen_id]).max()}"
         assert np.abs(next_obs_sim4.gen_p[gen_id] - normal_p[gen_id]) <= tol, f"error {np.abs(next_obs_sim4.gen_p[gen_id] - normal_p[gen_id]).max()}"
         # disco
         next_obs_sim5, reward, done, info = next_obs.simulate(act_deco)
-        assert not done
-        assert len(info["exception"]) == 0
+        assert not done, info["exception"]
+        assert len(info["exception"]) == 0, info["exception"]
         assert next_obs_sim5.gen_detached[gen_id]
         assert next_obs_sim5.gen_v[gen_id] == 0.
         assert next_obs_sim5.gen_p[gen_id] == 0.
         
         # reco again (and check the setpoint is not the last one used in obs.simulate but is the one of the observation)
         next_obs_sim6, reward, done, info = next_obs.simulate(act_reco)
-        assert not done
-        assert len(info["exception"]) == 0
+        assert not done, info["exception"]
+        assert len(info["exception"]) == 0, info["exception"]
         assert not next_obs_sim6.gen_detached[gen_id]
         assert np.abs(next_obs_sim6.gen_v[gen_id] - normal_v[gen_id]) <= tol, f"error {np.abs(next_obs_sim6.gen_v[gen_id] - normal_v[gen_id]).max()}"
         assert np.abs(next_obs_sim6.gen_p[gen_id] - normal_p[gen_id]) <= tol, f"error {np.abs(next_obs_sim6.gen_p[gen_id] - normal_p[gen_id]).max()}"
         
         
         # test step
         next_next_obs, reward, done, info = self.env.step(act_reco)
-        assert not done
-        assert len(info["exception"]) == 0
+        assert not done, info["exception"]
+        assert len(info["exception"]) == 0, info["exception"]
         assert not next_next_obs.gen_detached[gen_id]
         assert np.abs(next_next_obs.gen_v[gen_id] - normal_v[gen_id]) <= tol, f"error {np.abs(next_next_obs.gen_v[gen_id] - normal_v[gen_id]).max()}"
         assert np.abs(next_next_obs.gen_p[gen_id] - normal_p[gen_id]) <= tol, f"error {np.abs(next_next_obs.gen_p[gen_id] - normal_p[gen_id]).max()}"
