solving conflicts and implement logic in elements [skip ci]

Author: BDonnot

.github/workflows/main.yml

@@ -195,12 +195,16 @@ jobs:
 
       - name: Check package can be imported
         run: |
+          mkdir tmp_for_import_checking
+          cd tmp_for_import_checking
           python -c "import lightsim2grid"
           python -c "from lightsim2grid import *"
           python -c "from lightsim2grid.newtonpf import newtonpf"
+          cd ..
       
       - name: Check LightSimBackend can be imported
         run: |
+          cd tmp_for_import_checking
           python -m pip install grid2op
           python -c "from lightsim2grid import LightSimBackend"
           python -c "from lightsim2grid import LightSimBackend; import grid2op; env = grid2op.make('l2rpn_case14_sandbox', test=True, backend=LightSimBackend())"
@@ -253,16 +257,20 @@ jobs:
 
       - name: Check package can be imported
         run: |
+          mkdir tmp_for_import_checking
+          cd tmp_for_import_checking
           python -c "import lightsim2grid"
           python -c "from lightsim2grid import *"
           python -c "from lightsim2grid.newtonpf import newtonpf"
+          cd ..
       
       - name: Check LightSimBackend can be imported
         run: |
+          cd tmp_for_import_checking
           python -m pip install grid2op
           python -c "from lightsim2grid import LightSimBackend"
           python -c "from lightsim2grid import LightSimBackend; import grid2op; env = grid2op.make('l2rpn_case14_sandbox', test=True, backend=LightSimBackend())"
-
+        
       - name: Upload wheel
         uses: actions/upload-artifact@v3
         with:

CHANGELOG.rst

@@ -5,6 +5,7 @@ Change Log
 --------
 - [refacto] have a structure in cpp for the buses
 - [refacto] have the id_grid_to_solver and id_solver_to_grid etc. directly in the solver and NOT in the gridmodel.
+- [refacto] put some method in the DataGeneric as well as some attribute (_status for example)
 - support 3w trafo (as modeled in pandapower)
 - improve speed by not performing internal checks 
   (keep check for boundaries and all for python API instead) [see `TODO DEBUG MODE` in c++ code]
@@ -13,8 +14,6 @@ Change Log
 - a mode to do both `Computer` and `SecurityAnalysisCPP`
 - use the "multi slack hack" (see issue #50) for SecurityAnalysis or Computer for example
 - code `helm` powerflow method
-- possibility to read CGMES files
-- possibility to read XIIDM files
 - interface with gridpack (to enforce q limits for example)
 - maybe have a look at suitesparse "sliplu" tools ?
 - easier building (get rid of the "make" part)
@@ -25,7 +24,15 @@ Change Log
 - [FIXED] now voltage is properly set to 0. when storage units are disconnected
 - [FIXED] a bug where non connected grid were not spotted in DC
 - [FIXED] a bug when trying to set the slack for a non existing genererator
-- [IMPROVED] now making the new grid2op `create_test_suite` 
+- [FIXED] a bug in init from pypowsybl when some object were disconnected. It raises
+  an error (because they are not connected to a bus): now this function properly handles
+  these cases.
+- [ADDED] sets of methods to extract the main component of a grid and perform powerflow only on this
+  one.
+- [ADDED] possibility to set / retrieve the names of each elements of the grid.
+- [ADDED] embed in the generator models the "non pv" behaviour. (TODO need to be able to change Q from python side)
+- [IMPROVED] now performing the new grid2op `create_test_suite` 
+- [IMPROVED] now lightsim2grid properly throw `BackendError`
 
 [0.7.5] 2023-10-05
 --------------------

docs/conf.py

@@ -22,7 +22,7 @@
 author = 'Benjamin DONNOT'
 
 # The full version, including alpha/beta/rc tags
-release = "0.7.6.dev0"
+release = "0.7.6.dev1"
 version = '0.7'
 
 # -- General configuration ---------------------------------------------------

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.7.6.dev0"
+__version__ = "0.7.6.dev1"
 
 __all__ = ["newtonpf", "SolverType", "ErrorType", "solver"]
 

lightsim2grid/gridmodel/from_pypowsybl.py

@@ -6,21 +6,43 @@
 # SPDX-License-Identifier: MPL-2.0
 # This file is part of LightSim2grid, LightSim2grid implements a c++ backend targeting the Grid2Op platform.
 
-import copy
 import numpy as np
 import pypowsybl as pypo
-# import pypowsybl.loadflow as lf
 
 from lightsim2grid_cpp import GridModel
 
 
+def _aux_get_bus(bus_df, df, conn_key="connected", bus_key="bus_id"):
+    if df.shape[0] == 0:
+        # no element of this type so no problem
+        return np.zeros(0, dtype=int), np.ones(0, dtype=bool)
+    # retrieve which elements are disconnected 
+    mask_disco = ~df[conn_key]
+    if mask_disco.all():
+        raise RuntimeError("All element of the same type are disconnected, the init will not work.")
+    first_el_co = np.where(~mask_disco.values)[0][0]
+    # retrieve the bus where the element are
+    tmp_bus_id = df[bus_key].copy()
+    tmp_bus_id[mask_disco] = df.iloc[first_el_co][bus_key]  # assign a "random" bus to disco element
+    bus_id = bus_df.loc[tmp_bus_id.values]["bus_id"].values
+    # deactivate the element not on the main component
+    # wrong_component = bus_df.loc[tmp_bus_id.values]["connected_component"].values != 0
+    # mask_disco[wrong_component] = True
+    # assign bus -1 to disconnected elements
+    bus_id[mask_disco] = -1
+    return bus_id, mask_disco.values
+
+
 def init(net : pypo.network,
          gen_slack_id: int = None,
          slack_bus_id: int = None,
          sn_mva = 100.,
          sort_index=True,
-         f_hz = 50.):
+         f_hz = 50.,  # unused
+         only_main_component=True):
     model = GridModel()
