LightSim2Grid 0.8.0__tar.gz → 0.8.1.dev0__tar.gz

{LightSim2Grid-0.8.0 → LightSim2Grid-0.8.1.dev0/LightSim2Grid.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: LightSim2Grid
-Version: 0.8.0
+Version: 0.8.1.dev0
 Summary: LightSim2Grid implements a c++ backend targeting the Grid2Op platform.
 Home-page: https://github.com/BDonnot/lightsim2grid/
 Author: Benjamin Donnot

{LightSim2Grid-0.8.0/LightSim2Grid.egg-info → LightSim2Grid-0.8.1.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: LightSim2Grid
-Version: 0.8.0
+Version: 0.8.1.dev0
 Summary: LightSim2Grid implements a c++ backend targeting the Grid2Op platform.
 Home-page: https://github.com/BDonnot/lightsim2grid/
 Author: Benjamin Donnot

{LightSim2Grid-0.8.0 → LightSim2Grid-0.8.1.dev0}/lightsim2grid/__init__.py

@@ -5,7 +5,7 @@
 # you can obtain one at http://mozilla.org/MPL/2.0/.
 # SPDX-License-Identifier: MPL-2.0
 # This file is part of LightSim2grid, LightSim2grid implements a c++ backend targeting the Grid2Op platform.
-__version__ = "0.8.0"
+__version__ = "0.8.1.dev0"
 
 __all__ = ["newtonpf", "SolverType", "ErrorType", "solver"]
 

{LightSim2Grid-0.8.0 → LightSim2Grid-0.8.1.dev0}/lightsim2grid/lightSimBackend.py

@@ -22,6 +22,12 @@ try:
 except ImportError as exc_:
     from grid2op.Action._BackendAction import _BackendAction
 
+try:
+    from grid2op.Space import DEFAULT_N_BUSBAR_PER_SUB
+except ImportError:
+    # for backward compatibility with grid2op <= 1.9.8
+    DEFAULT_N_BUSBAR_PER_SUB = 2
+    
 try:
     from typing import Literal
 except ImportError:
@@ -94,6 +100,10 @@ class LightSimBackend(Backend):
                              loader_kwargs,
                              stop_if_load_disco,
                              stop_if_gen_disco)
+        
+        # backward compat: need to define it if not done by grid2op
+        if not hasattr(self, "_can_be_copied"):
+            self._can_be_copied = can_be_copied
 
         #: .. versionadded:: 0.8.0
         #: Which type of grid format can be read by your backend.
@@ -130,6 +140,9 @@ class LightSimBackend(Backend):
         self._timer_preproc = 0.
         self._timer_postproc = 0.
         self._timer_solver = 0.
+        self._timer_read_data_back = 0.
+        self._timer_fetch_data_cpp = 0.
+        self._timer_apply_act = 0.
 
         self.next_prod_p = None  # this vector is updated with the action that will modify the environment
         # it is done to keep track of the redispatching
@@ -175,6 +188,7 @@ class LightSimBackend(Backend):
         self.sh_p = None
         self.sh_q = None
         self.sh_v = None
+        self.sh_theta = None
         self.sh_bus = None
 
         # voltage angle
@@ -209,6 +223,9 @@ class LightSimBackend(Backend):
         self._timer_postproc = 0.
         self._timer_preproc = 0.
         self._timer_solver = 0.
+        self._timer_read_data_back = 0.
+        self._timer_fetch_data_cpp = 0.
+        self._timer_apply_act = 0.
 
         # hack for the storage unit:
         # in grid2op, for simplicity, I suppose that if a storage is alone on a busbar, and
@@ -221,6 +238,16 @@ class LightSimBackend(Backend):
         # backend SHOULD not do these kind of stuff
         self._idx_hack_storage = []
         
+        # speed optimization
+        self._lineor_res = None
+        self._lineex_res = None
+        self._load_res = None
+        self._gen_res = None
+        self._shunt_res = None
+        self._trafo_hv_res = None
+        self._trafo_lv_res = None
+        self._storage_res = None
+        
     def _aux_init_super(self, 
                         detailed_infos_for_cascading_failures,
                         can_be_copied,
@@ -255,7 +282,11 @@ class LightSimBackend(Backend):
                           "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"):
+            # do not forget to propagate this if needed
+            self.can_handle_more_than_2_busbar()
+            
     def turnedoff_no_pv(self):
         self._turned_off_pv = False
         self._grid.turnedoff_no_pv()
@@ -263,23 +294,6 @@ class LightSimBackend(Backend):
     def turnedoff_pv(self):
         self._turned_off_pv = True
         self._grid.turnedoff_pv()
-        
-    def _fill_theta(self):
-        # line_or_theta = np.empty(self.n_line)
-        self.line_or_theta[:self.__nb_powerline] = self._grid.get_lineor_theta()
-        self.line_or_theta[self.__nb_powerline:] = self._grid.get_trafohv_theta()
-
-        # line_ex_theta = np.empty(self.n_line)
-        self.line_ex_theta[:self.__nb_powerline] = self._grid.get_lineex_theta()
-        self.line_ex_theta[self.__nb_powerline:] = self._grid.get_trafolv_theta()
-
-        # line_or_theta = np.concatenate((self._grid.get_lineor_theta(), self._grid.get_trafohv_theta()))
-        # line_ex_theta = np.concatenate((self._grid.get_lineex_theta(), self._grid.get_trafolv_theta()))
-        self.load_theta[:] = self._grid.get_load_theta()
-        self.gen_theta[:] = self._grid.get_gen_theta()
-
-        if self.__has_storage:
-            self.storage_theta[:] = self._grid.get_storage_theta()
 
     def get_theta(self):
         """
@@ -466,6 +480,7 @@ class LightSimBackend(Backend):
         else:
             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
     
     def _should_not_have_to_do_this(self, path=None, filename=None):
         # included in grid2op now !
@@ -821,6 +836,7 @@ class LightSimBackend(Backend):
             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)
@@ -857,6 +873,7 @@ class LightSimBackend(Backend):
         self.__me_at_init = self._grid.copy()
         self.__init_topo_vect = np.ones(cls.dim_topo, dtype=dt_int)
         self.__init_topo_vect[:] = self.topo_vect
+        self.sh_bus[:] = 1
         
     def assert_grid_correct_after_powerflow(self):
         """
@@ -934,6 +951,7 @@ class LightSimBackend(Backend):
         """
         Specific implementation of the method to apply an action modifying a powergrid in the pandapower format.
         """
+        tick = time.perf_counter()
         active_bus, *_, topo__, shunts__ = backendAction()
 
         # change the overall topology
@@ -977,17 +995,40 @@ class LightSimBackend(Backend):
                         self._grid.change_bus_shunt(sh_id, type(self).local_bus_to_global_int(new_bus, self.shunt_to_subid[sh_id]))
                     else:
                         self._grid.change_bus_shunt(sh_id, self.shunt_to_subid[sh_id] + (new_bus == 2) * type(self).n_sub)
+            # remember the topology not to need to read it back from the grid
+            self.sh_bus[shunt_bus.changed] = shunt_bus.values[shunt_bus.changed]
             for sh_id, new_p in shunt_p:
                 self._grid.change_p_shunt(sh_id, new_p)
             for sh_id, new_q in shunt_q:
                 self._grid.change_q_shunt(sh_id, new_q)
         
         self._handle_dist_slack()
-    
+        self._timer_apply_act += time.perf_counter() - tick
+        
     def _handle_dist_slack(self):
         if self._dist_slack_non_renew:
             self._grid.update_slack_weights(type(self).gen_redispatchable)
 
+    def _fetch_grid_data(self):
+        beg_test = time.perf_counter()
+        if self._lineor_res is None:
+            self._lineor_res = self._grid.get_lineor_res_full()
+        if self._lineex_res is None:
+            self._lineex_res = self._grid.get_lineex_res_full()
+        if self._load_res is None:
+            self._load_res = self._grid.get_loads_res_full()
+        if self._gen_res is None:
+            self._gen_res = self._grid.get_gen_res_full()
+        if self._trafo_hv_res is None:
+            self._trafo_hv_res = self._grid.get_trafohv_res_full()
+        if self._trafo_lv_res is None:
+            self._trafo_lv_res = self._grid.get_trafolv_res_full()
+        if self._storage_res is None:
+            self._storage_res = self._grid.get_storages_res_full()
+        if self._shunt_res is None:
+            self._shunt_res = self._grid.get_shunts_res_full()
+        self._timer_fetch_data_cpp += time.perf_counter() - beg_test
+            
     def runpf(self, is_dc=False):
         my_exc_ = None
         res = False
@@ -1012,9 +1053,7 @@ class LightSimBackend(Backend):
                     self._grid.deactivate_result_computation()
                     # if I init with dc values, it should depends on previous state
                     self.V[:] = self._grid.get_init_vm_pu()  # see issue 30
-                    # print(f"{self.V[:14] = }")
                     Vdc = self._grid.dc_pf(copy.deepcopy(self.V), self.max_it, self.tol)
-                    # print(f"{Vdc[:14] = }")
                     self._grid.reactivate_result_computation()
                     if Vdc.shape[0] == 0:
                         raise BackendError(f"Divergence of DC powerflow (non connected grid) at the initialization of AC powerflow. Detailed error: {self._grid.get_dc_solver().get_error()}")
@@ -1043,24 +1082,31 @@ class LightSimBackend(Backend):
                 
                 self.timer_gridmodel_xx_pf += self._grid.timer_last_ac_pf
                 # timer_gridmodel_xx_pf takes all the time within the gridmodel "ac_pf"
-                   
+            
+            beg_readback = time.perf_counter()
             self.V[:] = V
+            self._fetch_grid_data()
+        
             (self.p_or[:self.__nb_powerline],
              self.q_or[:self.__nb_powerline],
              self.v_or[:self.__nb_powerline],
-             self.a_or[:self.__nb_powerline]) = self._grid.get_lineor_res()
+             self.a_or[:self.__nb_powerline],
+             self.line_or_theta[:self.__nb_powerline]) = self._lineor_res
             (self.p_or[self.__nb_powerline:],
              self.q_or[self.__nb_powerline:],
              self.v_or[self.__nb_powerline:],
-             self.a_or[self.__nb_powerline:]) = self._grid.get_trafohv_res()
+             self.a_or[self.__nb_powerline:],
+             self.line_or_theta[self.__nb_powerline:]) = self._trafo_hv_res
             (self.p_ex[:self.__nb_powerline],
              self.q_ex[:self.__nb_powerline],
              self.v_ex[:self.__nb_powerline],
-             self.a_ex[:self.__nb_powerline]) = self._grid.get_lineex_res()
+             self.a_ex[:self.__nb_powerline],
+             self.line_ex_theta[:self.__nb_powerline]) = self._lineex_res
             (self.p_ex[self.__nb_powerline:],
              self.q_ex[self.__nb_powerline:],
              self.v_ex[self.__nb_powerline:],
-             self.a_ex[self.__nb_powerline:]) = self._grid.get_trafolv_res()
+             self.a_ex[self.__nb_powerline:],
+             self.line_ex_theta[self.__nb_powerline:]) = self._trafo_lv_res
 
             self.a_or *= 1000.  # kA in lightsim, A expected in grid2op
             self.a_ex *= 1000.  # kA in lightsim, A expected in grid2op
