LightSim2Grid 0.10.1.post1__tar.gz → 0.10.3__tar.gz

{lightsim2grid-0.10.1.post1 → lightsim2grid-0.10.3/LightSim2Grid.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: LightSim2Grid
-Version: 0.10.1.post1
+Version: 0.10.3
 Summary: LightSim2Grid implements a c++ backend targeting the Grid2Op platform.
 Home-page: https://github.com/grid2op/lightsim2grid/
 Author: Benjamin Donnot
@@ -64,6 +64,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
+Dynamic: license-file
 Dynamic: platform
 Dynamic: provides-extra
 Dynamic: requires-dist

{lightsim2grid-0.10.1.post1 → lightsim2grid-0.10.3}/LightSim2Grid.egg-info/SOURCES.txt

@@ -545,6 +545,8 @@ src/element_container/LineContainer.cpp
 src/element_container/LineContainer.h
 src/element_container/LoadContainer.cpp
 src/element_container/LoadContainer.h
+src/element_container/OneSideContainer.cpp
+src/element_container/OneSideContainer.h
 src/element_container/SGenContainer.cpp
 src/element_container/SGenContainer.h
 src/element_container/ShuntContainer.cpp

{lightsim2grid-0.10.1.post1/LightSim2Grid.egg-info → lightsim2grid-0.10.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: LightSim2Grid
-Version: 0.10.1.post1
+Version: 0.10.3
 Summary: LightSim2Grid implements a c++ backend targeting the Grid2Op platform.
 Home-page: https://github.com/grid2op/lightsim2grid/
 Author: Benjamin Donnot
@@ -64,6 +64,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
+Dynamic: license-file
 Dynamic: platform
 Dynamic: provides-extra
 Dynamic: requires-dist

{lightsim2grid-0.10.1.post1 → lightsim2grid-0.10.3}/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.10.1.post1"
+__version__ = "0.10.3"
 
 __all__ = ["newtonpf", "SolverType", "ErrorType", "solver", "compilation_options"]
 

{lightsim2grid-0.10.1.post1 → lightsim2grid-0.10.3}/lightsim2grid/lightSimBackend.py

@@ -85,6 +85,7 @@ class LightSimBackend(Backend):
                  stop_if_load_disco : Optional[bool] = None,
                  stop_if_gen_disco : Optional[bool] = None,
                  stop_if_storage_disco : Optional[bool] = None,
+                 automatically_disconnect : bool = False, 
                  ):
         #: ``int`` maximum number of iteration allowed for the solver
         #: if the solver has not converge after this, it will 
@@ -167,7 +168,17 @@ class LightSimBackend(Backend):
         #:    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
-                                        
+        
+        #: .. versionadded:: 0.11.0
+        #: if set to ``True`` the backend will automatically
+        #: disconnect any load / generator not in the main
+        #: connected component. The default is ``False``
+        #: which means it will NOT disconnect them
+        #: automatically and raise a "non connected grid"
+        #: error (this should only be used if grid2op allows detachment
+        #: and the detachment is allowed in the env configuration)
+        self._automatically_disconnect = automatically_disconnect
+            
         self._aux_init_super(detailed_infos_for_cascading_failures,
                              can_be_copied,
                              solver_type,
@@ -180,7 +191,16 @@ class LightSimBackend(Backend):
                              loader_kwargs,
                              stop_if_load_disco,
                              stop_if_gen_disco,
-                             stop_if_storage_disco)
+                             stop_if_storage_disco,
+                             automatically_disconnect)
+        
+        #: whether or not to run a routine to detect the islanding
+        #: before computing the powerflow (this routine should
+        #: automatically switch off element not in the main CC)
+        #: by default it's False and only set to True if 
+        #: automatically_disconnect is True (and if the environment
+        #: supports detachment)
+        self._need_islanding_detection = False  
         
         # backward compat: need to define it if not done by grid2op
         if not hasattr(self, "_can_be_copied"):
@@ -335,6 +355,9 @@ class LightSimBackend(Backend):
         #: this flags remembers it
         self._next_pf_fails : Optional[BackendError] = None
         
+        # issue if dc then ac powerflow
+        self._last_dc = True
+        
         # speed optimization
         self._lineor_res = None
         self._lineex_res = None
@@ -361,7 +384,8 @@ class LightSimBackend(Backend):
                         loader_kwargs,
                         stop_if_load_disco,
                         stop_if_gen_disco,