+    # model.set_f_hz(f_hz)
+    
     # for substation
     # network.get_voltage_levels()["substation_id"]
     # network.get_substations()
@@ -50,42 +72,39 @@ def init(net : pypo.network,
         df_gen = net.get_generators().sort_index()
     else:
         df_gen = net.get_generators()
-        
     # to handle encoding in 32 bits and overflow when "splitting" the Q values among 
     min_q = df_gen["min_q"].values.astype(np.float32)
     max_q = df_gen["max_q"].values.astype(np.float32)
     min_q[~np.isfinite(min_q)] = np.finfo(np.float32).min * 0.5 + 1.
     max_q[~np.isfinite(max_q)] = np.finfo(np.float32).max * 0.5 - 1.
-    model.init_generators(df_gen["target_p"].values,
-                          df_gen["target_v"].values / voltage_levels.loc[df_gen["voltage_level_id"].values]["nominal_v"].values,
-                          min_q,
-                          max_q,
-                          1 * bus_df.loc[df_gen["bus_id"].values]["bus_id"].values
-                          )
-    # TODO dist slack
-    if gen_slack_id is not None:
-        model.add_gen_slackbus(gen_slack_id, 1.)
-    elif slack_bus_id is not None:
-        gen_bus = np.array([el.bus_id for el in model.get_generators()])
-        gen_is_conn_slack = gen_bus == model._orig_to_ls[slack_bus_id]
-        nb_conn = gen_is_conn_slack.sum()
-        if nb_conn == 0:
-            raise RuntimeError(f"There is no generator connected to bus {slack_bus_id}. It cannot be the slack")
-        for gen_id, is_slack in enumerate(gen_is_conn_slack):
-            if is_slack:
-                model.add_gen_slackbus(gen_id, 1. / nb_conn)   
-    else:
-        model.add_gen_slackbus(0, 1.)
-        
+    gen_bus, gen_disco = _aux_get_bus(bus_df, df_gen)
+    model.init_generators_full(df_gen["target_p"].values,
+                               df_gen["target_v"].values / voltage_levels.loc[df_gen["voltage_level_id"].values]["nominal_v"].values,
+                               df_gen["target_q"].values,
+                               df_gen["voltage_regulator_on"].values,
+                               min_q,
+                               max_q,
+                               gen_bus
+                               )
+    for gen_id, is_disco in enumerate(gen_disco):
+        if is_disco:
+            model.deactivate_gen(gen_id)
+    model.set_gen_names(df_gen.index)   
+    
     # for loads
     if sort_index:
         df_load = net.get_loads().sort_index()
     else:
         df_load = net.get_loads()
+    load_bus, load_disco = _aux_get_bus(bus_df, df_load)
     model.init_loads(df_load["p0"].values,
                      df_load["q0"].values,
-                     1 * bus_df.loc[df_load["bus_id"].values]["bus_id"].values
+                     load_bus
                      )
+    for load_id, is_disco in enumerate(load_disco):
+        if is_disco:
+            model.deactivate_load(load_id)
+    model.set_load_names(df_load.index)
 
     # for lines
     if sort_index:
@@ -117,13 +136,19 @@ def init(net : pypo.network,
     g2 = df_line["g2"].values * v2*v2/sn_mva + (v2-v1)*tmp_.real*v2/sn_mva
     line_h_or = (b1 + 1j * g1)
     line_h_ex = (b2 + 1j * g2)
+    lor_bus, lor_disco = _aux_get_bus(bus_df, df_line, conn_key="connected1", bus_key="bus1_id")
+    lex_bus, lex_disco = _aux_get_bus(bus_df, df_line, conn_key="connected2", bus_key="bus2_id")
     model.init_powerlines_full(line_r,
                                line_x,
                                line_h_or,
                                line_h_ex,
-                               1 * bus_df.loc[df_line["bus1_id"].values]["bus_id"].values,
-                               1 * bus_df.loc[df_line["bus2_id"].values]["bus_id"].values
+                               lor_bus,
+                               lex_bus
                               )
+    for line_id, (is_or_disc, is_ex_disc) in enumerate(zip(lor_disco, lex_disco)):
+        if is_or_disc or is_ex_disc:
+            model.deactivate_powerline(line_id)
+    model.set_line_names(df_line.index)
 
     # for trafo
     if sort_index:
@@ -145,51 +170,50 @@ def init(net : pypo.network,
     has_tap = tap_step_pct != 0.
     tap_pos[has_tap] += 1
     tap_step_pct[~has_tap] = 1.0  # or any other values...
+    tor_bus, tor_disco = _aux_get_bus(bus_df, df_trafo, conn_key="connected1", bus_key="bus1_id")
+    tex_bus, tex_disco = _aux_get_bus(bus_df, df_trafo, conn_key="connected2", bus_key="bus2_id")
     model.init_trafo(df_trafo["r"].values / trafo_to_pu,
                      df_trafo["x"].values / trafo_to_pu,
                      2.*(1j*df_trafo["g"].values + df_trafo["b"].values) * trafo_to_pu,
                      tap_step_pct,
                      tap_pos,
                      shift_,
                      is_tap_hv_side,
-                     1 * bus_df.loc[df_trafo["bus1_id"].values]["bus_id"].values, # TODO do I need to change hv / lv
-                     1 * bus_df.loc[df_trafo["bus2_id"].values]["bus_id"].values)    
+                     tor_bus, # TODO do I need to change hv / lv
+                     tex_bus)    
+    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)
+    model.set_trafo_names(df_trafo.index)
 
     # for shunt
     if sort_index:
         df_shunt = net.get_shunt_compensators().sort_index()
     else:
         df_shunt = net.get_shunt_compensators()
 
-    is_on = copy.deepcopy(df_shunt["connected"])
-    if (~is_on).any():
-        df_shunt["connected"] = True
-        net.update_shunt_compensators(df_shunt[["connected"]])
-        if sort_index:
-            df_shunt = net.get_shunt_compensators().sort_index()
-        else:
-            df_shunt = net.get_shunt_compensators()
-        df_shunt["connected"] = is_on
-        net.update_shunt_compensators(df_shunt[["connected"]])
-        
+    sh_bus, sh_disco = _aux_get_bus(bus_df, df_shunt)    
     shunt_kv = voltage_levels.loc[df_shunt["voltage_level_id"].values]["nominal_v"].values
     model.init_shunt(-df_shunt["g"].values * shunt_kv**2,
                      -df_shunt["b"].values * shunt_kv**2,
-                     1 * bus_df.loc[df_shunt["bus_id"].values]["bus_id"].values
+                     sh_bus
                     )
-    for shunt_id, conn in enumerate(is_on):
-        if not conn:
+    for shunt_id, disco in enumerate(sh_disco):
+        if disco:
            model.deactivate_shunt(shunt_id) 
+    model.set_shunt_names(df_trafo.index)
 
     # for hvdc (TODO not tested yet)
     df_dc = net.get_hvdc_lines().sort_index()
     df_sations = net.get_vsc_converter_stations().sort_index()
-    bus_from_id = df_sations.loc[df_dc["converter_station1_id"].values]["bus_id"].values
-    bus_to_id = df_sations.loc[df_dc["converter_station2_id"].values]["bus_id"].values
+    # bus_from_id = df_sations.loc[df_dc["converter_station1_id"].values]["bus_id"].values
+    # bus_to_id = df_sations.loc[df_dc["converter_station2_id"].values]["bus_id"].values
+    bus_from_id, hvdc_from_disco = _aux_get_bus(bus_df, df_sations.loc[df_dc["converter_station1_id"].values]) 
+    bus_to_id, hvdc_to_disco = _aux_get_bus(bus_df, df_sations.loc[df_dc["converter_station2_id"].values]) 
     loss_percent = np.zeros(df_dc.shape[0])  # TODO 
     loss_mw = np.zeros(df_dc.shape[0])  # TODO
-    model.init_dclines(bus_df.loc[bus_from_id]["bus_id"].values,
-                       bus_df.loc[bus_to_id]["bus_id"].values,
+    model.init_dclines(bus_from_id,
+                       bus_to_id,
                        df_dc["target_p"].values,
                        loss_percent,
                        loss_mw,
@@ -200,22 +224,56 @@ def init(net : pypo.network,
                        df_sations.loc[df_dc["converter_station2_id"].values]["min_q"].values,
                        df_sations.loc[df_dc["converter_station2_id"].values]["max_q"].values
                        )
-    
+    # TODO will probably not work !
+    for hvdc_id, (is_or_disc, is_ex_disc) in enumerate(zip(hvdc_from_disco, hvdc_to_disco)):
+        if is_or_disc or is_ex_disc:
+            model.deactivate_hvdc(hvdc_id)
+    model.set_dcline_names(df_sations.index)
+                
     # storage units  (TODO not tested yet)
     if sort_index:
         df_batt = net.get_batteries().sort_index()
     else:
         df_batt = net.get_batteries()
+    batt_bus, batt_disco = _aux_get_bus(bus_df, df_batt)
     model.init_storages(df_batt["target_p"].values,
                         df_batt["target_q"].values,
-                        1 * bus_df.loc[df_batt["bus_id"].values]["bus_id"].values
+                        batt_bus
                         )
+    for batt_id, disco in enumerate(batt_disco):
+        if disco:
+           model.deactivate_storage(batt_id) 
+    model.set_storage_names(df_batt.index)
+
+    # TODO dist slack
+    if gen_slack_id is None and slack_bus_id is None:
+        # if nothing is given, by default I assign a slack bus to a bus where a lot of lines are connected
+        # quite central in the grid
+        bus_id, gen_id = model.assign_slack_to_most_connected()
+    elif gen_slack_id is not None:
+        if slack_bus_id is not None:
+            raise RuntimeError(f"You provided both gen_slack_id and slack_bus_id which is not possible.")
+        model.add_gen_slackbus(gen_slack_id, 1.)
+    elif slack_bus_id is not None:
+        gen_bus = np.array([el.bus_id for el in model.get_generators()])
+        gen_is_conn_slack = gen_bus == model._orig_to_ls[slack_bus_id]
+        nb_conn = gen_is_conn_slack.sum()
+        if nb_conn == 0:
+            raise RuntimeError(f"There is no generator connected to bus {slack_bus_id}. It cannot be the slack")
+        for gen_id, is_slack in enumerate(gen_is_conn_slack):
+            if is_slack:
+                model.add_gen_slackbus(gen_id, 1. / nb_conn)    
 
     # TODO
     # sgen => regular gen (from net.get_generators()) with voltage_regulator off TODO 
 
     # TODO checks
     # no 3windings trafo and other exotic stuff
     if net.get_phase_tap_changers().shape[0] > 0:
-        raise RuntimeError("Impossible currently to init a grid with tap changers at the moment.")
+        pass
+        # raise RuntimeError("Impossible currently to init a grid with tap changers at the moment.")
+        
+    # and now deactivate all elements and nodes not in the main component
+    if only_main_component:
+        model.consider_only_main_component()
     return model