@@ -1070,11 +1116,12 @@ class LightSimBackend(Backend):
             self.a_ex[~np.isfinite(self.a_ex)] = 0.
             self.v_ex[~np.isfinite(self.v_ex)] = 0.
 
-            self.load_p[:], self.load_q[:], self.load_v[:] = self._grid.get_loads_res()
-            self.prod_p[:], self.prod_q[:], self.prod_v[:] = self._grid.get_gen_res()
+            self.load_p[:], self.load_q[:], self.load_v[:], self.load_theta[:] = self._load_res
+            self.prod_p[:], self.prod_q[:], self.prod_v[:], self.gen_theta[:] = self._gen_res
             if self.__has_storage:
-                self.storage_p[:], self.storage_q[:], self.storage_v[:] = self._grid.get_storages_res()
+                self.storage_p[:], self.storage_q[:], self.storage_v[:], self.storage_theta[:] = self._storage_res
             self.storage_v[self.storage_v == -1.] = 0.  # voltage is 0. for disconnected elements in grid2op
+            self._timer_read_data_back +=  time.perf_counter() - beg_readback
             
             self.next_prod_p[:] = self.prod_p
 
@@ -1092,8 +1139,6 @@ class LightSimBackend(Backend):
 
             if type(self).shunts_data_available:
                 self._set_shunt_info()
