LightSim2Grid 0.10.1.post1__tar.gz → 0.11.0.dev1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: LightSim2Grid
-Version: 0.10.1.post1
+Version: 0.11.0.dev1
 Summary: LightSim2Grid implements a c++ backend targeting the Grid2Op platform.
 Home-page: https://github.com/grid2op/lightsim2grid/
 Author: Benjamin Donnot

{lightsim2grid-0.10.1.post1 → lightsim2grid-0.11.0.dev1}/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.11.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: LightSim2Grid
-Version: 0.10.1.post1
+Version: 0.11.0.dev1
 Summary: LightSim2Grid implements a c++ backend targeting the Grid2Op platform.
 Home-page: https://github.com/grid2op/lightsim2grid/
 Author: Benjamin Donnot

{lightsim2grid-0.10.1.post1 → lightsim2grid-0.11.0.dev1}/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.11.0.dev1"
 
 __all__ = ["newtonpf", "SolverType", "ErrorType", "solver", "compilation_options"]
 

{lightsim2grid-0.10.1.post1 → lightsim2grid-0.11.0.dev1}/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"):
@@ -361,7 +381,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,7 +398,8 @@ 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, "
@@ -586,7 +608,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 +619,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 +630,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 +642,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 +653,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 +664,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 +686,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)
@@ -674,6 +702,8 @@ class LightSimBackend(Backend):
         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_)
+        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 +1113,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])
@@ -1175,22 +1207,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 +1222,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 +1321,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,6 +1414,9 @@ 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...
@@ -1477,7 +1525,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 +1544,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 +1563,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_
@@ -1598,7 +1656,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 +1682,8 @@ 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"
                            ]
         for attr_nm in li_regular_attr:
             if hasattr(self, attr_nm):
@@ -1682,7 +1742,7 @@ class LightSimBackend(Backend):
         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()
@@ -1780,6 +1840,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.11.0.dev1}/setup.py

@@ -14,7 +14,7 @@ import warnings
 from pybind11.setup_helpers import Pybind11Extension, build_ext
 
 
-__version__ = "0.10.1.post1"
+__version__ = "0.11.0.dev1"
 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.11.0.dev1}/src/GridModel.cpp

