LightSim2Grid 0.12.0__tar.gz → 0.12.2__tar.gz

{lightsim2grid-0.12.0 → lightsim2grid-0.12.2/LightSim2Grid.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: LightSim2Grid
-Version: 0.12.0
+Version: 0.12.2
 Summary: LightSim2Grid implements a c++ backend targeting the Grid2Op platform.
 Home-page: https://github.com/grid2op/lightsim2grid/
 Author: Benjamin Donnot
@@ -356,13 +356,13 @@ cd ..
 
 Some tests are performed automatically on standard platform each time modifications are made in the lightsim2grid code.
 
-These tests include, for now, compilation on gcc (version 8, 12 and 13) and clang (version 11, 16 and 17).
+These tests include, for now, compilation on gcc (version 8, 14 and 15) and clang (version 11, 20 and 21).
 
 **NB** Intermediate versions of clang and gcc (*eg* gcc 9 or clang 12) are not tested regularly, but lightsim2grid used to work on these. 
-We suppose that if it works on *eg* clang 10 and clang 14 then it compiles also on all intermediate versions.
+We suppose that if it works on *eg* clang 11 and clang 21 then it compiles also on all intermediate versions.
 
 **NB** Package might work (we never tested it) on earlier version of these compilers. 
-The only "real" requirement for lightsim2grid is to have a compiler supporting c++11
+The only "real" requirement for lightsim2grid is to have a compiler supporting c++14
 (at least).
 
 ### Known issues

{lightsim2grid-0.12.0/LightSim2Grid.egg-info → lightsim2grid-0.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: LightSim2Grid
-Version: 0.12.0
+Version: 0.12.2
 Summary: LightSim2Grid implements a c++ backend targeting the Grid2Op platform.
 Home-page: https://github.com/grid2op/lightsim2grid/
 Author: Benjamin Donnot
@@ -356,13 +356,13 @@ cd ..
 
 Some tests are performed automatically on standard platform each time modifications are made in the lightsim2grid code.
 
-These tests include, for now, compilation on gcc (version 8, 12 and 13) and clang (version 11, 16 and 17).
+These tests include, for now, compilation on gcc (version 8, 14 and 15) and clang (version 11, 20 and 21).
 
 **NB** Intermediate versions of clang and gcc (*eg* gcc 9 or clang 12) are not tested regularly, but lightsim2grid used to work on these. 
-We suppose that if it works on *eg* clang 10 and clang 14 then it compiles also on all intermediate versions.
+We suppose that if it works on *eg* clang 11 and clang 21 then it compiles also on all intermediate versions.
 
 **NB** Package might work (we never tested it) on earlier version of these compilers. 
-The only "real" requirement for lightsim2grid is to have a compiler supporting c++11
+The only "real" requirement for lightsim2grid is to have a compiler supporting c++14
 (at least).
 
 ### Known issues

{lightsim2grid-0.12.0 → lightsim2grid-0.12.2}/README.md

@@ -282,13 +282,13 @@ cd ..
 
 Some tests are performed automatically on standard platform each time modifications are made in the lightsim2grid code.
 
-These tests include, for now, compilation on gcc (version 8, 12 and 13) and clang (version 11, 16 and 17).
+These tests include, for now, compilation on gcc (version 8, 14 and 15) and clang (version 11, 20 and 21).
 
 **NB** Intermediate versions of clang and gcc (*eg* gcc 9 or clang 12) are not tested regularly, but lightsim2grid used to work on these. 
-We suppose that if it works on *eg* clang 10 and clang 14 then it compiles also on all intermediate versions.
+We suppose that if it works on *eg* clang 11 and clang 21 then it compiles also on all intermediate versions.
 
 **NB** Package might work (we never tested it) on earlier version of these compilers. 
-The only "real" requirement for lightsim2grid is to have a compiler supporting c++11
+The only "real" requirement for lightsim2grid is to have a compiler supporting c++14
 (at least).
 
 ### Known issues

{lightsim2grid-0.12.0 → lightsim2grid-0.12.2}/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.12.0"
+__version__ = "0.12.2"
 
 __all__ = [
     "newtonpf",

{lightsim2grid-0.12.0 → lightsim2grid-0.12.2}/lightsim2grid/contingencyAnalysis.py

@@ -122,6 +122,16 @@ class __ContingencyAnalysis(object):
         raise RuntimeError("Impossible to add new topologies like this. Please use `add_single_contingency` "
                            "or `add_multiple_contingencies`.")
 
+    @property
+    def init_from_n_powerflow(self):
+        return self.computer.init_from_n_powerflow
+    
+    @init_from_n_powerflow.setter
+    def init_from_n_powerflow(self, val):
+        if bool(val) != val:
+            raise ValueError("The `init_from_n_powerflow` attribute must be a boolean.")
+        self.computer.init_from_n_powerflow = bool(val)
+        
     # TODO implement that !
     def __update_grid(self, backend_act):
         raise NotImplementedError("TODO !")

{lightsim2grid-0.12.0 → lightsim2grid-0.12.2}/lightsim2grid/gridmodel/from_pandapower/_aux_add_dc_line.py

@@ -38,7 +38,7 @@ def _aux_add_dc_line(model, pp_net, pp_to_ls):
     branch_from_id = pp_bus_to_ls(pp_net.dcline["from_bus"].values, pp_to_ls)
     branch_to_id = pp_bus_to_ls(pp_net.dcline["to_bus"].values, pp_to_ls)
     p_mw = -pp_net.dcline["p_mw"].values
-    if np.any(~np.isfinite(p_mw)):
+    if (~np.isfinite(p_mw)).any():
         warnings.warn("Some non finite values are found for p_mw, they have been replaced by 0.")
         p_mw[~np.isfinite(p_mw)] = 0.
         
@@ -47,20 +47,20 @@ def _aux_add_dc_line(model, pp_net, pp_to_ls):
     vm_or_pu = pp_net.dcline["vm_from_pu"].values
     vm_ex_pu = pp_net.dcline["vm_to_pu"].values
     
-    min_q_or = pp_net.dcline["min_q_from_mvar"].values
-    if np.any(~np.isfinite(min_q_or)):
+    min_q_or = pp_net.dcline["min_q_from_mvar"].values.copy()
+    if (~np.isfinite(min_q_or)).any():
         min_q_or[~np.isfinite(min_q_or)] = -SOME_KIND_OF_INF_FOR_PMIN_PMAX
         
-    max_q_or = pp_net.dcline["max_q_from_mvar"].values
-    if np.any(~np.isfinite(max_q_or)):
+    max_q_or = pp_net.dcline["max_q_from_mvar"].values.copy()
+    if (~np.isfinite(max_q_or)).any():
         max_q_or[~np.isfinite(max_q_or)] = SOME_KIND_OF_INF_FOR_PMIN_PMAX
         
-    min_q_ex = pp_net.dcline["min_q_to_mvar"].values
-    if np.any(~np.isfinite(min_q_ex)):
+    min_q_ex = pp_net.dcline["min_q_to_mvar"].values.copy()
+    if (~np.isfinite(min_q_ex)).any():
         min_q_ex[~np.isfinite(min_q_ex)] = -SOME_KIND_OF_INF_FOR_PMIN_PMAX
         
-    max_q_ex = pp_net.dcline["max_q_to_mvar"].values
-    if np.any(~np.isfinite(max_q_ex)):
+    max_q_ex = pp_net.dcline["max_q_to_mvar"].values.copy()
+    if (~np.isfinite(max_q_ex)).any():
         max_q_ex[~np.isfinite(max_q_ex)] = +SOME_KIND_OF_INF_FOR_PMIN_PMAX
                           
     model.init_dclines(branch_from_id.astype(np.int32),

{lightsim2grid-0.12.0 → lightsim2grid-0.12.2}/lightsim2grid/gridmodel/from_pandapower/_aux_add_load.py

@@ -29,7 +29,7 @@ def _aux_add_load(model, pp_net, pp_to_ls):
 
     ratio = 1.0
     if "scaling" in pp_net.load:
-        ratio = pp_net.load["scaling"].values
+        ratio = pp_net.load["scaling"].values.copy()
         ratio[~np.isfinite(ratio)] = 1.0
         
     model.init_loads(pp_net.load["p_mw"].values * ratio,

{lightsim2grid-0.12.0 → lightsim2grid-0.12.2}/lightsim2grid/gridmodel/from_pandapower/_aux_add_sgen.py

@@ -35,7 +35,7 @@ def _aux_add_sgen(model, pp_net, pp_to_ls):
         return
 
     if "min_p_mw" in pp_net.sgen:
-        min_p_mw = pp_net.sgen["min_p_mw"].values
+        min_p_mw = pp_net.sgen["min_p_mw"].values.copy()
     else:
         min_p_mw = np.zeros(pp_net.sgen.shape[0]) - SOME_KIND_OF_INF_FOR_PMIN_PMAX
     if np.any(~np.isfinite(min_p_mw)):
@@ -43,7 +43,7 @@ def _aux_add_sgen(model, pp_net, pp_to_ls):
     min_p_mw[~np.isfinite(min_p_mw)] = 0.
 
     if "max_p_mw" in pp_net.sgen:
-        max_p_mw = pp_net.sgen["max_p_mw"].values
+        max_p_mw = pp_net.sgen["max_p_mw"].values.copy()
     else:
         max_p_mw = np.zeros(pp_net.sgen.shape[0]) + SOME_KIND_OF_INF_FOR_PMIN_PMAX
     if np.any(~np.isfinite(max_p_mw)):
@@ -51,7 +51,7 @@ def _aux_add_sgen(model, pp_net, pp_to_ls):
     max_p_mw[~np.isfinite(max_p_mw)] = 0.
 
     if "min_q_mvar" in pp_net.sgen:
-        min_q_mvar = pp_net.sgen["min_q_mvar"].values
+        min_q_mvar = pp_net.sgen["min_q_mvar"].values.copy()
     else:
         min_q_mvar = np.zeros(pp_net.sgen.shape[0]) - SOME_KIND_OF_INF_FOR_PMIN_PMAX
     if np.any(~np.isfinite(min_q_mvar)):
@@ -59,7 +59,7 @@ def _aux_add_sgen(model, pp_net, pp_to_ls):
     min_q_mvar[~np.isfinite(min_q_mvar)] = 0.
 
     if "max_q_mvar" in pp_net.sgen:
-        max_q_mvar = pp_net.sgen["max_q_mvar"].values
+        max_q_mvar = pp_net.sgen["max_q_mvar"].values.copy()
     else:
         max_q_mvar = np.zeros(pp_net.sgen.shape[0]) + SOME_KIND_OF_INF_FOR_PMIN_PMAX
     if np.any(~np.isfinite(max_q_mvar)):

{lightsim2grid-0.12.0 → lightsim2grid-0.12.2}/lightsim2grid/gridmodel/from_pandapower/_aux_add_slack.py

@@ -96,7 +96,7 @@ def _aux_add_slack(
             # so I assume i need to add as many generators as number of slack bus
             nb_slack = len(slack_bus_ids)
             if "slack_weight" in pp_net.ext_grid:
-                slack_coeff = 1.0 * pp_net.ext_grid["slack_weight"].values
+                slack_coeff = 1.0 * pp_net.ext_grid["slack_weight"].values.copy()
             else:
                 slack_coeff = np.ones(nb_slack)
             slack_coeff_norm = slack_coeff / slack_coeff.sum()

{lightsim2grid-0.12.0 → lightsim2grid-0.12.2}/lightsim2grid/gridmodel/from_pandapower/_aux_add_trafo.py

@@ -40,7 +40,7 @@ def _aux_add_trafo(
                            "Some pp_net.trafo[\"parallel\"] != 1 it is not handled by lightsim yet.")
 
     # fix the missing values
-    tap_neutral = 1.0 * pp_net.trafo["tap_neutral"].values
+    tap_neutral = pp_net.trafo["tap_neutral"].values.copy()
     if np.any(~np.isfinite(tap_neutral)):
         warnings.warn("There were some Nan in the pp_net.trafo[\"tap_neutral\"], they have been replaced by 0")
     tap_neutral[~np.isfinite(tap_neutral)] = 0.
@@ -48,17 +48,17 @@ def _aux_add_trafo(
     if np.any(tap_neutral != 0.):
         raise RuntimeError("lightsim converter supposes that tap_neutral is 0 for the transformers")
 
-    tap_step_pct = 1.0 * pp_net.trafo["tap_step_percent"].values
+    tap_step_pct = pp_net.trafo["tap_step_percent"].values.copy()
     if np.any(~np.isfinite(tap_step_pct)):
         warnings.warn("There were some Nan in the pp_net.trafo[\"tap_step_percent\"], they have been replaced by 0")
     tap_step_pct[~np.isfinite(tap_step_pct)] = 0.
 
-    tap_pos = 1.0 * pp_net.trafo["tap_pos"].values
+    tap_pos = pp_net.trafo["tap_pos"].values.copy()
     if np.any(~np.isfinite(tap_pos)):
         warnings.warn("There were some Nan in the pp_net.trafo[\"tap_pos\"], they have been replaced by 0")
     tap_pos[~np.isfinite(tap_pos)] = 0.
 
-    shift_ = 1.0 * pp_net.trafo["shift_degree"].values
+    shift_ = pp_net.trafo["shift_degree"].values.copy()
     if np.any(~np.isfinite(tap_pos)):
         warnings.warn("There were some Nan in the pp_net.trafo[\"shift_degree\"], they have been replaced by 0")
     shift_[~np.isfinite(shift_)] = 0.
@@ -80,8 +80,8 @@ def _aux_add_trafo(
         if np.any(pp_net.trafo3w["tap_changer_type"].values == "Ideal"):
             raise RuntimeError("Ideal phase shifters are not modeled. Please remove all 3-winding trafos "
                                "with \"tap_changer_type\" set to \"Ideal\".")
-
-    tap_angles_ = 1.0 * pp_net.trafo["tap_step_degree"].values
+            
+    tap_angles_ = pp_net.trafo["tap_step_degree"].values
     if np.any(~np.isfinite(tap_angles_)):
         warnings.warn("There were some Nan in the pp_net.trafo[\"tap_step_degree\"], they have been replaced by 0")
     tap_angles_[~np.isfinite(tap_angles_)] = 0.
@@ -93,7 +93,7 @@ def _aux_add_trafo(
     trafo_model_is_t = True
     if "_options" in pp_net and "trafo_model" in pp_net._options:
         trafo_model_is_t = pp_net._options["trafo_model"] == "t"
-        
+    
     # compute physical parameters
     if version.parse(pp.__version__) >= _MIN_PP_VERSION_ADV_GRID_MODEL and pp_orig_file == "pandapower_v3":
         # use pandapower version 3 converter in this case.
@@ -133,6 +133,7 @@ def _aux_add_trafo(
                                           )
 
     # initialize the grid
+    do_ignore_tap_side_for_phase_shift = True
     model.init_trafo_pandapower(trafo_r,
                                 trafo_x,
                                 trafo_b,
@@ -141,7 +142,8 @@ def _aux_add_trafo(
                                 shift_,
                                 is_tap_hv_side,
                                 pp_bus_to_ls(pp_net.trafo["hv_bus"].values, pp_to_ls),
-                                pp_bus_to_ls(pp_net.trafo["lv_bus"].values, pp_to_ls))
+                                pp_bus_to_ls(pp_net.trafo["lv_bus"].values, pp_to_ls),
+                                do_ignore_tap_side_for_phase_shift)
 
     for tr_id, is_connected in enumerate(pp_net.trafo["in_service"].values):
         if not is_connected:

{lightsim2grid-0.12.0 → lightsim2grid-0.12.2}/lightsim2grid/gridmodel/from_pypowsybl/_from_pypowsybl.py

@@ -369,7 +369,8 @@ def init(net : pypo.network.Network,
                                "of the net (once per unit). Please upgrade pypowsybl."
                                "NB: phase tap change are handled by lightsim2grid)")
         shift_ = np.zeros(df_trafo.shape[0])
-    is_tap_hv_side = np.zeros(df_trafo.shape[0], dtype=bool)  # TODO    
+    # tap is side 2 in IIDM
+    is_tap_side1 = np.zeros(df_trafo.shape[0], dtype=bool)   
     trafo_r = df_trafo_pu["r"].values
     trafo_x = df_trafo_pu["x"].values
     trafo_h = (df_trafo_pu["g"].values + 1j * df_trafo_pu["b"].values)
@@ -398,9 +399,11 @@ def init(net : pypo.network.Network,
                      trafo_h,
                      ratio,
                      shift_,  # in degree !
-                     is_tap_hv_side,
+                     is_tap_side1,
                      tor_bus,
-                     tex_bus)    
+                     tex_bus,
+                     False,  # ignore_tap_side_for_phase_shift is False for pypowsybl
+                     )    
     for t_id, (is_or_disc, is_ex_disc) in enumerate(zip(tor_disco, tex_disco)):
         if is_or_disc or is_ex_disc:
             model.deactivate_trafo(t_id)

{lightsim2grid-0.12.0 → lightsim2grid-0.12.2}/lightsim2grid/lightSimBackend.py

@@ -1119,7 +1119,6 @@ class LightSimBackend(Backend):
                 
         if "pp_orig_file" in loader_kwargs and str(loader_kwargs["pp_orig_file"]) == loader_kwargs["pp_orig_file"]:
             pp_orig_file = str(loader_kwargs["pp_orig_file"])
-            
         self._grid = init_from_pandapower(self._init_pp_backend._grid,
                                           self._init_pp_backend.n_sub,
                                           self.n_busbar_per_sub,
@@ -1166,10 +1165,10 @@ class LightSimBackend(Backend):
         self.name_sub = pp_cls.name_sub
         self._grid.set_substation_names(self.name_sub)
 
-        self.prod_pu_to_kv = self._init_pp_backend.prod_pu_to_kv
-        self.load_pu_to_kv = self._init_pp_backend.load_pu_to_kv
-        self.lines_or_pu_to_kv = self._init_pp_backend.lines_or_pu_to_kv
-        self.lines_ex_pu_to_kv = self._init_pp_backend.lines_ex_pu_to_kv
+        self.prod_pu_to_kv = self._init_pp_backend.prod_pu_to_kv.copy()
+        self.load_pu_to_kv = self._init_pp_backend.load_pu_to_kv.copy()
+        self.lines_or_pu_to_kv = self._init_pp_backend.lines_or_pu_to_kv.copy()
+        self.lines_ex_pu_to_kv = self._init_pp_backend.lines_ex_pu_to_kv.copy()
 
         # TODO storage check grid2op version and see if storage is available !
         if self.__has_storage:
@@ -1365,13 +1364,14 @@ class LightSimBackend(Backend):
         # TODO speed optimization here to read it "better"
         cls = type(self)
         # handle object in topo vect
-        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)
+        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)
+            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.bus1_id for el in self._grid.get_lines()]),
                                         np.array([el.bus1_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)
@@ -1383,7 +1383,8 @@ class LightSimBackend(Backend):
         # handle shunts (not in topo vect)
         if cls.shunts_data_available:
             self.sh_bus.flags.writeable = True
-            self.sh_bus[:] = cls.global_bus_to_local(self._grid.get_shunts().get_bus_id(),
+            sh_bus_global = np.asarray([el.bus_id for el in self._grid.get_shunts()])
+            self.sh_bus[:] = cls.global_bus_to_local(sh_bus_global,
                                                      cls.shunt_to_subid).copy()
             self.sh_bus.flags.writeable = False
         
@@ -1403,14 +1404,6 @@ class LightSimBackend(Backend):
             self._init_pp_backend.__class__ = type(self._init_pp_backend).init_grid(type(self))
         self._backend_action_class = _BackendAction.init_grid(type(self))
         
-        # self._init_action_to_set = self._backend_action_class()
-        # try:
-        #     _init_action_to_set = self.get_action_to_set()
-        # except TypeError:
-        #     # I am in legacy grid2op version...
-        #     _init_action_to_set = _dont_use_get_action_to_set_legacy(self)
-            
-        # self._init_action_to_set += _init_action_to_set
         if self.prod_pu_to_kv is not None:
             assert np.isfinite(self.prod_pu_to_kv).all()
         if self.load_pu_to_kv is not None:
@@ -1422,6 +1415,13 @@ class LightSimBackend(Backend):
         if self.__has_storage and self.n_storage > 0 and self.storage_pu_to_kv is not None:
             assert np.isfinite(self.storage_pu_to_kv).all()
 
+        if self._dist_slack_non_renew and not type(self).redispatching_unit_commitment_availble:
+            raise Grid2OpException("You asked to distribute the slack on renewable generators, "
+                                   "yet the environment does not seem to know which generators are "
+                                   "renewables or not. Make sure env.redispatching_unit_commitment_availble is True "
+                                   "(this include having a 'prods_charac.csv' properly formatted and "
+                                   "at the right location)")
+            
     def _count_object_per_bus(self):
         # should be called only when self.topo_vect and self.shunt_topo_vect are set
         # todo factor that more properly to update it when it's modified, and not each time
@@ -1459,7 +1459,12 @@ class LightSimBackend(Backend):
             # self.init_pp_backend.close()  # should not close it, the same init_pp_backend is used when copied
             self._init_pp_backend = None
         self._reset_res_pointers()
-        self._fill_nans()
+        try:
+            self._fill_nans()
+        except AttributeError:
+            # some attributes are not completely filled
+            
+            pass
         self._grid = None
         self.__me_at_init = None
 
@@ -1487,11 +1492,14 @@ class LightSimBackend(Backend):
                 self._need_islanding_detection = True
         
         # update the injections
+        gen_v = backendAction.prod_v.values.copy()
+        gen_v[~backendAction.prod_v.changed] = 0.  # sometimes there were nan here, which lead to a warnings
+        gen_v /= self.prod_pu_to_kv
         try:
             self._grid.update_gens_p(backendAction.prod_p.changed,
                                      backendAction.prod_p.values)
             self._grid.update_gens_v(backendAction.prod_v.changed,
-                                     backendAction.prod_v.values / self.prod_pu_to_kv)
+                                     gen_v)
             self._grid.update_loads_p(backendAction.load_p.changed,
                                       backendAction.load_p.values)
             self._grid.update_loads_q(backendAction.load_q.changed,

{lightsim2grid-0.12.0 → lightsim2grid-0.12.2}/setup.py

@@ -14,7 +14,7 @@ import warnings
 from pybind11.setup_helpers import Pybind11Extension, build_ext
 
 
-__version__ = "0.12.0"
+__version__ = "0.12.2"
 KLU_SOLVER_AVAILABLE = False
 
 # Try to link against SuiteSparse (if available)
@@ -240,8 +240,12 @@ if "PATH_CKTSO" in os.environ:
     libcktso_path = None
     if include_cktso:
         if sys.platform.startswith("linux") or sys.platform.startswith("darwin"):
-            libcktso_path = os.path.join(path_cktso, "ubuntu1804_x64_gcc750/libcktso.so")  # TODO CHANGE THAT !
-            if not os.path.exists(libcktso_path):
+            include_cktso = False
+            for el in ["ubuntu2004_x64_gcc940", "ubuntu1804_x64_gcc750"]:
+                libcktso_path = os.path.join(path_cktso, f"{el}/libcktso.so")  # TODO CHANGE THAT !
+                if os.path.exists(libcktso_path):
+                    include_cktso = True
+            if not include_cktso:
                 print(f"WARNING: cannot locate the CKTSO shared object that should be at: {libcktso_path}")
                 include_cktso = False
                 libcktso_path = None

{lightsim2grid-0.12.0 → lightsim2grid-0.12.2}/src/ChooseSolver.hpp

@@ -85,14 +85,27 @@ class ChooseSolver final
             return res;
         }
         
-        bool is_dc(const SolverType & type){
-            bool res;
+        bool is_dc(const SolverType & type) const noexcept{
+            bool res = false;
             res = (type == SolverType::DC) || 
                   (type == SolverType::KLUDC) || 
                   (type == SolverType::NICSLUDC) ||
                   (type == SolverType::CKTSODC);
             return res;
         }
+        bool is_fdpf(const SolverType & type) const noexcept{
+            bool res = false;
+            res = (type == SolverType::FDPF_XB_SparseLU) || 
+                  (type == SolverType::FDPF_BX_SparseLU) || 
+                  (type == SolverType::FDPF_XB_KLU) ||
+                  (type == SolverType::FDPF_BX_KLU) ||
+                  (type == SolverType::FDPF_XB_NICSLU) ||
+                  (type == SolverType::FDPF_BX_NICSLU) ||
+                  (type == SolverType::FDPF_XB_CKTSO) ||
+                  (type == SolverType::FDPF_BX_CKTSO)
+                  ;
+            return res;
+        }
         SolverType get_type() const {return _solver_type;}
 
         // TODO DO that for all solvers

{lightsim2grid-0.12.0 → lightsim2grid-0.12.2}/src/GridModel.cpp

@@ -218,7 +218,7 @@ void GridModel::set_orig_to_ls(const IntVect & orig_to_ls){
     }
 }
 
-void GridModel::set_ls_to_orig_internal(const IntVect & ls_to_orig){
+void GridModel::set_ls_to_orig_internal(const IntVect & ls_to_orig) noexcept{
     if(ls_to_orig.size() == 0){
         _ls_to_orig = IntVect();
         _orig_to_ls = IntVect();
@@ -354,12 +354,12 @@ void GridModel::check_solution_q_values_onegen(CplxVect & res,
     if(check_q_limits)
     {
         // i need to check the reactive can be absorbed / produced by the generator
-        real_type new_q = my_zero_;
+        real_type new_q = BaseConstants::my_zero_;
         real_type react_this_bus = std::imag(res.coeff(gen.bus_id));
         if((react_this_bus >= gen.min_q_mvar) && (react_this_bus <= gen.max_q_mvar))
         {
             // this generator is able to handle all reactive
-            new_q = my_zero_;
+            new_q = BaseConstants::my_zero_;
         }else if(react_this_bus < gen.min_q_mvar){
             // generator cannot absorb enough reactive power
             new_q = react_this_bus - gen.min_q_mvar; //ex. need -50, qmin is -30, remains: (-50) - (-30) = -20 MVAr
@@ -370,7 +370,7 @@ void GridModel::check_solution_q_values_onegen(CplxVect & res,
         res.coeffRef(gen.bus_id) = {std::real(res.coeff(gen.bus_id)), new_q};
     }else{
         // the q value for the bus at which the generator is connected will be 0
-        res.coeffRef(gen.bus_id) = {std::real(res.coeff(gen.bus_id)), my_zero_};
+        res.coeffRef(gen.bus_id) = {std::real(res.coeff(gen.bus_id)), BaseConstants::my_zero_};
     }
 }
 
@@ -390,7 +390,7 @@ void GridModel::check_solution_q_values(CplxVect & res, bool check_q_limits) con
         {
             // slack bus, by definition, can handle all active value
             // This is probably not the case with distributed slack !
-            res.coeffRef(gen.bus_id) = {my_zero_, std::imag(res.coeff(gen.bus_id))};
+            res.coeffRef(gen.bus_id) = {BaseConstants::my_zero_, std::imag(res.coeff(gen.bus_id))};
         }
     }
 
@@ -433,7 +433,7 @@ CplxVect GridModel::check_solution(const CplxVect & V_proposed, bool check_q_lim
                                                    id_me_to_ac_solver_,
                                                    static_cast<int>(V_proposed.size())
                                                    );
-    if(abs(sn_mva_- 1.) > _tol_equal_float) res *= sn_mva_;
+    if(abs(sn_mva_- 1.) > BaseConstants::_tol_equal_float) res *= sn_mva_;
 
     // now check reactive values for buses where there are generators and active values of slack bus
     check_solution_q_values(res, check_q_limits);
@@ -442,7 +442,7 @@ CplxVect GridModel::check_solution(const CplxVect & V_proposed, bool check_q_lim
     for(int bus_id = 0; bus_id < nb_bus; ++bus_id)
     {
         if(substations_.is_bus_connected(GlobalBusId(bus_id))) continue;
-        res.coeffRef(bus_id) = my_zero_;
+        res.coeffRef(bus_id) = BaseConstants::my_zero_;
     }
     return res;
 };
@@ -543,7 +543,7 @@ CplxVect GridModel::pre_process_solver(
     CplxVect V = CplxVect::Constant(nb_bus_solver, init_vm_pu_);
     for(int bus_solver_id = 0; bus_solver_id < nb_bus_solver; ++bus_solver_id){
         GlobalBusId bus_me_id = id_solver_to_me[bus_solver_id]; 
-        if(bus_me_id.cast_int() == _deactivated_bus_id){
+        if(bus_me_id.cast_int() == BaseConstants::_deactivated_bus_id){
             //TODO DEBUG MODE : only in debug mode
             std::ostringstream exc_;
             exc_ << "GridModel::pre_process_solver: the bus with solver id ";
@@ -574,12 +574,12 @@ CplxVect GridModel::_get_results_back_to_orig_nodes(const CplxVect & res_tmp,
                                                     std::vector<SolverBusId> & id_me_to_solver,
                                                     int size)
 {
-    CplxVect res = CplxVect::Constant(size, {init_vm_pu_, my_zero_});
+    CplxVect res = CplxVect::Constant(size, {init_vm_pu_, BaseConstants::my_zero_});
     const int nb_bus = static_cast<int>(substations_.nb_bus());
     for (int bus_id_me=0; bus_id_me < nb_bus; ++bus_id_me){
         if(!substations_.is_bus_connected(GlobalBusId(bus_id_me))) continue;  // nothing is done if the bus is connected
         SolverBusId bus_id_solver = id_me_to_solver[bus_id_me];
-        if(bus_id_solver.cast_int() == _deactivated_bus_id){
+        if(bus_id_solver.cast_int() == BaseConstants::_deactivated_bus_id){
             std::ostringstream exc_;
             exc_ << "GridModel::_get_results_back_to_orig_nodes: the bus with id ";
             exc_ << bus_id_me;
@@ -622,7 +622,7 @@ void GridModel::init_converter_bus_id(std::vector<SolverBusId>& id_me_to_solver,
     //TODO get disconnected bus !!! (and have some conversion for it)
     //1. init the conversion bus
     const int nb_bus_init = static_cast<int>(substations_.nb_bus());
-    id_me_to_solver = std::vector<SolverBusId>(nb_bus_init, SolverBusId(_deactivated_bus_id));  // by default, if a bus is disconnected, then it has a -1 there
+    id_me_to_solver = std::vector<SolverBusId>(nb_bus_init, SolverBusId(BaseConstants::_deactivated_bus_id));  // by default, if a bus is disconnected, then it has a -1 there
     id_solver_to_me = std::vector<GlobalBusId>();
     id_solver_to_me.reserve(nb_bus_init);
     int bus_id_solver = 0;
@@ -648,12 +648,12 @@ void GridModel::init_slack_bus(const CplxVect & Sbus,
                                const GlobalBusIdVect & slack_bus_id_me,
                                SolverBusIdVect & slack_bus_id_solver)
 {
-    slack_bus_id_solver = SolverBusIdVect::Constant(slack_bus_id_me.size(), SolverBusId(_deactivated_bus_id));
+    slack_bus_id_solver = SolverBusIdVect::Constant(slack_bus_id_me.size(), SolverBusId(BaseConstants::_deactivated_bus_id));
 
     size_t i = 0;
     for(const GlobalBusId & el: slack_bus_id_me) {
         SolverBusId tmp = id_me_to_solver[el.cast_int()];
-        if(tmp.cast_int() == _deactivated_bus_id){
+        if(tmp.cast_int() == BaseConstants::_deactivated_bus_id){
             std::ostringstream exc_;
             exc_ << "GridModel::init_slack_bus: One of the slack bus is disconnected.";
             exc_ << " You can check bus with global id GlobalBusId : ";
@@ -667,7 +667,7 @@ void GridModel::init_slack_bus(const CplxVect & Sbus,
         ++i;
     }
     
-    if(is_in_vect(_deactivated_bus_id, slack_bus_id_solver)){
+    if(GenericContainer::is_in_vect(BaseConstants::_deactivated_bus_id, slack_bus_id_solver)){
         // TODO improve error message with the gen_id
         // TODO DEBUG MODE: only check that in debug mode
         throw std::runtime_error("GridModel::init_Sbus: One of the slack bus is disconnected !");
@@ -710,7 +710,7 @@ void GridModel::fillSbus_me(CplxVect & Sbus, bool ac, const std::vector<SolverBu
     storages_.fillSbus(Sbus, id_me_to_solver, ac);
     generators_.fillSbus(Sbus, id_me_to_solver, ac);
     dc_lines_.fillSbus(Sbus, id_me_to_solver, ac);
-    if (abs(sn_mva_ - 1.0) > _tol_equal_float) Sbus /= sn_mva_;
+    if (abs(sn_mva_ - 1.0) > BaseConstants::_tol_equal_float) Sbus /= sn_mva_;
     // in dc mode, this is used for the phase shifter, this should not be divided by sn_mva_ !
     trafos_.hack_Sbus_for_dc_phase_shifter(Sbus, ac, id_me_to_solver);
 }
@@ -743,7 +743,7 @@ void GridModel::fillpv_pq(const std::vector<SolverBusId>& id_me_to_solver,
     dc_lines_.fillpv(bus_pv, has_bus_been_added, slack_bus_id_solver, id_me_to_solver);
 
     for(int bus_id = 0; bus_id< nb_bus; ++bus_id){
-        if(is_in_vect(bus_id, slack_bus_id_solver)) continue;  // slack bus is not PQ either
+        if(GenericContainer::is_in_vect(bus_id, slack_bus_id_solver)) continue;  // slack bus is not PQ either
         if(has_bus_been_added[bus_id]) continue; // a pv bus cannot be PQ
         bus_pq.push_back(bus_id);
         has_bus_been_added[bus_id] = true;  // don't add it a second time