-            
-            self._fill_theta()
 
             if (self.line_or_theta >= 1e6).any() or (self.line_ex_theta >= 1e6).any():
                 raise BackendError(f"Some theta are above 1e6 which should not be happening !")
@@ -1111,6 +1156,7 @@ class LightSimBackend(Backend):
             if is_dc:
                 # set back the solver to its previous state
                 self._grid.change_solver(self.__current_solver_type)
+            self._grid.tell_solver_need_reset()
 
         # TODO grid2op compatibility ! (was a single returned element before storage were introduced)
         if self.__has_storage:
@@ -1143,6 +1189,7 @@ class LightSimBackend(Backend):
             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:
@@ -1151,7 +1198,18 @@ class LightSimBackend(Backend):
             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()
+    
+    def _reset_res_pointers(self):
+        self._lineor_res  = None
+        self._lineex_res = None
+        self._load_res = None
+        self._gen_res = None
+        self._trafo_hv_res = None
+        self._trafo_lv_res = None
+        self._storage_res = None
+        self._shunt_res = None
+        
     def __deepcopy__(self, memo):
         result = self.copy()
         memo[id(self)] = result
@@ -1188,6 +1246,11 @@ class LightSimBackend(Backend):
                             self._loader_kwargs,
                             self._stop_if_load_disco,
                             self._stop_if_gen_disco)