@@ -540,7 +540,9 @@ CplxVect GridModel::pre_process_solver(const CplxVect & Vinit,
     if (solver_control.need_reset_solver() ||
         solver_control.ybus_change_sparsity_pattern() || 
         solver_control.has_dimension_changed()){
-            init_Ybus(Ybus, id_me_to_solver, id_solver_to_me);
+            init_converter_bus_id(id_me_to_solver, id_solver_to_me);
+            const int nb_bus_solver = static_cast<int>(id_solver_to_me.size());
+            init_Ybus(Ybus, nb_bus_solver);
         }
     if (solver_control.need_reset_solver() ||
         solver_control.ybus_change_sparsity_pattern() || 
@@ -642,9 +644,9 @@ void GridModel::process_results(bool conv,
     }
 }
 
-void GridModel::init_Ybus(Eigen::SparseMatrix<cplx_type> & Ybus,
-                          std::vector<int>& id_me_to_solver,
-                          std::vector<int>& id_solver_to_me){
+void GridModel::init_converter_bus_id(std::vector<int>& id_me_to_solver,
+                                      std::vector<int>& id_solver_to_me){
+
     //TODO get disconnected bus !!! (and have some conversion for it)
     //1. init the conversion bus
     const int nb_bus_init = static_cast<int>(bus_vn_kv_.size());
@@ -660,8 +662,10 @@ void GridModel::init_Ybus(Eigen::SparseMatrix<cplx_type> & Ybus,
             ++bus_id_solver;
         }
     }
-    const int nb_bus_solver = static_cast<int>(id_solver_to_me.size());
+}
 
+void GridModel::init_Ybus(Eigen::SparseMatrix<cplx_type> & Ybus,
+                          int nb_bus_solver){
     Ybus = Eigen::SparseMatrix<cplx_type>(nb_bus_solver, nb_bus_solver);
     Ybus.reserve(nb_bus_solver + 2*powerlines_.nb() + 2*trafos_.nb());
 }
@@ -1276,38 +1280,79 @@ void GridModel::consider_only_main_component(){
 
     // find the connected buses
     // TODO copy paste from SecurityAnalysis
-    std::queue<Eigen::Index> neighborhood;
-    for(const auto & el : slack_buses_id) neighborhood.push(el);
-    if(neighborhood.empty()){
-        throw std::runtime_error("There is no slack buses defined in your grid. You cannot isolate the main component.");
-    }
-    std::vector<bool> visited(nb_busbars, false);
+    // for(const auto & el : slack_buses_id) neighborhood.push(el);
+    std::vector<bool> tmp_visited(nb_busbars, false);
+    std::vector<int> conn_comp(nb_busbars, -1);
     std::vector<bool> already_added(nb_busbars, false);
-    while (true)
+
+    int connected_comp = 0;
+    std::queue<Eigen::Index> neighborhood;
+    while(true)
     {
-        const Eigen::Index col_id = neighborhood.front();
-        neighborhood.pop();
-        visited[col_id] = true;
-        for (Eigen::SparseMatrix<real_type>::InnerIterator it(graph, col_id); it; ++it)
+        neighborhood = std::queue<Eigen::Index>();
+
+        // choose bus id (one of the slack) to start
+        bool one_added = false;
+        for(const auto & el : slack_buses_id){
+            if(!tmp_visited[el] && !already_added[el])
+            {
+                one_added = true;
+                neighborhood.push(el);
+                break;
+            }
+        }
+        
+        if(!one_added) break; // no more slack bus, I stop
+
+        // start the bfs
+        while (true)
         {
-            // add in the queue all my neighbor (if the coefficient is big enough)
-            if(!visited[it.row()] && !already_added[it.row()]){  // && abs(it.value()) > 1e-8
-                neighborhood.push(it.row());
-                already_added[it.row()] = true;
+            const Eigen::Index col_id = neighborhood.front();
+            neighborhood.pop();
+            tmp_visited[col_id] = true;
+            conn_comp[col_id] = connected_comp;
+            for (Eigen::SparseMatrix<real_type>::InnerIterator it(graph, col_id); it; ++it)
+            {
+                // add in the queue all my neighbor
+                if(!tmp_visited[it.row()] && !already_added[it.row()]){
+                    neighborhood.push(it.row());
+                    already_added[it.row()] = true;
+                }
             }
+            if(neighborhood.empty()) break;  // no more neighbors
         }
-        if(neighborhood.empty()) break;
+
+        // go to the next connected comp
+        ++connected_comp;
+    }
+
+    // TODO speed optim: if connected_comp == 1 => don't do the following 2 steps
+    
+    // find the connected comp with the most buses
+    int main_cc_id = -1;
+    std::vector<int> nb_bus_per_cc(connected_comp, 0);
+    for(const auto el : conn_comp){
+        if(el == -1) continue;
+        nb_bus_per_cc[el] += 1;
+    }
+    main_cc_id = std::distance(nb_bus_per_cc.begin(),
+                               std::max_element(nb_bus_per_cc.begin(), nb_bus_per_cc.end()));
+
+    // mark as visited the element in this cc
+    std::vector<bool> bus_in_main_cc(nb_busbars, false);
+    for(int bus_id = 0; bus_id < nb_busbars; ++bus_id){
+        if(conn_comp[bus_id] == main_cc_id) bus_in_main_cc[bus_id] = true;
     }
 
     // disconnected elements not in main component
-    powerlines_.disconnect_if_not_in_main_component(visited);
-    shunts_.disconnect_if_not_in_main_component(visited);
-    trafos_.disconnect_if_not_in_main_component(visited);
-    loads_.disconnect_if_not_in_main_component(visited);
-    sgens_.disconnect_if_not_in_main_component(visited);
-    storages_.disconnect_if_not_in_main_component(visited);
-    generators_.disconnect_if_not_in_main_component(visited);
-    dc_lines_.disconnect_if_not_in_main_component(visited);
+    powerlines_.disconnect_if_not_in_main_component(bus_in_main_cc);
+    shunts_.disconnect_if_not_in_main_component(bus_in_main_cc);
+    trafos_.disconnect_if_not_in_main_component(bus_in_main_cc);
+    loads_.disconnect_if_not_in_main_component(bus_in_main_cc);
+    sgens_.disconnect_if_not_in_main_component(bus_in_main_cc);
+    storages_.disconnect_if_not_in_main_component(bus_in_main_cc);
+    generators_.disconnect_if_not_in_main_component(bus_in_main_cc);
+    dc_lines_.disconnect_if_not_in_main_component(bus_in_main_cc);
     // and finally deal with the buses
     init_bus_status();
 }

{lightsim2grid-0.10.1.post1 → lightsim2grid-0.11.0.dev1}/src/GridModel.h

@@ -363,7 +363,7 @@ class GridModel : public GenericContainer
                 solver_control_.need_recompute_sbus();
                 solver_control_.need_recompute_ybus();
                 solver_control_.ybus_change_sparsity_pattern();
-                _deactivate(bus_id, bus_status_);
+                _generic_deactivate(bus_id, bus_status_);
             }
         }
         // if a bus is connected, but isolated, it will make the powerflow diverge
