LightSim2Grid 0.9.2.post1__tar.gz → 0.10.0__tar.gz

{lightsim2grid-0.9.2.post1 → lightsim2grid-0.10.0/LightSim2Grid.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: LightSim2Grid
-Version: 0.9.2.post1
+Version: 0.10.0
 Summary: LightSim2Grid implements a c++ backend targeting the Grid2Op platform.
 Home-page: https://github.com/grid2op/lightsim2grid/
 Author: Benjamin Donnot
@@ -147,6 +147,7 @@ Pypi packages are available for linux (`x86_64` cpu architecture), windows (`x86
 - 3.10 (lightsim2grid >= 0.6.1)
 - 3.11 (lightsim2grid >= 0.7.1)
 - 3.12 (lightsim2grid >= 0.7.5)
+- 3.13 (lightsim2grid >= 0.9.2.post2)
 
 
 As from version 0.8.2, we also distribute windows `arm64` and macos `arm64` binaries of lightsim2grid that can be installed

{lightsim2grid-0.9.2.post1/LightSim2Grid.egg-info → lightsim2grid-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: LightSim2Grid
-Version: 0.9.2.post1
+Version: 0.10.0
 Summary: LightSim2Grid implements a c++ backend targeting the Grid2Op platform.
 Home-page: https://github.com/grid2op/lightsim2grid/
 Author: Benjamin Donnot
@@ -147,6 +147,7 @@ Pypi packages are available for linux (`x86_64` cpu architecture), windows (`x86
 - 3.10 (lightsim2grid >= 0.6.1)
 - 3.11 (lightsim2grid >= 0.7.1)
 - 3.12 (lightsim2grid >= 0.7.5)
+- 3.13 (lightsim2grid >= 0.9.2.post2)
 
 
 As from version 0.8.2, we also distribute windows `arm64` and macos `arm64` binaries of lightsim2grid that can be installed

{lightsim2grid-0.9.2.post1 → lightsim2grid-0.10.0}/README.md

@@ -88,6 +88,7 @@ Pypi packages are available for linux (`x86_64` cpu architecture), windows (`x86
 - 3.10 (lightsim2grid >= 0.6.1)
 - 3.11 (lightsim2grid >= 0.7.1)
 - 3.12 (lightsim2grid >= 0.7.5)
+- 3.13 (lightsim2grid >= 0.9.2.post2)
 
 
 As from version 0.8.2, we also distribute windows `arm64` and macos `arm64` binaries of lightsim2grid that can be installed

{lightsim2grid-0.9.2.post1 → lightsim2grid-0.10.0}/lightsim2grid/__init__.py

@@ -6,7 +6,7 @@
 # SPDX-License-Identifier: MPL-2.0
 # This file is part of LightSim2grid, LightSim2grid implements a c++ backend targeting the Grid2Op platform.
 
-__version__ = "0.9.2.post1"
+__version__ = "0.10.0"
 
 __all__ = ["newtonpf", "SolverType", "ErrorType", "solver", "compilation_options"]
 

{lightsim2grid-0.9.2.post1 → lightsim2grid-0.10.0}/lightsim2grid/lightSimBackend.py

@@ -36,6 +36,12 @@ try:
 except ImportError:
     # for backward compatibility with grid2op <= 1.9.8
     DEFAULT_N_BUSBAR_PER_SUB = 2
+
+try:
+    from grid2op.Space import DEFAULT_ALLOW_DETACHMENT
+except ImportError:
+    # for backward compatibility with grid2op < 1.11.0
+    DEFAULT_ALLOW_DETACHMENT = False
     
 try:
     from typing import Literal
@@ -61,6 +67,9 @@ class LightSimBackend(Backend):
         # for legacy grid2op
         n_busbar_per_sub = DEFAULT_N_BUSBAR_PER_SUB
         
+    if not hasattr(Backend, "detachment_is_allowed"):
+        # for legacy grid2op (< 1.11.0)
+        detachment_is_allowed = DEFAULT_ALLOW_DETACHMENT
         
     def __init__(self,
                  detailed_infos_for_cascading_failures: bool=False,
@@ -73,8 +82,9 @@ class LightSimBackend(Backend):
                  use_static_gen: bool=False, # add the static generators as generator gri2dop side
                  loader_method: Literal["pandapower", "pypowsybl"] = "pandapower",
                  loader_kwargs : Optional[dict] = None,
-                 stop_if_load_disco : Optional[bool] = True,
-                 stop_if_gen_disco : Optional[bool] = True,
+                 stop_if_load_disco : Optional[bool] = None,
+                 stop_if_gen_disco : Optional[bool] = None,
+                 stop_if_storage_disco : Optional[bool] = None,
                  ):
         #: ``int`` maximum number of iteration allowed for the solver
         #: if the solver has not converge after this, it will 
@@ -131,13 +141,32 @@ class LightSimBackend(Backend):
         #:
         #: if set to ``True`` (default) then the backend will raise a 
         #: BackendError in case of disconnected load
+        #:
+        #: .. note:: When using grid2op >= 1.11.0 and lightsim2grid >= 0.10.0 this 
+        #:    is automatically set-up with the call to grid2op.make, 
+        #:    to match the behaviour expected by `allow_detachment`
         self._stop_if_load_disco = stop_if_load_disco
         
         #: .. versionadded:: 0.8.0
         #:
         #: if set to ``True`` (default) then the backend will raise a 
         #: BackendError in case of disconnected generator
+        #:
+        #: .. note:: When using grid2op >= 1.11.0 and lightsim2grid >= 0.10.0 this 
+        #:    is automatically set-up with the call to grid2op.make, 
+        #:    to match the behaviour expected by `allow_detachment`
         self._stop_if_gen_disco = stop_if_gen_disco
+        
+        #: .. versionadded:: 0.10.0
+        #:
+        #: if set to ``True`` (default) then the backend will raise a 
+        #: BackendError in case of disconnected storage that are 
+        #: asked to produce / absorb something
+        #:
+        #: .. note:: When using grid2op >= 1.11.0 and lightsim2grid >= 0.10.0 this 
+        #:    is automatically set-up with the call to grid2op.make, 
+        #:    to match the behaviour expected by `allow_detachment`
+        self._stop_if_storage_disco = stop_if_storage_disco
                                         
         self._aux_init_super(detailed_infos_for_cascading_failures,
                              can_be_copied,
@@ -150,12 +179,16 @@ class LightSimBackend(Backend):
                              loader_method,
                              loader_kwargs,
                              stop_if_load_disco,
-                             stop_if_gen_disco)
+                             stop_if_gen_disco,
+                             stop_if_storage_disco)
         
         # backward compat: need to define it if not done by grid2op
         if not hasattr(self, "_can_be_copied"):
             self._can_be_copied = can_be_copied
 
+        #: I can output the voltage angle
+        self.can_output_theta = True
+        
         #: .. versionadded:: 0.8.0
         #:
         #: Which type of grid format can be read by your backend.
@@ -295,6 +328,13 @@ class LightSimBackend(Backend):
         # backend SHOULD not do these kind of stuff
         self._idx_hack_storage = []
         
+        #: ..versionadded: 0.9.3
+        #: sometimes some actions will make the grid fails
+        #: but grid2op expect it to fail not on "apply_action"
+        #: but rather when calling `runpf`
+        #: this flags remembers it
+        self._next_pf_fails : Optional[BackendError] = None
+        
         # speed optimization
         self._lineor_res = None
         self._lineex_res = None
@@ -320,7 +360,8 @@ class LightSimBackend(Backend):
                         loader_method,
                         loader_kwargs,
                         stop_if_load_disco,
-                        stop_if_gen_disco):
+                        stop_if_gen_disco,
+                        stop_if_storage_disco):
         try:
             # for grid2Op >= 1.7.1
             Backend.__init__(self,
@@ -336,6 +377,7 @@ class LightSimBackend(Backend):
                              loader_kwargs=loader_kwargs,
                              stop_if_load_disco=stop_if_load_disco,
                              stop_if_gen_disco=stop_if_gen_disco,
+                             stop_if_storage_disco=stop_if_storage_disco
                              )
         except TypeError as exc_:
             warnings.warn("Please use grid2op >= 1.7.1: with older grid2op versions, "
@@ -347,6 +389,10 @@ class LightSimBackend(Backend):
             # do not forget to propagate this if needed
             self.can_handle_more_than_2_busbar()
             
+        if hasattr(type(self), "can_handle_detachment"):
+            # do not forget to propagate this if needed
+            self.can_handle_detachment()
+            
     def turnedoff_no_pv(self):
         self._turned_off_pv = False
         self._grid.turnedoff_no_pv()
@@ -513,7 +559,9 @@ class LightSimBackend(Backend):
             self._grid.turnedoff_no_pv()
     
     def _assign_right_solver(self):
-        has_single_slack = np.where(np.array([el.slack_weight for el in self._grid.get_generators()]) != 0.)[0].shape[0] == 1
+        slack_weights = np.array([el.slack_weight for el in self._grid.get_generators()])
+        nb_slack_nonzero = (np.abs(slack_weights) > 0.).sum()
+        has_single_slack = nb_slack_nonzero == 1
         if has_single_slack and not self._dist_slack_non_renew:
             if SolverType.KLUSingleSlack in self.available_solvers:
                 # use the faster KLU if available
@@ -527,14 +575,96 @@ class LightSimBackend(Backend):
                 self._grid.change_solver(SolverType.KLU)
             else:
                 self._grid.change_solver(SolverType.SparseLU)
+    
+    def _aux_set_correct_detach_flags_d_allowed(self):
+        # user allowed detachment, I check the correct flags
+        if self._stop_if_gen_disco is None:
+            # user did not specify anything
+            self._stop_if_gen_disco = False
+        elif not self._stop_if_gen_disco:
+            # force conversion to proper type
+            self._stop_if_gen_disco = False
+        elif self._stop_if_gen_disco:
+            # erase default values and continue like the grid2op call specifies
+            warnings.warn("Call to `grid2op.make(..., allow_detachement=True)` will erase the lightsim2grid kwargs `stop_if_gen_disco=True`")
+            self._stop_if_gen_disco = False
+            
+        if self._stop_if_load_disco is None:
+            # user did not specify anything
+            self._stop_if_load_disco = False
+        elif not self._stop_if_load_disco:
+            # force conversion to the proper type
+            self._stop_if_load_disco = False
+        elif self._stop_if_load_disco:
+            # erase default values and continue like the grid2op call specifies
+            warnings.warn("Call to `grid2op.make(..., allow_detachement=True)` will erase the lightsim2grid kwargs `stop_if_load_disco=True`")
+            self._stop_if_load_disco = False
+            
+        if self._stop_if_storage_disco is None:
+            # user did not specify anything
+            self._stop_if_storage_disco = False
+        elif not self._stop_if_storage_disco:
+            # force conversion to the proper type
+            self._stop_if_storage_disco = False
+        elif self._stop_if_storage_disco:
+            # erase default values and continue like the grid2op call specifies
+            warnings.warn("Call to `grid2op.make(..., allow_detachement=True)` will erase the lightsim2grid kwargs `stop_if_storage_disco=True`")
+            self._stop_if_storage_disco = False
+    
+    def _aux_set_correct_detach_flags_d_not_allowed(self):# user did not allow detachment (or it's a legacy grid2op version), I check the correct flags
+        if self._stop_if_gen_disco is None:
+            # user did not specify anything
+            self._stop_if_gen_disco = True
+        elif self._stop_if_gen_disco:
+            # force conversion to proper type
+            self._stop_if_gen_disco = True
+        elif not self._stop_if_gen_disco:
+            # erase default values and continue like the grid2op call specifies
+            warnings.warn("Call to `grid2op.make(..., allow_detachement=False)` will erase the lightsim2grid kwargs `stop_if_gen_disco=False`")
+            self._stop_if_gen_disco = True
+            
+        if self._stop_if_load_disco is None:
+            # user did not specify anything
+            self._stop_if_load_disco = True
+        elif self._stop_if_load_disco:
+            # force conversion to proper type
+            self._stop_if_load_disco = True
+        elif not self._stop_if_load_disco:
+            # erase default values and continue like the grid2op call specifies
+            warnings.warn("Call to `grid2op.make(..., allow_detachement=False)` will erase the lightsim2grid kwargs `stop_if_load_disco=False`")
+            self._stop_if_load_disco = True
+            
+        if self._stop_if_storage_disco is None:
+            # user did not specify anything
+            self._stop_if_storage_disco = True
+        elif self._stop_if_storage_disco:
+            # force conversion to proper type
+            self._stop_if_storage_disco = True
+        elif not self._stop_if_storage_disco:
+            # erase default values and continue like the grid2op call specifies
+            warnings.warn("Call to `grid2op.make(..., allow_detachement=False)` will erase the lightsim2grid kwargs `stop_if_storage_disco=False`")
+            self._stop_if_storage_disco = True
                 
+    def _aux_set_correct_detach_flags(self):
+        if self.detachment_is_allowed:
+            self._aux_set_correct_detach_flags_d_allowed()
+        else:
+            self._aux_set_correct_detach_flags_d_not_allowed()
+        
     def load_grid(self,
                   path : Union[os.PathLike, str],
                   filename : Optional[Union[os.PathLike, str]]=None) -> None: 
-        if hasattr(type(self), "can_handle_more_than_2_busbar"):
+        cls = type(self)
+        if hasattr(cls, "can_handle_more_than_2_busbar"):
             # grid2op version >= 1.10.0 then we use this
             self.can_handle_more_than_2_busbar()
-        
+            
+        if hasattr(cls, "can_handle_detachment"):
+            # grid2op version >= 1.11.0 then we use this
+            self.can_handle_detachment()
+            
+        self._aux_set_correct_detach_flags()
+            
         if self._loader_method == "pandapower":
             self._load_grid_pandapower(path, filename)
         elif self._loader_method == "pypowsybl":
@@ -543,6 +673,7 @@ class LightSimBackend(Backend):
             raise BackendError(f"Impossible to initialize the backend with '{self._loader_method}'")
         self._grid.tell_solver_need_reset()
         self._reset_res_pointers()  # force the re reading of the accessors at next powerflow
+        self.V = np.ones(self.nb_bus_total, dtype=np.complex_)
     
     def _should_not_have_to_do_this(self, path=None, filename=None):
         # included in grid2op now !
@@ -836,7 +967,6 @@ class LightSimBackend(Backend):
         self._aux_init_pandapower()
     
     def _aux_init_pandapower(self):
-        self.can_output_theta = True  # i can compute the "theta" and output it to grid2op
         from lightsim2grid.gridmodel import init_from_pandapower
         self._grid = init_from_pandapower(self.init_pp_backend._grid)    
         self.__nb_bus_before = self.init_pp_backend.get_nb_active_bus()  
@@ -1146,6 +1276,7 @@ class LightSimBackend(Backend):
         Specific implementation of the method to apply an action modifying a powergrid in the pandapower format.
         """
         tick = time.perf_counter()
+        self._next_pf_fails = None
         active_bus, *_, topo__, shunts__ = backendAction()
 
         # change the overall topology
@@ -1176,7 +1307,11 @@ class LightSimBackend(Backend):
                                              backendAction.storage_power.values)
             except RuntimeError as exc_:
                 # modification of power of disconnected storage has no effect in lightsim2grid
-                pass
+                if self.detachment_is_allowed:
+                    # a storage units is allowed to be disconnected in this case
+                    pass
+                else:
+                    self._next_pf_fails = BackendError("Some storage units would be disconnected")
 
         # handle shunts
         if type(self).shunts_data_available:
@@ -1229,7 +1364,10 @@ class LightSimBackend(Backend):
     def runpf(self, is_dc : bool=False) -> Tuple[bool, Union[Exception, None]]:
         my_exc_ = None
         res = False
-        try:
+        try:            
+            if self._next_pf_fails is not None:
+                raise self._next_pf_fails
+            
             beg_preproc = time.perf_counter()
             if is_dc:
                 # somehow, when asked to do a powerflow in DC, pandapower assign Vm to be
@@ -1329,20 +1467,31 @@ class LightSimBackend(Backend):
             self.next_prod_p[:] = self.prod_p
             if self._stop_if_load_disco and ((~np.isfinite(self.load_v)).any() or (self.load_v <= 0.).any()):
                 disco = (~np.isfinite(self.load_v)) | (self.load_v <= 0.)
-                load_disco = np.where(disco)[0]
+                load_disco = disco.nonzero()[0]
                 self._timer_postproc += time.perf_counter() - beg_postroc
                 raise BackendError(f"At least one load is disconnected (check loads {load_disco})")
             if self._stop_if_gen_disco and ((~np.isfinite(self.prod_v)).any() or (self.prod_v <= 0.).any()):
                 disco = (~np.isfinite(self.prod_v)) | (self.prod_v <= 0.)
-                gen_disco = np.where(disco)[0]
+                gen_disco = disco.nonzero()[0]
                 self._timer_postproc += time.perf_counter() - beg_postroc
                 raise BackendError(f"At least one generator is disconnected (check gen {gen_disco})")
+            
+            if self.__has_storage:
+                sto_active = (np.abs(self.storage_p) > 0.)
+                sto_act_disco = (((~np.isfinite(self.storage_v)) & sto_active).any() or 
+                                 ((self.storage_v <= 0.) & sto_active).any()
+                                )
+                if self._stop_if_storage_disco and sto_act_disco:
+                    disco = ((~np.isfinite(self.storage_v)) | (self.storage_v <= 0.)) & sto_active
+                    sto_disco = disco.nonzero()[0]
+                    self._timer_postproc += time.perf_counter() - beg_postroc
+                    raise BackendError(f"At least one storage unit is disconnected (check gen {sto_disco})")
             # TODO storage case of divergence !
 
             if type(self).shunts_data_available:
                 self._set_shunt_info()
 
-            if (self.line_or_theta >= 1e6).any() or (self.line_ex_theta >= 1e6).any():
+            if (np.abs(self.line_or_theta) >= 1e6).any() or (np.abs(self.line_ex_theta) >= 1e6).any():
                 raise BackendError(f"Some theta are above 1e6 which should not be happening !")
             res = True
             self._grid.unset_changes()
@@ -1367,6 +1516,7 @@ class LightSimBackend(Backend):
 
     def _fill_nans(self):
         """fill the results vectors with nans"""
+        self._next_pf_fails = None
         self.p_or[:] = np.NaN
         self.q_or[:] = np.NaN
         self.v_or[:] = np.NaN
@@ -1447,7 +1597,8 @@ class LightSimBackend(Backend):
                             self._loader_method,
                             self._loader_kwargs,
                             self._stop_if_load_disco,
-                            self._stop_if_gen_disco)
+                            self._stop_if_gen_disco,
+                            self._stop_if_storage_disco)
         
         # for backward compat (attribute was not necessarily present in early grid2op)
         if not hasattr(res, "_can_be_copied"):
@@ -1471,8 +1622,8 @@ class LightSimBackend(Backend):
                            "supported_grid_format", 
                            "max_it", "tol", "_turned_off_pv", "_dist_slack_non_renew",
                            "_use_static_gen", "_loader_method", "_loader_kwargs",
-                           "_stop_if_load_disco", "_stop_if_gen_disco",
-                           "_timer_fetch_data_cpp"
+                           "_stop_if_load_disco", "_stop_if_gen_disco", "_stop_if_storage_disco",
+                           "_timer_fetch_data_cpp", "_next_pf_fails"
                            ]
         for attr_nm in li_regular_attr:
             if hasattr(self, attr_nm):

{lightsim2grid-0.9.2.post1 → lightsim2grid-0.10.0}/setup.py

@@ -14,7 +14,7 @@ import warnings
 from pybind11.setup_helpers import Pybind11Extension, build_ext
 
 
-__version__ = "0.9.2.post1"
+__version__ = "0.10.0"
 KLU_SOLVER_AVAILABLE = False
 
 # Try to link against SuiteSparse (if available)

{lightsim2grid-0.9.2.post1 → lightsim2grid-0.10.0}/src/GridModel.h

@@ -494,9 +494,9 @@ class GridModel : public GenericContainer
 //                reactivate_storage(storage_id);  // requirement from grid2op, might be discussed
 //                storages_.change_p(storage_id, new_p, need_reset_);
 //            }
-               storages_.change_p(storage_id, new_p, solver_control_);
+               storages_.change_p_nothrow(storage_id, new_p, solver_control_);
             }
-        void change_q_storage(int storage_id, real_type new_q) {storages_.change_q(storage_id, new_q, solver_control_); }
+        void change_q_storage(int storage_id, real_type new_q) {storages_.change_q_nothrow(storage_id, new_q, solver_control_); }
         int get_bus_storage(int storage_id) {return storages_.get_bus(storage_id);}
 
         //deactivate a powerline (disconnect it)

{lightsim2grid-0.9.2.post1 → lightsim2grid-0.10.0}/src/element_container/LoadContainer.cpp

@@ -117,10 +117,7 @@ void LoadContainer::change_p(int load_id, real_type new_p, SolverControl & solve
         exc_ << ")";
         throw std::runtime_error(exc_.str());
     }
-    if (p_mw_(load_id) != new_p) {
-        solver_control.tell_recompute_sbus();
-        p_mw_(load_id) = new_p;
-    }
+    change_p_nothrow(load_id, new_p, solver_control);
 }
 
 void LoadContainer::change_q(int load_id, real_type new_q, SolverControl & solver_control)
@@ -134,10 +131,7 @@ void LoadContainer::change_q(int load_id, real_type new_q, SolverControl & solve
         exc_ << ")";
         throw std::runtime_error(exc_.str());
     }
-    if (q_mvar_(load_id) != new_q) {
-        solver_control.tell_recompute_sbus();
-        q_mvar_(load_id) = new_q;
-    }
+    change_q_nothrow(load_id, new_q, solver_control);
 }
 
 void LoadContainer::reconnect_connected_buses(std::vector<bool> & bus_status) const {

{lightsim2grid-0.9.2.post1 → lightsim2grid-0.10.0}/src/element_container/LoadContainer.h

@@ -153,7 +153,21 @@ class LoadContainer : public GenericContainer
     void change_bus(int load_id, int new_bus_id, SolverControl & solver_control, int nb_bus) {_change_bus(load_id, new_bus_id, bus_id_, solver_control, nb_bus);}
     int get_bus(int load_id) {return _get_bus(load_id, status_, bus_id_);}
     void change_p(int load_id, real_type new_p, SolverControl & solver_control);
+    void change_p_nothrow(int load_id, real_type new_p, SolverControl & solver_control)
+    {
+        if (p_mw_(load_id) != new_p) {
+            solver_control.tell_recompute_sbus();
+            p_mw_(load_id) = new_p;
+        }
+    }
     void change_q(int load_id, real_type new_q, SolverControl & solver_control);
+    void change_q_nothrow(int load_id, real_type new_q, SolverControl & solver_control)
+    {
+        if (q_mvar_(load_id) != new_q) {
+            solver_control.tell_recompute_sbus();
+            q_mvar_(load_id) = new_q;
+        }
+    }
     virtual void reconnect_connected_buses(std::vector<bool> & bus_status) const;
     virtual void disconnect_if_not_in_main_component(std::vector<bool> & busbar_in_main_component);