+        
+        # for backward compat (attribute was not necessarily present in early grid2op)
+        if not hasattr(res, "_can_be_copied"):
+            res._can_be_copied = self._can_be_copied
+            
         res.comp_time = self.comp_time
         res.timer_gridmodel_xx_pf = self.timer_gridmodel_xx_pf
 
@@ -1202,10 +1265,12 @@ class LightSimBackend(Backend):
                            "_big_topo_to_obj", "dim_topo",
                            "_idx_hack_storage",
                            "_timer_preproc", "_timer_postproc", "_timer_solver",
+                           "_timer_read_data_back", "_timer_apply_act",
                            "supported_grid_format", 
                            "max_it", "tol", "_turned_off_pv", "_dist_slack_non_renew",
                            "_use_static_gen", "_loader_method", "_loader_kwargs",
-                           "_stop_if_load_disco", "_stop_if_gen_disco"
+                           "_stop_if_load_disco", "_stop_if_gen_disco",
+                           "_timer_fetch_data_cpp"
                            ]
         for attr_nm in li_regular_attr:
             if hasattr(self, attr_nm):
@@ -1223,7 +1288,7 @@ class LightSimBackend(Backend):
                        "load_p", "load_q", "load_v",
                        "prod_p", "prod_q", "prod_v",
                        "storage_p", "storage_q", "storage_v",
-                       "sh_p", "sh_q", "sh_v", "sh_bus",
+                       "sh_p", "sh_q", "sh_v", "sh_bus", "sh_theta",
                        "line_or_theta", "line_ex_theta", "load_theta", "gen_theta", "storage_theta",                   
                        ]
         for attr_nm in li_attr_npy:
@@ -1265,7 +1330,10 @@ class LightSimBackend(Backend):
         res._backend_action_class = self._backend_action_class  # this is const
         res.__init_topo_vect = self.__init_topo_vect
         res.available_solvers = self.available_solvers
-
+        res._reset_res_pointers()
+        res._fetch_grid_data()
+        
+        # assign back "self" attributes
         self._grid = mygrid
         self.init_pp_backend = inippbackend
         self.__me_at_init = __me_at_init
@@ -1313,15 +1381,29 @@ class LightSimBackend(Backend):
     def shunt_info(self):
         return self.cst_1 * self.sh_p, self.cst_1 * self.sh_q, self.cst_1 * self.sh_v, self.sh_bus
 
