LightSim2Grid 0.9.2.post2__tar.gz → 0.10.1__tar.gz

{lightsim2grid-0.9.2.post2 → lightsim2grid-0.10.1/LightSim2Grid.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: LightSim2Grid
-Version: 0.9.2.post2
+Version: 0.10.1
 Summary: LightSim2Grid implements a c++ backend targeting the Grid2Op platform.
 Home-page: https://github.com/grid2op/lightsim2grid/
 Author: Benjamin Donnot
@@ -32,6 +32,7 @@ Requires-Dist: pip
 Requires-Dist: pybind11
 Requires-Dist: scipy
 Requires-Dist: numpy
+Requires-Dist: packaging
 Provides-Extra: docs
 Requires-Dist: numpydoc>=0.9.2; extra == "docs"
 Requires-Dist: sphinx<7,>=2.4.4; extra == "docs"
@@ -54,8 +55,19 @@ Provides-Extra: test
 Requires-Dist: grid2op>=1.6.4; extra == "test"
 Requires-Dist: numba; extra == "test"
 Requires-Dist: pandapower>=2.14.0; extra == "test"
-Requires-Dist: packaging; extra == "test"
 Requires-Dist: pypowsybl; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: platform
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
 
 # LightSim2Grid
 Provide a fast backend for grid2op using c++ KLU and Eigen librairies. Its primary goal is to serve as a fast

{lightsim2grid-0.9.2.post2 → lightsim2grid-0.10.1}/LightSim2Grid.egg-info/SOURCES.txt

@@ -503,7 +503,11 @@ lightsim2grid/gridmodel/from_pandapower/initGridModel.py
 lightsim2grid/gridmodel/from_pypowsybl/__init__.py
 lightsim2grid/gridmodel/from_pypowsybl/_from_pypowsybl.py
 lightsim2grid/newtonpf/__init__.py
-lightsim2grid/newtonpf/newtonpf.py
+lightsim2grid/pandapower_compat/__init__.py
+lightsim2grid/pandapower_compat/dcpf/__init__.py
+lightsim2grid/pandapower_compat/dcpf/_dcpf.py
+lightsim2grid/pandapower_compat/newtonpf/__init__.py
+lightsim2grid/pandapower_compat/newtonpf/_newtonpf.py
 lightsim2grid/rewards/__init__.py
 lightsim2grid/rewards/n1ContingencyReward.py
 lightsim2grid/solver/__init__.py

{lightsim2grid-0.9.2.post2/LightSim2Grid.egg-info → lightsim2grid-0.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: LightSim2Grid
-Version: 0.9.2.post2
+Version: 0.10.1
 Summary: LightSim2Grid implements a c++ backend targeting the Grid2Op platform.
 Home-page: https://github.com/grid2op/lightsim2grid/
 Author: Benjamin Donnot
@@ -32,6 +32,7 @@ Requires-Dist: pip
 Requires-Dist: pybind11
 Requires-Dist: scipy
 Requires-Dist: numpy
+Requires-Dist: packaging
 Provides-Extra: docs
 Requires-Dist: numpydoc>=0.9.2; extra == "docs"
 Requires-Dist: sphinx<7,>=2.4.4; extra == "docs"
@@ -54,8 +55,19 @@ Provides-Extra: test
 Requires-Dist: grid2op>=1.6.4; extra == "test"
 Requires-Dist: numba; extra == "test"
 Requires-Dist: pandapower>=2.14.0; extra == "test"
-Requires-Dist: packaging; extra == "test"
 Requires-Dist: pypowsybl; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: platform
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
 
 # LightSim2Grid
 Provide a fast backend for grid2op using c++ KLU and Eigen librairies. Its primary goal is to serve as a fast

{lightsim2grid-0.9.2.post2 → lightsim2grid-0.10.1}/lightsim2grid/__init__.py

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

{lightsim2grid-0.9.2.post2 → lightsim2grid-0.10.1}/lightsim2grid/gridmodel/from_pandapower/_aux_add_trafo.py

@@ -61,9 +61,18 @@ def _aux_add_trafo(converter, model, pp_net, pp_to_ls):
         warnings.warn("There were some Nan in the pp_net.trafo[\"tap_side\"], they have been replaced by \"hv\"")
     is_tap_hv_side[~np.isfinite(is_tap_hv_side)] = True
 
-    if np.any(pp_net.trafo["tap_phase_shifter"].values):
-        raise RuntimeError("ideal phase shifter are not modeled. Please remove all trafo with "
-                           "pp_net.trafo[\"tap_phase_shifter\"] set to True.")
+    if "tap_phase_shifter" in pp_net.trafo:
+        if np.any(pp_net.trafo["tap_phase_shifter"].values):
+            raise RuntimeError("Ideal phase shifters are not modeled. Please remove all trafos with "
+                               "pp_net.trafo[\"tap_phase_shifter\"] set to True.")
+    elif "tap_changer_type" in pp_net.trafo:
+        if np.any(pp_net.trafo["tap_changer_type"].values == "Ideal"):
+            raise RuntimeError("Ideal phase shifters are not modeled. Please remove all 2-winding trafos "
+                               "with \"tap_changer_type\" set to \"Ideal\".")
+    elif "tap_changer_type" in pp_net.trafo3w:
+        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
     if np.any(~np.isfinite(tap_angles_)):

{lightsim2grid-0.9.2.post2 → lightsim2grid-0.10.1}/lightsim2grid/lightSimBackend.py

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

lightsim2grid-0.10.1/lightsim2grid/newtonpf/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) 2020-2025, RTE (https://www.rte-france.com)
+# See AUTHORS.txt
+# This Source Code Form is subject to the terms of the Mozilla Public License, version 2.0.
+# If a copy of the Mozilla Public License, version 2.0 was not distributed with this file,
+# 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.
+
+__all__ = ["newtonpf", "newtonpf_new", "newtonpf_old"]
+
+from lightsim2grid.pandapower_compat import newtonpf, newtonpf_new, newtonpf_old

lightsim2grid-0.10.1/lightsim2grid/pandapower_compat/__init__.py

@@ -0,0 +1,12 @@
+# Copyright (c) 2025, RTE (https://www.rte-france.com)
+# See AUTHORS.txt
+# This Source Code Form is subject to the terms of the Mozilla Public License, version 2.0.
+# If a copy of the Mozilla Public License, version 2.0 was not distributed with this file,
+# 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.
+
+__all__ = ["newtonpf", "newtonpf_new", "newtonpf_old", "dcpf"]
+
+from lightsim2grid.pandapower_compat.newtonpf import newtonpf, newtonpf_new, newtonpf_old
+from lightsim2grid.pandapower_compat.dcpf import dcpf

lightsim2grid-0.10.1/lightsim2grid/pandapower_compat/dcpf/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) 2025, RTE (https://www.rte-france.com)
+# See AUTHORS.txt
+# This Source Code Form is subject to the terms of the Mozilla Public License, version 2.0.
+# If a copy of the Mozilla Public License, version 2.0 was not distributed with this file,
+# 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.
+
+__all__ = ["dcpf"]
+
+from lightsim2grid.pandapower_compat.dcpf._dcpf import dcpf

lightsim2grid-0.10.1/lightsim2grid/pandapower_compat/dcpf/_dcpf.py

@@ -0,0 +1,65 @@
+# Copyright (c) 2020, RTE (https://www.rte-france.com)
+# See AUTHORS.txt
+# This Source Code Form is subject to the terms of the Mozilla Public License, version 2.0.
+# If a copy of the Mozilla Public License, version 2.0 was not distributed with this file,
+# 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.
+
+import numpy as np
+from scipy import sparse
+
+from lightsim2grid.solver import DCSolver
+
+try:
+    from lightsim2grid.solver import KLUDCSolver
+    KLU_solver_available = True
+except ImportError:
+    KLU_solver_available = False
+
+
+def _isolate_slack_ids(Sbus, pv, pq):
+    # extract the slack bus
+    ref = set(np.arange(Sbus.shape[0])) - set(pv) - set(pq)
+    ref = np.array(list(ref))
+    # build the slack weights
+    slack_weights = np.zeros(Sbus.shape[0])
+    slack_weights[ref] = 1.0 / ref.shape[0]
+    return ref, slack_weights
+
+
+def _get_valid_solver(options, Bbus):
+    # initialize the solver
+    # TODO have that in options maybe (can use GaussSeidel, and NR with KLU -faster- or SparseLU)
+    solver = KLUDCSolver() if KLU_solver_available else DCSolver()
+
+    if not sparse.isspmatrix_csc(Bbus):
+        Bbus = sparse.csc_matrix(Bbus)
+
+    if not Bbus.has_canonical_format:
+        Bbus.sum_duplicates()
+        if not Bbus.has_canonical_format:
+            raise RuntimeError("Your matrix should be in a canonical format. See "
+                            "https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csc_matrix.has_canonical_format.html"
+                            " for more information.")
+    
+    return solver
+
+
+def dcpf(B, Pbus, Va0, ref, pv, pq):
+    """
+    Implementation (using lightsim2grid) of the `dcpf` function of pandapower
+    that allows to perform DC powerflow.
+    
+    It is meant to be used from inside pandapower and not directly.
+    """
+    # initialize the solver and perform some sanity checks
+    solver = _get_valid_solver(None, B)
+    
+    # do the newton raphson algorithm
+    slack_weights = np.ones(len(ref), dtype=float)
+    slack_weights /= slack_weights.sum()
+    solver.solve(B, np.cos(Va0) + 1j * np.sin(Va0), Pbus, ref, slack_weights, pv, pq, 1, 1e-8)
+    # extract the results
+    Va = solver.get_Va()
+    return Va

{lightsim2grid-0.9.2.post2/lightsim2grid → lightsim2grid-0.10.1/lightsim2grid/pandapower_compat}/newtonpf/__init__.py

@@ -8,4 +8,4 @@
 
 __all__ = ["newtonpf", "newtonpf_new", "newtonpf_old"]
 
-from lightsim2grid.newtonpf.newtonpf import newtonpf, newtonpf_new, newtonpf_old
+from lightsim2grid.pandapower_compat.newtonpf._newtonpf import newtonpf, newtonpf_new, newtonpf_old

lightsim2grid-0.9.2.post2/lightsim2grid/newtonpf/newtonpf.py → lightsim2grid-0.10.1/lightsim2grid/pandapower_compat/newtonpf/_newtonpf.py

@@ -7,18 +7,24 @@
 # This file is part of LightSim2grid, LightSim2grid implements a c++ backend targeting the Grid2Op platform.
 
 import warnings
+from packaging import version
+try:
+    from importlib.metadata import version as version_metadata
+except ImportError:
+    # for compat with python 3.7 ...
+    version_metadata = None
 import numpy as np
 from scipy import sparse
 
-from lightsim2grid_cpp import SparseLUSolver, SparseLUSolverSingleSlack
+from lightsim2grid.solver import SparseLUSolver, SparseLUSolverSingleSlack
 
 try:
-    from lightsim2grid_cpp import KLUSolver, KLUSolverSingleSlack
+    from lightsim2grid.solver import KLUSolver, KLUSolverSingleSlack
     KLU_solver_available = True
 except ImportError:
     KLU_solver_available = False
 
-_PP_VERSION_MAX = "2.7.0"
+_PP_VERSION_MAX = version.parse("2.7.0")
 
 
 def _isolate_slack_ids(Sbus, pv, pq):
@@ -43,10 +49,11 @@ def _get_valid_solver(options, Ybus):
         Ybus = sparse.csc_matrix(Ybus)
 
     if not Ybus.has_canonical_format:
-        raise RuntimeError("Your matrix should be in a canonical format. See "
-                           "https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csc_matrix.has_canonical_format.html"
-                           " for more information.")
-    
+        Ybus.sum_duplicates()
+        if not Ybus.has_canonical_format:
+            raise RuntimeError("Your matrix should be in a canonical format. See "
+                            "https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csc_matrix.has_canonical_format.html"
+                            " for more information.")
     return solver
 
 
@@ -73,17 +80,23 @@ def newtonpf(*args, **kwargs):
 
     .. code-block::
 
-        from lightsim2grid.newtonpf import newtonpf
+        from lightsim2grid.pandapower_compat import newtonpf
 
-        # when pandapower version <= 2.7.0
+        # with pandapower version <= 2.7.0
         V, converged, iterations, J, Vm_it, Va_it = newtonpf(Ybus, Sbus, V0, pv, pq, ppci, options)
 
-        # when pandapower version > 2.7.0
+        # with pandapower version > 2.7.0
         V, converged, iterations, J, Vm_it, Va_it = newtonpf(Ybus, Sbus, V0, ref, pv, pq, ppci, options)
 
     """
-    import pandapower as pp
-    if pp.__version__ <= _PP_VERSION_MAX:
+    if version_metadata is not None:
+        pp_ver = version_metadata("pandapower")
+    else:
+        # for compat with python 3.7
+        import pandapower as pp
+        pp_ver = pp.__version__
+        
+    if version.parse(pp_ver) <= _PP_VERSION_MAX:
         try:
             # should be the old version
             return newtonpf_old(*args, **kwargs)

{lightsim2grid-0.9.2.post2 → lightsim2grid-0.10.1}/setup.py

@@ -14,7 +14,7 @@ import warnings
 from pybind11.setup_helpers import Pybind11Extension, build_ext
 
 
-__version__ = "0.9.2.post2"
+__version__ = "0.10.1"
 KLU_SOLVER_AVAILABLE = False
 
 # Try to link against SuiteSparse (if available)
@@ -322,7 +322,8 @@ req_pkgs = [
     "pip",
     "pybind11",
     "scipy",
-    "numpy"
+    "numpy",
+    "packaging", 
         # "pandapower" if sys.version_info < (3, 10) else "pandapower>=2.8",
         # "pytest",  # for pandapower see https://github.com/e2nIEE/pandapower/issues/1988
     ]
@@ -363,7 +364,6 @@ pkgs = {
             "grid2op>=1.6.4",
             "numba",
             "pandapower>=2.14.0",  # interface changed for pandapower, not backward compatible
-            "packaging", 
             "pypowsybl"
         ]
     }