@@ -374,7 +374,7 @@ class GridModel : public GenericContainer
                 solver_control_.need_recompute_sbus();
                 solver_control_.need_recompute_ybus();
                 solver_control_.ybus_change_sparsity_pattern();
-                _reactivate(bus_id, bus_status_); 
+                _generic_reactivate(bus_id, bus_status_); 
             }
         }
         /**
@@ -452,32 +452,33 @@ class GridModel : public GenericContainer
         void deactivate_load(int load_id) {loads_.deactivate(load_id, solver_control_); }
         void reactivate_load(int load_id) {loads_.reactivate(load_id, solver_control_); }
         void change_bus_load(int load_id, int new_bus_id) {loads_.change_bus(load_id, new_bus_id, solver_control_, static_cast<int>(bus_vn_kv_.size())); }
-        void change_p_load(int load_id, real_type new_p) {loads_.change_p(load_id, new_p, solver_control_); }
-        void change_q_load(int load_id, real_type new_q) {loads_.change_q(load_id, new_q, solver_control_); }
+        void change_p_load(int load_id, real_type new_p) {loads_.change_p_nothrow(load_id, new_p, solver_control_); }
+        void change_q_load(int load_id, real_type new_q) {loads_.change_q_nothrow(load_id, new_q, solver_control_); }
         int get_bus_load(int load_id) {return loads_.get_bus(load_id);}
 
         //generator
         void deactivate_gen(int gen_id) {generators_.deactivate(gen_id, solver_control_); }
         void reactivate_gen(int gen_id) {generators_.reactivate(gen_id, solver_control_); }
         void change_bus_gen(int gen_id, int new_bus_id) {generators_.change_bus(gen_id, new_bus_id, solver_control_, static_cast<int>(bus_vn_kv_.size())); }
-        void change_p_gen(int gen_id, real_type new_p) {generators_.change_p(gen_id, new_p, solver_control_); }
-        void change_v_gen(int gen_id, real_type new_v_pu) {generators_.change_v(gen_id, new_v_pu, solver_control_); }
+        void change_p_gen(int gen_id, real_type new_p) {generators_.change_p_nothrow(gen_id, new_p, solver_control_); }
+        void change_q_gen(int gen_id, real_type new_q) {generators_.change_q_nothrow(gen_id, new_q, solver_control_); }
+        void change_v_gen(int gen_id, real_type new_v_pu) {generators_.change_v_nothrow(gen_id, new_v_pu, solver_control_); }
         int get_bus_gen(int gen_id) {return generators_.get_bus(gen_id);}
 
         //shunt
         void deactivate_shunt(int shunt_id) {shunts_.deactivate(shunt_id, solver_control_); }
         void reactivate_shunt(int shunt_id) {shunts_.reactivate(shunt_id, solver_control_); }
         void change_bus_shunt(int shunt_id, int new_bus_id) {shunts_.change_bus(shunt_id, new_bus_id, solver_control_, static_cast<int>(bus_vn_kv_.size()));  }
-        void change_p_shunt(int shunt_id, real_type new_p) {shunts_.change_p(shunt_id, new_p, solver_control_); }
-        void change_q_shunt(int shunt_id, real_type new_q) {shunts_.change_q(shunt_id, new_q, solver_control_); }
+        void change_p_shunt(int shunt_id, real_type new_p) {shunts_.change_p_nothrow(shunt_id, new_p, solver_control_); }
+        void change_q_shunt(int shunt_id, real_type new_q) {shunts_.change_q_nothrow(shunt_id, new_q, solver_control_); }
         int get_bus_shunt(int shunt_id) {return shunts_.get_bus(shunt_id);}
 
         //static gen
         void deactivate_sgen(int sgen_id) {sgens_.deactivate(sgen_id, solver_control_); }
         void reactivate_sgen(int sgen_id) {sgens_.reactivate(sgen_id, solver_control_); }
         void change_bus_sgen(int sgen_id, int new_bus_id) {sgens_.change_bus(sgen_id, new_bus_id, solver_control_, static_cast<int>(bus_vn_kv_.size())); }
-        void change_p_sgen(int sgen_id, real_type new_p) {sgens_.change_p(sgen_id, new_p, solver_control_); }
-        void change_q_sgen(int sgen_id, real_type new_q) {sgens_.change_q(sgen_id, new_q, solver_control_); }
+        void change_p_sgen(int sgen_id, real_type new_p) {sgens_.change_p_nothrow(sgen_id, new_p, solver_control_); }
+        void change_q_sgen(int sgen_id, real_type new_q) {sgens_.change_q_nothrow(sgen_id, new_q, solver_control_); }
         int get_bus_sgen(int sgen_id) {return sgens_.get_bus(sgen_id);}
 
         //storage units
@@ -544,6 +545,12 @@ class GridModel : public GenericContainer
 
         Eigen::Ref<const IntVect> get_all_shunt_buses() const {return shunts_.get_buses();}
 
+        Eigen::Ref<const RealVect>  get_shunt_target_p() const {return shunts_.get_target_p();}
+        Eigen::Ref<const RealVect>  get_load_target_p() const {return loads_.get_target_p();}
+        Eigen::Ref<const RealVect>  get_gen_target_p() const {return generators_.get_target_p();}
+        Eigen::Ref<const RealVect>  get_sgen_target_p() const {return sgens_.get_target_p();}
+        Eigen::Ref<const RealVect>  get_storage_target_p() const {return storages_.get_target_p();}
+
         // complete results (with theta)
         tuple4d get_loads_res_full() const {return loads_.get_res_full();}
         tuple4d get_shunts_res_full() const {return shunts_.get_res_full();}
@@ -1048,8 +1055,9 @@ class GridModel : public GenericContainer
         // init the Ybus matrix (its size, it is filled up elsewhere) and also the 
         // converter from "my bus id" to the "solver bus id" (id_me_to_solver and id_solver_to_me)
         void init_Ybus(Eigen::SparseMatrix<cplx_type> & Ybus,
-                       std::vector<int> & id_me_to_solver,
-                       std::vector<int>& id_solver_to_me);
+                       int nb_bus_solver);
+        void init_converter_bus_id(std::vector<int>& id_me_to_solver,
+                                   std::vector<int>& id_solver_to_me);
 
         // converts the slack_bus_id from gridmodel ordering into solver ordering
         void init_slack_bus(const CplxVect & Sbus,

{lightsim2grid-0.10.1.post1 → lightsim2grid-0.11.0.dev1}/src/element_container/DCLineContainer.h

@@ -162,12 +162,12 @@ class DCLineContainer : public GenericContainer
 
     // accessor / modifiers
     void deactivate(int dcline_id, SolverControl & solver_control) {
-        _deactivate(dcline_id, status_);
+        _generic_deactivate(dcline_id, status_);
         from_gen_.deactivate(dcline_id, solver_control);
         to_gen_.deactivate(dcline_id, solver_control);
         }
     void reactivate(int dcline_id, SolverControl & solver_control) {
-        _reactivate(dcline_id, status_);
+        _generic_reactivate(dcline_id, status_);
         from_gen_.reactivate(dcline_id, solver_control);
         to_gen_.reactivate(dcline_id, solver_control);
         }