-                        stop_if_storage_disco):
+                        stop_if_storage_disco,
+                        automatically_disconnect):
         try:
             # for grid2Op >= 1.7.1
             Backend.__init__(self,
@@ -377,22 +401,28 @@ 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
+                             stop_if_storage_disco=stop_if_storage_disco,
+                             automatically_disconnect=automatically_disconnect
                              )
         except TypeError as exc_:
             warnings.warn("Please use grid2op >= 1.7.1: with older grid2op versions, "
                           "you cannot set max_iter, tol nor solver_type arguments.")
             Backend.__init__(self,
                              detailed_infos_for_cascading_failures=detailed_infos_for_cascading_failures)
-            
-        if hasattr(type(self), "can_handle_more_than_2_busbar"):
+        
+        cls = type(self)
+        if hasattr(cls, "can_handle_more_than_2_busbar"):
             # do not forget to propagate this if needed
             self.can_handle_more_than_2_busbar()
             
-        if hasattr(type(self), "can_handle_detachment"):
+        if hasattr(cls, "can_handle_detachment"):
             # do not forget to propagate this if needed
             self.can_handle_detachment()
             
+        if automatically_disconnect:
+            # authorize disconnection of elements in the backend
+            self._prevent_automatic_disconnection = False
+            
     def turnedoff_no_pv(self):
         self._turned_off_pv = False
         self._grid.turnedoff_no_pv()