+    def _compute_shunt_bus_with_compat(self, shunt_bus):
+        cls = type(self)
+        if hasattr(cls, "global_bus_to_local"):
+            self.sh_bus[:] = cls.global_bus_to_local(shunt_bus, cls.shunt_to_subid)
+        else:
+            res = (1 * shunt_bus).astype(dt_int)  # make a copy
+            if hasattr(cls, "n_busbar_per_sub"):
+                n_busbar_per_sub = cls.n_busbar_per_sub
+            else:
+                # backward compat when this was not defined:
+                n_busbar_per_sub = DEFAULT_N_BUSBAR_PER_SUB
+            for i in range(n_busbar_per_sub):
+                res[(i * cls.n_sub <= shunt_bus) & (shunt_bus < (i+1) * cls.n_sub)] = i + 1
+            res[shunt_bus == -1] = -1
+            self.sh_bus[:] = res
+        
     def _set_shunt_info(self):
-        self.sh_p[:], self.sh_q[:], self.sh_v[:]  = self._grid.get_shunts_res()
-        shunt_bus = np.array([self._grid.get_bus_shunt(i) for i in range(type(self).n_shunt)], dtype=dt_int)
-        res_bus = np.ones(shunt_bus.shape[0], dtype=dt_int)  # by default all shunts are on bus one
-        res_bus[shunt_bus >= self.__nb_bus_before] = 2  # except the one that are connected to bus 2
-        res_bus[shunt_bus == -1] = -1  # or the one that are disconnected
-        self.sh_bus[:] = res_bus
+        tick = time.perf_counter()
+        self.sh_p[:], self.sh_q[:], self.sh_v[:], self.sh_theta[:]  = self._shunt_res
         self.sh_v[self.sh_v == -1.] = 0.  # in grid2op disco element have voltage of 0. and -1.
-
+        self._timer_read_data_back += time.perf_counter() - tick
+        # self._timer_fetch_data_cpp += time.perf_counter() - tick
+        
     def _disconnect_line(self, id_):
         self.topo_vect[self.line_ex_pos_topo_vect[id_]] = -1
         self.topo_vect[self.line_or_pos_topo_vect[id_]] = -1
@@ -1339,10 +1421,14 @@ class LightSimBackend(Backend):
         self._grid.unset_changes()
         self._grid.change_solver(self.__current_solver_type)
         self._handle_turnedoff_pv()
-        self.topo_vect[:] = self.__init_topo_vect
         self.comp_time = 0.
         self.timer_gridmodel_xx_pf = 0.
         self._timer_postproc = 0.
         self._timer_preproc = 0.
         self._timer_solver = 0.
+        self._timer_read_data_back = 0.
+        self._timer_fetch_data_cpp = 0.
+        self._timer_apply_act = 0.
         self._grid.tell_solver_need_reset()
+        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

{LightSim2Grid-0.8.0 → LightSim2Grid-0.8.1.dev0}/setup.py

@@ -14,7 +14,7 @@ import warnings
 from pybind11.setup_helpers import Pybind11Extension, build_ext
 
 
-__version__ = "0.8.0"
+__version__ = "0.8.1.dev0"
 KLU_SOLVER_AVAILABLE = False
 
 # Try to link against SuiteSparse (if available)
@@ -136,6 +136,7 @@ extra_compile_args = extra_compile_args_tmp
 extra_compile_args += [f"-DVERSION_MAJOR={VERSION_MAJOR}",
                        f"-DVERSION_MEDIUM={VERSION_MEDIUM}",
                        f"-DVERSION_MINOR={VERSION_MINOR}"]