@@ -586,7 +616,7 @@ class LightSimBackend(Backend):
             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`")
+            warnings.warn("Call to `grid2op.make(..., allow_detachment=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:
@@ -597,7 +627,7 @@ class LightSimBackend(Backend):
             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`")
+            warnings.warn("Call to `grid2op.make(..., allow_detachment=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:
@@ -608,7 +638,7 @@ class LightSimBackend(Backend):
             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`")
+            warnings.warn("Call to `grid2op.make(..., allow_detachment=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
@@ -620,7 +650,7 @@ class LightSimBackend(Backend):
             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`")
+            warnings.warn("Call to `grid2op.make(..., allow_detachment=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:
@@ -631,7 +661,7 @@ class LightSimBackend(Backend):
             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`")
+            warnings.warn("Call to `grid2op.make(..., allow_detachment=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:
@@ -642,7 +672,7 @@ class LightSimBackend(Backend):
             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`")
+            warnings.warn("Call to `grid2op.make(..., allow_detachment=False)` will erase the lightsim2grid kwargs `stop_if_storage_disco=False`")
             self._stop_if_storage_disco = True
                 
     def _aux_set_correct_detach_flags(self):
@@ -664,6 +694,12 @@ class LightSimBackend(Backend):
             self.can_handle_detachment()
             
         self._aux_set_correct_detach_flags()
+        if self._automatically_disconnect and not self.detachment_is_allowed:
+            warnings.warn(("It is not possible to automatically disconnect element if grid2op "
+                           "if grid2op does not allow detachment (make sure to upgrade to grid2op >= 1.11 "
+                           "or if the environment is not configure to use it (add the kwargs grid2op.make(..., allow_detachment=True))")
+                          )
+            self._automatically_disconnect = False
             
         if self._loader_method == "pandapower":
             self._load_grid_pandapower(path, filename)
@@ -673,7 +709,9 @@ 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_)
+        self.V = np.ones(self.nb_bus_total, dtype=complex)
+        if self._automatically_disconnect:
+            self._need_islanding_detection = True
     
     def _should_not_have_to_do_this(self, path=None, filename=None):
         # included in grid2op now !
@@ -1083,10 +1121,12 @@ class LightSimBackend(Backend):
 
     def _aux_finish_setup_after_reading(self):
         # set up the "lightsim grid" accordingly
-        cls = type(self)
-        if cls.n_line <= -1:
+        my_cls = type(self)
+        if my_cls.n_line <= -1:
             warnings.warn("You are using a legacy (quite old now) grid2op version. Please upgrade it.")
             cls = self
+        else:
+            cls = my_cls
         self._grid.set_load_pos_topo_vect(cls.load_pos_topo_vect)
         self._grid.set_gen_pos_topo_vect(cls.gen_pos_topo_vect)
         self._grid.set_line_or_pos_topo_vect(cls.line_or_pos_topo_vect[:self.__nb_powerline])
@@ -1132,40 +1172,40 @@ class LightSimBackend(Backend):
         if cls.shunts_data_available:
             self.shunt_topo_vect = np.ones(cls.n_shunt, dtype=dt_int)
              # shunts
-            self.sh_p = np.full(cls.n_shunt, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-            self.sh_q = np.full(cls.n_shunt, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-            self.sh_v = np.full(cls.n_shunt, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-            self.sh_theta = np.full(cls.n_shunt, dtype=dt_float, fill_value=np.NaN).reshape(-1)
+            self.sh_p = np.full(cls.n_shunt, dtype=dt_float, fill_value=np.nan).reshape(-1)
+            self.sh_q = np.full(cls.n_shunt, dtype=dt_float, fill_value=np.nan).reshape(-1)
+            self.sh_v = np.full(cls.n_shunt, dtype=dt_float, fill_value=np.nan).reshape(-1)
+            self.sh_theta = np.full(cls.n_shunt, dtype=dt_float, fill_value=np.nan).reshape(-1)
             self.sh_bus = np.full(cls.n_shunt, dtype=dt_int, fill_value=-1).reshape(-1)
 
-        self.p_or = np.full(cls.n_line, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-        self.q_or = np.full(cls.n_line, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-        self.v_or = np.full(cls.n_line, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-        self.a_or = np.full(cls.n_line, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-        self.p_ex = np.full(cls.n_line, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-        self.q_ex = np.full(cls.n_line, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-        self.v_ex = np.full(cls.n_line, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-        self.a_ex = np.full(cls.n_line, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-
-        self.load_p = np.full(cls.n_load, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-        self.load_q = np.full(cls.n_load, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-        self.load_v = np.full(cls.n_load, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-
-        self.prod_p = np.full(cls.n_gen, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-        self.prod_q = np.full(cls.n_gen, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-        self.prod_v = np.full(cls.n_gen, dtype=dt_float, fill_value=np.NaN).reshape(-1)
+        self.p_or = np.full(cls.n_line, dtype=dt_float, fill_value=np.nan).reshape(-1)
+        self.q_or = np.full(cls.n_line, dtype=dt_float, fill_value=np.nan).reshape(-1)
+        self.v_or = np.full(cls.n_line, dtype=dt_float, fill_value=np.nan).reshape(-1)
+        self.a_or = np.full(cls.n_line, dtype=dt_float, fill_value=np.nan).reshape(-1)
+        self.p_ex = np.full(cls.n_line, dtype=dt_float, fill_value=np.nan).reshape(-1)
+        self.q_ex = np.full(cls.n_line, dtype=dt_float, fill_value=np.nan).reshape(-1)
+        self.v_ex = np.full(cls.n_line, dtype=dt_float, fill_value=np.nan).reshape(-1)
+        self.a_ex = np.full(cls.n_line, dtype=dt_float, fill_value=np.nan).reshape(-1)
+
+        self.load_p = np.full(cls.n_load, dtype=dt_float, fill_value=np.nan).reshape(-1)
+        self.load_q = np.full(cls.n_load, dtype=dt_float, fill_value=np.nan).reshape(-1)
+        self.load_v = np.full(cls.n_load, dtype=dt_float, fill_value=np.nan).reshape(-1)
+
+        self.prod_p = np.full(cls.n_gen, dtype=dt_float, fill_value=np.nan).reshape(-1)
+        self.prod_q = np.full(cls.n_gen, dtype=dt_float, fill_value=np.nan).reshape(-1)
+        self.prod_v = np.full(cls.n_gen, dtype=dt_float, fill_value=np.nan).reshape(-1)
         
-        self.line_or_theta = np.full(cls.n_line, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-        self.line_ex_theta = np.full(cls.n_line, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-        self.load_theta = np.full(cls.n_load, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-        self.gen_theta = np.full(cls.n_gen, dtype=dt_float, fill_value=np.NaN).reshape(-1)
+        self.line_or_theta = np.full(cls.n_line, dtype=dt_float, fill_value=np.nan).reshape(-1)
+        self.line_ex_theta = np.full(cls.n_line, dtype=dt_float, fill_value=np.nan).reshape(-1)
+        self.load_theta = np.full(cls.n_load, dtype=dt_float, fill_value=np.nan).reshape(-1)
+        self.gen_theta = np.full(cls.n_gen, dtype=dt_float, fill_value=np.nan).reshape(-1)
 
         # TODO storage check grid2op version and see if storage is available !
         if self.__has_storage:
-            self.storage_p = np.full(cls.n_storage, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-            self.storage_q = np.full(cls.n_storage, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-            self.storage_v = np.full(cls.n_storage, dtype=dt_float, fill_value=np.NaN).reshape(-1)
-            self.storage_theta = np.full(cls.n_storage, dtype=dt_float, fill_value=np.NaN).reshape(-1)
+            self.storage_p = np.full(cls.n_storage, dtype=dt_float, fill_value=np.nan).reshape(-1)
+            self.storage_q = np.full(cls.n_storage, dtype=dt_float, fill_value=np.nan).reshape(-1)
+            self.storage_v = np.full(cls.n_storage, dtype=dt_float, fill_value=np.nan).reshape(-1)
+            self.storage_theta = np.full(cls.n_storage, dtype=dt_float, fill_value=np.nan).reshape(-1)
 
         self._count_object_per_bus()
         
@@ -1175,22 +1215,11 @@ class LightSimBackend(Backend):
         try:
             cls.n_sub = self.n_sub
             LightSimBackend.n_sub = self.n_sub
-            self.topo_vect[cls.load_pos_topo_vect] = cls.global_bus_to_local(np.array([el.bus_id for el in self._grid.get_loads()]),
-                                                                            cls.load_to_subid)
-            self.topo_vect[cls.gen_pos_topo_vect] = cls.global_bus_to_local(np.array([el.bus_id for el in self._grid.get_generators()]),
-                                                                            cls.gen_to_subid)
-            if self.__has_storage:
-                self.topo_vect[cls.storage_pos_topo_vect] = cls.global_bus_to_local(np.array([el.bus_id for el in self._grid.get_storages()]),
-                                                                                    cls.storage_to_subid)
-            lor_glob_bus = np.concatenate((np.array([el.bus_or_id for el in self._grid.get_lines()]),
-                                        np.array([el.bus_hv_id for el in self._grid.get_trafos()])))
-            self.topo_vect[cls.line_or_pos_topo_vect] = cls.global_bus_to_local(lor_glob_bus,
-                                                                                cls.line_or_to_subid)
-            lex_glob_bus = np.concatenate((np.array([el.bus_ex_id for el in self._grid.get_lines()]),
-                                        np.array([el.bus_lv_id for el in self._grid.get_trafos()])))
-            self.topo_vect[cls.line_ex_pos_topo_vect] = cls.global_bus_to_local(lex_glob_bus,
-                                                                                cls.line_ex_to_subid)
-            
+            if my_cls.load_pos_topo_vect is None:
+                # old grid2op version
+                self.topo_vect[:] = 1
+            else:
+                self._read_topo_vect(self.topo_vect)
             self._grid.tell_solver_need_reset()
             self.__me_at_init = self._grid.copy()
             self.__init_topo_vect = np.ones(cls.dim_topo, dtype=dt_int)
@@ -1201,6 +1230,24 @@ class LightSimBackend(Backend):
         finally:
             cls.n_sub = n_sub_cls_orig
             LightSimBackend.n_sub = n_sub_ls_orig
+    
+    def _read_topo_vect(self, res):
+        """the input vector "res" is modified !"""
+        # TODO speed optimization here to read it "better"
+        cls = type(self)
+        res[cls.load_pos_topo_vect] = cls.global_bus_to_local(np.array([el.bus_id for el in self._grid.get_loads()]),
+                                                                        cls.load_to_subid)
+        res[cls.gen_pos_topo_vect] = cls.global_bus_to_local(np.array([el.bus_id for el in self._grid.get_generators()]),
+                                                                        cls.gen_to_subid)
+        if self.__has_storage:
+            res[cls.storage_pos_topo_vect] = cls.global_bus_to_local(np.array([el.bus_id for el in self._grid.get_storages()]),
+                                                                                cls.storage_to_subid)
+        lor_glob_bus = np.concatenate((np.array([el.bus_or_id for el in self._grid.get_lines()]),
+                                        np.array([el.bus_hv_id for el in self._grid.get_trafos()])))
+        res[cls.line_or_pos_topo_vect] = cls.global_bus_to_local(lor_glob_bus, cls.line_or_to_subid)
+        lex_glob_bus = np.concatenate((np.array([el.bus_ex_id for el in self._grid.get_lines()]),
+                                        np.array([el.bus_lv_id for el in self._grid.get_trafos()])))
+        res[cls.line_ex_pos_topo_vect] = cls.global_bus_to_local(lex_glob_bus, cls.line_ex_to_subid)
         
     def assert_grid_correct_after_powerflow(self) -> None:
         """
@@ -1282,10 +1329,16 @@ class LightSimBackend(Backend):
         # change the overall topology
         chgt = backendAction.current_topo.changed
         self._grid.update_topo(chgt, backendAction.current_topo.values)
-        self.topo_vect[chgt] = backendAction.current_topo.values[chgt]
+        if not self._automatically_disconnect:
+            # the backend cannot change the topology, so 
+            # this holds
+            self.topo_vect[chgt] = backendAction.current_topo.values[chgt]
+        else:
+            if chgt.sum():
+                # there has been topological changes, I need 
+                # to perform a BFS to detect possible islanding
+                self._need_islanding_detection = True
         
-        # print(f" load p {backendAction.load_p.values[backendAction.load_p.changed]}")  # TODO DEBUG WINDOWS
-        # print(f" prod_p p {backendAction.prod_p.values[backendAction.prod_p.changed]}")  # TODO DEBUG WINDOWS
         # update the injections
         try:
             self._grid.update_gens_p(backendAction.prod_p.changed,
@@ -1369,11 +1422,15 @@ class LightSimBackend(Backend):
                 raise self._next_pf_fails
             
             beg_preproc = time.perf_counter()
+            if self._need_islanding_detection:
+                self._grid.consider_only_main_component()
+                
             if is_dc:
                 # somehow, when asked to do a powerflow in DC, pandapower assign Vm to be
                 # one everywhere...
                 # But not when it initializes in DC mode... (see below)
-                self.V = np.ones(self.nb_bus_total, dtype=np.complex_) #  * self._grid.get_init_vm_pu()
+                self._last_dc = True
+                self.V = np.ones(self.nb_bus_total, dtype=complex) #  * self._grid.get_init_vm_pu()
                 tick = time.perf_counter()
                 self._timer_preproc += tick - beg_preproc
                 V = self._grid.dc_pf(self.V, self.max_it, self.tol)
@@ -1383,7 +1440,7 @@ class LightSimBackend(Backend):
             else:
                 if (self.V is None) or (self.V.shape[0] == 0):
                     # create the vector V as it is not created
-                    self.V = np.ones(self.nb_bus_total, dtype=np.complex_) * self._grid.get_init_vm_pu()
+                    self.V = np.ones(self.nb_bus_total, dtype=complex) * self._grid.get_init_vm_pu()
                 if self.initdc:
                     self._grid.deactivate_result_computation()
                     # if I init with dc values, it should depends on previous state
@@ -1402,6 +1459,10 @@ class LightSimBackend(Backend):
                     V_init = copy.deepcopy(self.V)
                 tick = time.perf_counter()
                 self._timer_preproc += tick - beg_preproc
+                if self._last_dc:
+                    # otherwise might segfault is a dc powerflow as been run before an ac one
+                    self._grid.tell_solver_need_reset()
+                    self._last_dc = False
                 V = self._grid.ac_pf(V_init, self.max_it, self.tol)
                 self._timer_solver += time.perf_counter() - tick
                 if V.shape[0] == 0:
@@ -1477,7 +1538,8 @@ class LightSimBackend(Backend):
                 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.)
+                # TODO speed optim here: self._grid.get_storage_target_p() is not "cached"
+                sto_active = (np.abs(self._grid.get_storage_target_p()) > 0.)
                 sto_act_disco = (((~np.isfinite(self.storage_v)) & sto_active).any() or 
                                  ((self.storage_v <= 0.) & sto_active).any()
                                 )
@@ -1495,6 +1557,12 @@ class LightSimBackend(Backend):
                 raise BackendError(f"Some theta are above 1e6 which should not be happening !")
             res = True
             self._grid.unset_changes()
+            
+            if self._need_islanding_detection:
+                # topology might have changed in the
+                # powerflow computation
+                self._read_topo_vect(self.topo_vect)
+                self._need_islanding_detection = False
             self._timer_postproc += time.perf_counter() - beg_postroc
         except Exception as exc_:
             # of the powerflow has not converged, results are Nan
@@ -1508,7 +1576,10 @@ class LightSimBackend(Backend):
                 # set back the solver to its previous state
                 self._grid.change_solver(self.__current_solver_type)
             self._grid.tell_solver_need_reset()
-
+            if self._automatically_disconnect:
+                # trigger a check for the connected component only
+                # if relevant attribute is set
+                self._need_islanding_detection = True
         # TODO grid2op compatibility ! (was a single returned element before storage were introduced)
         if self.__has_storage:
             res = res, my_exc_
@@ -1517,40 +1588,41 @@ 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
-        self.a_or[:] = np.NaN
-        self.p_ex[:] = np.NaN
-        self.q_ex[:] = np.NaN
-        self.v_ex[:] = np.NaN
-        self.a_ex[:] = np.NaN
-        self.load_p[:] = np.NaN
-        self.load_q[:] = np.NaN
-        self.load_v[:] = np.NaN
-        self.prod_p[:] = np.NaN
-        self.next_prod_p[:] = np.NaN
-        self.prod_q[:] = np.NaN
-        self.prod_v[:] = np.NaN
-        self.line_or_theta[:] = np.NaN
-        self.line_ex_theta[:] = np.NaN
-        self.load_theta[:] = np.NaN
-        self.gen_theta[:] = np.NaN
+        self.p_or[:] = np.nan
+        self.q_or[:] = np.nan
+        self.v_or[:] = np.nan
+        self.a_or[:] = np.nan
+        self.p_ex[:] = np.nan
+        self.q_ex[:] = np.nan
+        self.v_ex[:] = np.nan
+        self.a_ex[:] = np.nan
+        self.load_p[:] = np.nan
+        self.load_q[:] = np.nan
+        self.load_v[:] = np.nan
+        self.prod_p[:] = np.nan
+        self.next_prod_p[:] = np.nan
+        self.prod_q[:] = np.nan
+        self.prod_v[:] = np.nan
+        self.line_or_theta[:] = np.nan
+        self.line_ex_theta[:] = np.nan
+        self.load_theta[:] = np.nan
+        self.gen_theta[:] = np.nan
 
         if type(self).shunts_data_available:
-            self.sh_p[:] = np.NaN
-            self.sh_q[:] = np.NaN
-            self.sh_v[:] = np.NaN
-            self.sh_theta[:] = np.NaN
+            self.sh_p[:] = np.nan
+            self.sh_q[:] = np.nan
+            self.sh_v[:] = np.nan
+            self.sh_theta[:] = np.nan
             self.sh_bus[:] = -1
 
         if self.__has_storage:
-            self.storage_p[:] = np.NaN
-            self.storage_q[:] = np.NaN
-            self.storage_v[:] = np.NaN
-            self.storage_theta[:] = np.NaN
+            self.storage_p[:] = np.nan
+            self.storage_q[:] = np.nan
+            self.storage_v[:] = np.nan
+            self.storage_theta[:] = np.nan
         self.V[:] = self._grid.get_init_vm_pu()  # reset the V to its "original" value (see issue 30)
         self._reset_res_pointers()
+        self._last_dc = True
     
     def _reset_res_pointers(self):
         self._lineor_res  = None
@@ -1563,11 +1635,14 @@ class LightSimBackend(Backend):
         self._shunt_res = None
         
     def __deepcopy__(self, memo):
-        result = self.copy()
+        if hasattr(type(self), "copy_public"):
+            result = self.copy_public()
+        else:
+            result = self.copy()
         memo[id(self)] = result
         return result
 
-    def copy(self) -> Self:
+    def copy(self, orig_grid=None) -> Self:
         # i can perform a regular copy, everything has been initialized
         mygrid = self._grid
         __me_at_init = self.__me_at_init
@@ -1598,7 +1673,8 @@ class LightSimBackend(Backend):
                             self._loader_kwargs,
                             self._stop_if_load_disco,
                             self._stop_if_gen_disco,
-                            self._stop_if_storage_disco)
+                            self._stop_if_storage_disco,
+                            self._automatically_disconnect)
         
         # for backward compat (attribute was not necessarily present in early grid2op)
         if not hasattr(res, "_can_be_copied"):
@@ -1623,7 +1699,9 @@ class LightSimBackend(Backend):
                            "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", "_stop_if_storage_disco",
-                           "_timer_fetch_data_cpp", "_next_pf_fails"
+                           "_timer_fetch_data_cpp", "_next_pf_fails", "_automatically_disconnect",
+                           "_need_islanding_detection",
+                           "_last_dc"
                            ]
         for attr_nm in li_regular_attr:
             if hasattr(self, attr_nm):
@@ -1677,16 +1755,23 @@ class LightSimBackend(Backend):
         ###############
 
         # handle the most complicated
-        res._grid = mygrid.copy()
+        if mygrid is not None:
+            res._grid = mygrid.copy()
+            res._reset_res_pointers()
+            res._fetch_grid_data()
+            if orig_grid is not None:
+                if mygrid is not orig_grid:
+                    raise Grid2OpException("Error in the copy of a LightSimBackend: my_grid is not orig_grid")
+        else:
+            res._grid = None
         res.__me_at_init = __me_at_init.copy()  # this is const
         res.init_pp_backend = inippbackend  # this is const
         res._init_action_to_set = copy.deepcopy(self._init_action_to_set)
         res._backend_action_class = self._backend_action_class  # this is const
-        res.__init_topo_vect = self.__init_topo_vect
+        res.__init_topo_vect = 1 * self.__init_topo_vect
         res.available_solvers = self.available_solvers
         res._orig_grid_pypowsybl = self._orig_grid_pypowsybl 
-        res._reset_res_pointers()
-        res._fetch_grid_data()
+        
         # assign back "self" attributes
         self._grid = mygrid
         self.init_pp_backend = inippbackend
@@ -1780,6 +1865,9 @@ class LightSimBackend(Backend):
         if type(self).shunts_data_available:
             self.sh_bus[:] = 1  # TODO self._compute_shunt_bus_with_compat(self._grid.get_all_shunt_buses())
         self.topo_vect[:] = self.__init_topo_vect  # TODO#
+        if self._automatically_disconnect:
+            # automatically disconnect things if needed (and if the option is properly set)
+            self._need_islanding_detection = True
 
 
 def _dont_use_global_bus_to_local_legacy(cls, global_bus: np.ndarray, to_sub_id: np.ndarray) -> np.ndarray:

{lightsim2grid-0.10.1.post1 → lightsim2grid-0.10.3}/setup.py

@@ -14,7 +14,7 @@ import warnings
 from pybind11.setup_helpers import Pybind11Extension, build_ext
 
 
-__version__ = "0.10.1.post1"
+__version__ = "0.10.3"
 KLU_SOLVER_AVAILABLE = False
 
 # Try to link against SuiteSparse (if available)
@@ -152,14 +152,16 @@ src_files = ['src/main.cpp',
              "src/batch_algorithm/BaseBatchSolverSynch.cpp",
              "src/batch_algorithm/TimeSeries.cpp",
              "src/batch_algorithm/ContingencyAnalysis.cpp",
-             "src/element_container/LineContainer.cpp",
              "src/element_container/GenericContainer.cpp",
+             "src/element_container/OneSideContainer.cpp",
              "src/element_container/ShuntContainer.cpp",
              "src/element_container/TrafoContainer.cpp",
              "src/element_container/LoadContainer.cpp",
              "src/element_container/GeneratorContainer.cpp",
              "src/element_container/SGenContainer.cpp",
-             "src/element_container/DCLineContainer.cpp"]
+             "src/element_container/DCLineContainer.cpp",
+             "src/element_container/LineContainer.cpp",
+             ]
 
 if KLU_SOLVER_AVAILABLE:
     src_files.append("src/linear_solvers/KLUSolver.cpp")

{lightsim2grid-0.10.1.post1 → lightsim2grid-0.10.3}/src/BaseConstants.cpp

@@ -15,4 +15,6 @@ const real_type BaseConstants::my_two_ = 2.0;
 const real_type BaseConstants::my_half_ = 0.5;
 const real_type BaseConstants::my_zero_ = 0.;
 const real_type BaseConstants::my_180_pi_ = 180. / M_PI;
+const real_type BaseConstants::v_disco_el_ = 0.0;
+const real_type BaseConstants::theta_disco_el_ = 0.0;
 const int BaseConstants::_deactivated_bus_id = -1;

{lightsim2grid-0.10.1.post1 → lightsim2grid-0.10.3}/src/BaseConstants.h

@@ -25,6 +25,8 @@ class BaseConstants
         static const real_type my_two_;
         static const real_type my_zero_;
         static const real_type my_180_pi_;
+        static const real_type v_disco_el_;
+        static const real_type theta_disco_el_;
         static const int _deactivated_bus_id;
 };