+extra_compile_args += [f"-DVERSION=\"{__version__}\""]
 src_files = ['src/main.cpp',
              "src/powerflow_algorithm/GaussSeidelAlgo.cpp",
              "src/powerflow_algorithm/GaussSeidelSynchAlgo.cpp",
@@ -210,6 +211,7 @@ if "PATH_NICSLU" in os.environ:
         include_dirs.append(os.path.join(path_nicslu, "include"))
         src_files.append("src/linear_solvers/NICSLUSolver.cpp")
         extra_compile_args.append("-DNICSLU_SOLVER_AVAILABLE")
+        extra_compile_args += [f"-DNICSLU_PATH=\"{os.path.join(path_nicslu, libnicslu_path)}\""]
         print("INFO: Using NICSLU package")
 
 # Try to locate the CKTSO sparse linear solver
@@ -257,6 +259,7 @@ if "PATH_CKTSO" in os.environ:
         include_dirs.append(os.path.join(path_cktso, "include"))
         src_files.append("src/linear_solvers/CKTSOSolver.cpp")
         extra_compile_args.append("-DCKTSO_SOLVER_AVAILABLE")
+        extra_compile_args += [f"-DCKTSO_PATH=\"{os.path.join(path_cktso, libcktso_path)}\""]
         print("INFO: Using CKTSO package")
         
         
@@ -269,6 +272,7 @@ if "__COUT_TIMES" in os.environ:
 if "__COMPILE_MARCHNATIVE" in os.environ:
     if os.environ["__COMPILE_MARCHNATIVE"] == "1":
         extra_compile_args.append("-march=native")
+        extra_compile_args.append("-D__COMPILE_MARCHNATIVE")
         print("INFO: Using \"-march=native\" compiler flag")
 
 # $Env:_READ_THE_DOCS = "1" in powershell
@@ -299,6 +303,7 @@ if "__O3_OPTIM" in os.environ:
             print("INFO: Using \"-O3\" compiler flag")
         elif IS_WINDOWS:
             extra_compile_args.append("/O2")
+        extra_compile_args.append("-D__O3_OPTIM")
 
 ext_modules = [
     Pybind11Extension(

{LightSim2Grid-0.8.0 → LightSim2Grid-0.8.1.dev0}/src/BaseConstants.cpp

@@ -14,3 +14,4 @@ const real_type BaseConstants::my_one_ = 1.0;
 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;

{LightSim2Grid-0.8.0 → LightSim2Grid-0.8.1.dev0}/src/BaseConstants.h

@@ -24,6 +24,7 @@ class BaseConstants
         static const real_type my_one_;
         static const real_type my_two_;
         static const real_type my_zero_;
+        static const real_type my_180_pi_;
 };
 
 enum class FDPFMethod {XB, BX};  // Different type of FDPF powerflow

{LightSim2Grid-0.8.0 → LightSim2Grid-0.8.1.dev0}/src/ChooseSolver.h

@@ -286,6 +286,7 @@ class ChooseSolver
             Eigen::SparseMatrix<real_type> res = get_J();
             return res;
         }
+
         double get_computation_time() const
         {
             auto p_solver = get_prt_solver("get_computation_time", true);
@@ -293,6 +294,18 @@ class ChooseSolver
             return std::get<3>(res);
         }
 
+        std::tuple<double, double, double, double> get_timers() const
+        {
+            auto p_solver = get_prt_solver("get_timers", true);
+            return p_solver -> get_timers();
+        }
+
+        TimerJacType get_timers_jacobian() const
+        {
+            const BaseAlgo * p_solver = get_prt_solver("get_timers_jacobian", true);
+            return p_solver -> get_timers_jacobian();
+        }
+
         ErrorType get_error() const{
             auto p_solver = get_prt_solver("get_error", true);
             return p_solver -> get_error();

{LightSim2Grid-0.8.0 → LightSim2Grid-0.8.1.dev0}/src/GridModel.cpp

@@ -371,7 +371,7 @@ CplxVect GridModel::ac_pf(const CplxVect & Vinit,
     bool conv = false;
     CplxVect res = CplxVect();
 
-    reset_results();  // reset the results
+    // reset_results();  // clear the results  No need to do it, results are neceassirly set or reset in post process
 
     // pre process the data to define a proper jacobian matrix, the proper voltage vector etc.
     bool is_ac = true;
@@ -901,7 +901,7 @@ CplxVect GridModel::dc_pf(const CplxVect & Vinit,
     bool conv = false;
     CplxVect res = CplxVect();
 
-    reset_results();  // reset the results
+    // reset_results();  // clear the results  No need to do it, results are neceassirly set or reset in post process
 
     // pre process the data to define a proper jacobian matrix, the proper voltage vector etc.
     bool is_ac = false;

{LightSim2Grid-0.8.0 → LightSim2Grid-0.8.1.dev0}/src/GridModel.h

@@ -494,6 +494,21 @@ class GridModel : public GenericContainer
         Eigen::Ref<const RealVect> get_dclineor_theta() const {return dc_lines_.get_theta_or();}
         Eigen::Ref<const RealVect> get_dclineex_theta() const {return dc_lines_.get_theta_ex();}
 
+        Eigen::Ref<const IntVect> get_all_shunt_buses() const {return shunts_.get_buses();}
+
+        // 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();}
+        tuple4d get_gen_res_full() const {return generators_.get_res_full();}
+        tuple5d get_lineor_res_full() const {return powerlines_.get_res_or_full();}
+        tuple5d get_lineex_res_full() const {return powerlines_.get_res_ex_full();}
+        tuple5d get_trafohv_res_full() const {return trafos_.get_res_hv_full();}
+        tuple5d get_trafolv_res_full() const {return trafos_.get_res_lv_full();}
+        tuple4d get_storages_res_full() const {return storages_.get_res_full();}
+        tuple4d get_sgens_res_full() const {return sgens_.get_res_full();}
+        tuple4d get_dclineor_res_full() const {return dc_lines_.get_res_or_full();}
+        tuple4d get_dclineex_res_full() const {return dc_lines_.get_res_ex_full();}
+
         // get some internal information, be cerafull the ID of the buses might not be the same
         // TODO convert it back to this ID, that will make copies, but who really cares ?
         Eigen::SparseMatrix<cplx_type> get_Ybus(){

{LightSim2Grid-0.8.0 → LightSim2Grid-0.8.1.dev0}/src/Utils.h

@@ -22,6 +22,10 @@ typedef double real_type;  // type for real numbers: can be changed if installed
 typedef std::complex<real_type> cplx_type;  // type for complex number
 
 typedef Eigen::Matrix<real_type, Eigen::Dynamic, 1> EigenPythonNumType;  // Eigen::VectorXd
+typedef Eigen::Matrix<int, Eigen::Dynamic, 1> IntVect;
+typedef Eigen::Matrix<real_type, Eigen::Dynamic, 1> RealVect;
+typedef Eigen::Matrix<cplx_type, Eigen::Dynamic, 1> CplxVect;
+
 typedef std::tuple<Eigen::Ref<const EigenPythonNumType>,
                    Eigen::Ref<const EigenPythonNumType>,
                    Eigen::Ref<const EigenPythonNumType> > tuple3d;
@@ -29,9 +33,11 @@ typedef std::tuple<Eigen::Ref<const EigenPythonNumType>,
                    Eigen::Ref<const EigenPythonNumType>,
                    Eigen::Ref<const EigenPythonNumType>,
                    Eigen::Ref<const EigenPythonNumType> > tuple4d;
-typedef Eigen::Matrix<int, Eigen::Dynamic, 1> IntVect;
-typedef Eigen::Matrix<real_type, Eigen::Dynamic, 1> RealVect;
-typedef Eigen::Matrix<cplx_type, Eigen::Dynamic, 1> CplxVect;
+typedef std::tuple<Eigen::Ref<const EigenPythonNumType>,
+                   Eigen::Ref<const EigenPythonNumType>,
+                   Eigen::Ref<const EigenPythonNumType>,
+                   Eigen::Ref<const EigenPythonNumType>,
+                   Eigen::Ref<const EigenPythonNumType> > tuple5d;
 
 typedef Eigen::Matrix<real_type, Eigen::Dynamic, Eigen::Dynamic> RealMat;
 typedef Eigen::Matrix<cplx_type, Eigen::Dynamic, Eigen::Dynamic> CplxMat;

{LightSim2Grid-0.8.0 → LightSim2Grid-0.8.1.dev0}/src/element_container/DCLineContainer.cpp

@@ -36,6 +36,7 @@ void DCLineContainer::set_state(DCLineContainer::StateRes & my_state){
     status_ = status;
     loss_percent_ = RealVect::Map(&loss_percent[0], loss_percent.size());
     loss_mw_ = RealVect::Map(&loss_mw[0], loss_percent.size());
+    reset_results();
 }
 
 void DCLineContainer::init(const Eigen::VectorXi & branch_from_id,

{LightSim2Grid-0.8.0 → LightSim2Grid-0.8.1.dev0}/src/element_container/DCLineContainer.h

@@ -294,6 +294,9 @@ class DCLineContainer : public GenericContainer
     
     tuple3d get_or_res() const {return from_gen_.get_res();}
     tuple3d get_ex_res() const {return to_gen_.get_res();}
+    tuple4d get_res_or_full() const {return from_gen_.get_res_full();}
+    tuple4d get_res_ex_full() const {return to_gen_.get_res_full();}
+    
     Eigen::Ref<const RealVect> get_theta_or() const {return from_gen_.get_theta();}
     Eigen::Ref<const RealVect> get_theta_ex() const {return to_gen_.get_theta();}
 

{LightSim2Grid-0.8.0 → LightSim2Grid-0.8.1.dev0}/src/element_container/GeneratorContainer.cpp

@@ -54,6 +54,7 @@ void GeneratorContainer::init(const RealVect & generators_p,
     turnedoff_gen_pv_ = true;
     voltage_regulator_on_ = std::vector<bool>(generators_p.size(), true);
     q_mvar_ = RealVect::Zero(generators_p.size());
+    reset_results();
 }
 
 void GeneratorContainer::init_full(const RealVect & generators_p,
@@ -94,7 +95,6 @@ GeneratorContainer::StateRes GeneratorContainer::get_state() const
 
 void GeneratorContainer::set_state(GeneratorContainer::StateRes & my_state)
 {
-    reset_results();
     names_ = std::get<0>(my_state);
     turnedoff_gen_pv_ = std::get<1>(my_state);
 
@@ -122,6 +122,7 @@ void GeneratorContainer::set_state(GeneratorContainer::StateRes & my_state)
     status_ = status;
     gen_slackbus_ = slack_bus;
     gen_slack_weight_ = slack_weight;
+    reset_results();
 }
 
 RealVect GeneratorContainer::get_slack_weights(Eigen::Index nb_bus_solver, const std::vector<int> & id_grid_to_solver){
@@ -222,10 +223,10 @@ void GeneratorContainer::compute_results(const Eigen::Ref<const RealVect> & Va,
 }
 
 void GeneratorContainer::reset_results(){
-    res_p_ = RealVect();  // in MW
-    res_q_ = RealVect();  // in MVar
-    res_v_ = RealVect();  // in kV
-    res_theta_ = RealVect();  // in deg
+    res_p_ = RealVect(nb());  // in MW
+    res_q_ = RealVect(nb());  // in MVar
+    res_v_ = RealVect(nb());  // in kV
+    res_theta_ = RealVect(nb());  // in deg
     // bus_slack_weight_ = RealVect();
 }
 
@@ -414,13 +415,23 @@ void GeneratorContainer::set_q(const RealVect & reactive_mismatch,
                                const RealVect & total_q_max_per_bus)
 {
     const int nb_gen = nb();
-    res_q_ = RealVect::Constant(nb_gen, 0.);
-    if(!ac) return;  // do not consider Q values in dc mode
+    // res_q_ = RealVect::Constant(nb_gen, 0.);
+    if(!ac)  
+    {
+        // do not consider Q values in dc mode
+        for(int gen_id = 0; gen_id < nb_gen; ++gen_id) res_q_(gen_id) = 0.;
+        return;
+    }
+    
     real_type eps_q = 1e-8;
     for(int gen_id = 0; gen_id < nb_gen; ++gen_id)
     {
         real_type real_q = 0.;
-        if(!status_[gen_id]) continue;  // set at 0 for disconnected generators
+        if(!status_[gen_id]){
+            // set at 0 for disconnected generators
+            res_q_(gen_id) = 0.;
+            continue;  
+        }
 
         if (!voltage_regulator_on_[gen_id]) continue;  // gen is purposedly not pv
         if ((!turnedoff_gen_pv_) && p_mw_(gen_id) == 0.) continue;  // in this case turned off generators are not pv

{LightSim2Grid-0.8.0 → LightSim2Grid-0.8.1.dev0}/src/element_container/GeneratorContainer.h

@@ -324,6 +324,7 @@ class GeneratorContainer: public GenericContainer
     virtual void gen_p_per_bus(std::vector<real_type> & res) const;
 
     tuple3d get_res() const {return tuple3d(res_p_, res_q_, res_v_);}
+    tuple4d get_res_full() const {return tuple4d(res_p_, res_q_, res_v_, res_theta_);}
     Eigen::Ref<const RealVect> get_theta() const {return res_theta_;}
 
     const std::vector<bool>& get_status() const {return status_;}