LightSim2Grid 0.9.0__tar.gz → 0.9.1__tar.gz

{lightsim2grid-0.9.0 → lightsim2grid-0.9.1/LightSim2Grid.egg-info}/PKG-INFO

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

{lightsim2grid-0.9.0 → lightsim2grid-0.9.1}/LightSim2Grid.egg-info/SOURCES.txt

@@ -497,6 +497,7 @@ lightsim2grid/gridmodel/from_pandapower/_aux_add_slack.py
 lightsim2grid/gridmodel/from_pandapower/_aux_add_storage.py
 lightsim2grid/gridmodel/from_pandapower/_aux_add_trafo.py
 lightsim2grid/gridmodel/from_pandapower/_aux_check_legit.py
+lightsim2grid/gridmodel/from_pandapower/_my_const.py
 lightsim2grid/gridmodel/from_pandapower/_pp_bus_to_ls_bus.py
 lightsim2grid/gridmodel/from_pandapower/initGridModel.py
 lightsim2grid/gridmodel/from_pypowsybl/__init__.py

{lightsim2grid-0.9.0/LightSim2Grid.egg-info → lightsim2grid-0.9.1}/PKG-INFO

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

{lightsim2grid-0.9.0 → lightsim2grid-0.9.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.0"
+__version__ = "0.9.1"
 
 __all__ = ["newtonpf", "SolverType", "ErrorType", "solver", "compilation_options"]
 

{lightsim2grid-0.9.0 → lightsim2grid-0.9.1}/lightsim2grid/elements/__init__.py

@@ -6,29 +6,33 @@
 # SPDX-License-Identifier: MPL-2.0
 # This file is part of LightSim2grid, LightSim2grid implements a c++ backend targeting the Grid2Op platform.
 
-__all__ = ["DataGen",
+__all__ = ["GeneratorContainer",
            "GenInfo",
-           "DataSGen",
+           "SGenContainer",
            "SGenInfo",
-           "DataLoad",
+           "LoadContainer",
            "LoadInfo",
-           "DataShunt",
+           "ShuntContainer",
            "ShuntInfo",
-           "DataTrafo",
+           "TrafoContainer",
            "TrafoInfo",
-           "DataLine",
+           "LineContainer",
            "LineInfo",
+           "DCLineContainer",
+           "DCLineInfo",
            ]
 
-from lightsim2grid_cpp import DataGen
+from lightsim2grid_cpp import GeneratorContainer
 from lightsim2grid_cpp import GenInfo
-from lightsim2grid_cpp import DataSGen
+from lightsim2grid_cpp import SGenContainer
 from lightsim2grid_cpp import SGenInfo
-from lightsim2grid_cpp import DataLoad
+from lightsim2grid_cpp import LoadContainer
 from lightsim2grid_cpp import LoadInfo
-from lightsim2grid_cpp import DataShunt
+from lightsim2grid_cpp import ShuntContainer
 from lightsim2grid_cpp import ShuntInfo
-from lightsim2grid_cpp import DataTrafo
+from lightsim2grid_cpp import TrafoContainer
 from lightsim2grid_cpp import TrafoInfo
-from lightsim2grid_cpp import DataLine
+from lightsim2grid_cpp import LineContainer
 from lightsim2grid_cpp import LineInfo
+from lightsim2grid_cpp import DCLineContainer
+from lightsim2grid_cpp import DCLineInfo

lightsim2grid-0.9.1/lightsim2grid/gridmodel/from_pandapower/_aux_add_line.py

@@ -0,0 +1,73 @@
+# Copyright (c) 2020-2023, 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 packaging import version
+import pandapower as pp
+
+from ._pp_bus_to_ls_bus import pp_bus_to_ls
+from ._my_const import _MIN_PP_VERSION_ADV_GRID_MODEL
+
+def _aux_add_line(converter, model, pp_net, pp_to_ls=None):
+    """
+    Add the lines of the pp_net into the lightsim2grid "model"
+
+    Parameters
+    ----------
+    converter
+    model
+    pp_net
+
+    Returns
+    -------
+
+    """
+    if "parallel" in pp_net.line and np.any(pp_net.line["parallel"].values != 1):
+        raise RuntimeError("Cannot handle 'parallel' lines columns. Please duplicate the rows if that is the case. "
+                           "Some pp_net.line[\"parallel\"] != 1 it is not handled by lightsim yet.")
+
+    #### find the right powerline parameters
+    if version.parse(pp.__version__) >= _MIN_PP_VERSION_ADV_GRID_MODEL:
+        # new pandapower with support for different h at both side
+        line_r, line_x, line_h_or, line_h_ex = \
+            converter.get_line_param(
+                pp_net.line["r_ohm_per_km"].values * pp_net.line["length_km"].values,
+                pp_net.line["x_ohm_per_km"].values * pp_net.line["length_km"].values,
+                pp_net.line["g_us_per_km"].values * pp_net.line["length_km"].values,
+                pp_net.line["c_nf_per_km"].values * pp_net.line["length_km"].values,
+                pp_net.bus.loc[pp_net.line["from_bus"]]["vn_kv"], 
+                pp_net.bus.loc[pp_net.line["to_bus"]]["vn_kv"], 
+                )
+
+        ### add them to the grid
+        model.init_powerlines_full(line_r, line_x, line_h_or, line_h_ex,
+                                   pp_bus_to_ls(pp_net.line["from_bus"].values, pp_to_ls),
+                                   pp_bus_to_ls(pp_net.line["to_bus"].values, pp_to_ls)
+                                  )
+        
+    else:
+        # legacy pandapower, when they did not support lines with different h both side
+        line_r, line_x, line_h = \
+            converter.get_line_param_legacy(
+                pp_net.line["r_ohm_per_km"].values * pp_net.line["length_km"].values,
+                pp_net.line["x_ohm_per_km"].values * pp_net.line["length_km"].values,
+                pp_net.line["g_us_per_km"].values * pp_net.line["length_km"].values,
+                pp_net.line["c_nf_per_km"].values * pp_net.line["length_km"].values,
+                pp_net.bus.loc[pp_net.line["from_bus"]]["vn_kv"], 
+                pp_net.bus.loc[pp_net.line["to_bus"]]["vn_kv"], 
+                )
+
+        ### add them to the grid
+        model.init_powerlines(line_r, line_x, line_h,
+                              pp_bus_to_ls(pp_net.line["from_bus"].values, pp_to_ls),
+                              pp_bus_to_ls(pp_net.line["to_bus"].values, pp_to_ls)
+                              )
+    for line_id, is_connected in enumerate(pp_net.line["in_service"].values):
+        if not is_connected:
+            # powerline is deactivated
+            model.deactivate_powerline(line_id)

{lightsim2grid-0.9.0 → lightsim2grid-0.9.1}/lightsim2grid/gridmodel/from_pandapower/_aux_add_trafo.py

@@ -8,8 +8,11 @@
 
 import warnings
 import numpy as np
-from ._pp_bus_to_ls_bus import pp_bus_to_ls
+import pandapower as pp
+from packaging import version
 
+from ._pp_bus_to_ls_bus import pp_bus_to_ls
+from ._my_const import _MIN_PP_VERSION_ADV_GRID_MODEL
 
 def _aux_add_trafo(converter, model, pp_net, pp_to_ls):
     """
@@ -69,30 +72,57 @@ def _aux_add_trafo(converter, model, pp_net, pp_to_ls):
     tap_angles_ = np.deg2rad(tap_angles_)
 
     # compute physical parameters
-    trafo_r, trafo_x, trafo_b = \
-        converter.get_trafo_param(tap_step_pct,
-                                  tap_pos,
-                                  tap_angles_,  # in radian !
-                                  is_tap_hv_side,
-                                  pp_net.bus.loc[pp_net.trafo["hv_bus"]]["vn_kv"],
-                                  pp_net.bus.loc[pp_net.trafo["lv_bus"]]["vn_kv"],
-                                  pp_net.trafo["vk_percent"].values,
-                                  pp_net.trafo["vkr_percent"].values,
-                                  pp_net.trafo["sn_mva"].values,
-                                  pp_net.trafo["pfe_kw"].values,
-                                  pp_net.trafo["i0_percent"].values,
-                                  )
-
-    # initialize the grid
-    model.init_trafo(trafo_r,
-                     trafo_x,
-                     trafo_b,
-                     tap_step_pct,
-                     tap_pos,
-                     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))
+    if version.parse(pp.__version__) >= _MIN_PP_VERSION_ADV_GRID_MODEL:
+        # TODO
+        trafo_r, trafo_x, trafo_b = \
+            converter.get_trafo_param(tap_step_pct,
+                                      tap_pos,
+                                      tap_angles_,  # in radian !
+                                      is_tap_hv_side,
+                                      pp_net.bus.loc[pp_net.trafo["hv_bus"]]["vn_kv"],
+                                      pp_net.bus.loc[pp_net.trafo["lv_bus"]]["vn_kv"],
+                                      pp_net.trafo["vk_percent"].values,
+                                      pp_net.trafo["vkr_percent"].values,
+                                      pp_net.trafo["sn_mva"].values,
+                                      pp_net.trafo["pfe_kw"].values,
+                                      pp_net.trafo["i0_percent"].values,
+                                      )
+
+        # initialize the grid
+        model.init_trafo(trafo_r,
+                        trafo_x,
+                        trafo_b,
+                        tap_step_pct,
+                        tap_pos,
+                        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))
+    else:
+        trafo_r, trafo_x, trafo_b = \
+            converter.get_trafo_param_legacy(tap_step_pct,
+                                             tap_pos,
+                                             tap_angles_,  # in radian !
+                                             is_tap_hv_side,
+                                             pp_net.bus.loc[pp_net.trafo["hv_bus"]]["vn_kv"],
+                                             pp_net.bus.loc[pp_net.trafo["lv_bus"]]["vn_kv"],
+                                             pp_net.trafo["vk_percent"].values,
+                                             pp_net.trafo["vkr_percent"].values,
+                                             pp_net.trafo["sn_mva"].values,
+                                             pp_net.trafo["pfe_kw"].values,
+                                             pp_net.trafo["i0_percent"].values,
+                                             )
+
+        # initialize the grid
+        model.init_trafo(trafo_r,
+                        trafo_x,
+                        trafo_b,
+                        tap_step_pct,
+                        tap_pos,
+                        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))
 
     for tr_id, is_connected in enumerate(pp_net.trafo["in_service"].values):
         if not is_connected:

lightsim2grid-0.9.1/lightsim2grid/gridmodel/from_pandapower/_my_const.py

@@ -0,0 +1,11 @@
+# Copyright (c) 2024, 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.
+
+from packaging import version
+# pandapower version with more advanced grid modelling
+_MIN_PP_VERSION_ADV_GRID_MODEL = version.parse("2.15")  

{lightsim2grid-0.9.0 → lightsim2grid-0.9.1}/lightsim2grid/gridmodel/from_pypowsybl/_from_pypowsybl.py

@@ -7,11 +7,15 @@
 # This file is part of LightSim2grid, LightSim2grid implements a c++ backend targeting the Grid2Op platform.
 
 import warnings
+import copy
 import numpy as np
 import pandas as pd
 import pypowsybl as pypo
-from typing import Union
+from typing import Optional, Union
+from packaging import version
 
+PP_BUG_RATIO_TAP_CHANGER = version.parse("1.7.0")
+PYPOWSYBL_VER = version.parse(pypo.__version__)
 from lightsim2grid_cpp import GridModel
 
 
@@ -36,22 +40,21 @@ def _aux_get_bus(bus_df, df, conn_key="connected", bus_key="bus_id"):
     return bus_id, mask_disco.values
 
 
-def init(net : pypo.network,
+def init(net : pypo.network.Network,
          gen_slack_id: Union[int, str] = None,
          slack_bus_id: int = None,
          sn_mva = 100.,
          sort_index=True,
          f_hz = 50.,  # unused
+         net_pu : Optional[pypo.network.Network] = None,
          only_main_component=True,
-         return_sub_id=False):
+         return_sub_id=False,
+         n_busbar_per_sub=None,  # new in 0.9.1
+         buses_for_sub=None,  # new in 0.9.1
+         ):
     model = GridModel()
     # model.set_f_hz(f_hz)
     
-    # for substation
-    # network.get_voltage_levels()["substation_id"]
-    # network.get_substations()
-    # network.get_busbar_sections()
-    
     if gen_slack_id is not None and slack_bus_id is not None:
         raise RuntimeError("Impossible to intialize a grid with both gen_slack_id and slack_bus_id")
     
@@ -61,29 +64,108 @@ def init(net : pypo.network,
         bus_df = bus_df_orig.sort_index()
     else:
         bus_df = bus_df_orig
-    bus_df["bus_id"] = np.arange(bus_df.shape[0])
-    bus_df_orig["bus_id"] = bus_df.loc[bus_df_orig.index]["bus_id"]
-    voltage_levels = net.get_voltage_levels()
+    
+    if sort_index:
+        voltage_levels = net.get_voltage_levels().sort_index()
+    else:
+        voltage_levels = net.get_voltage_levels()
+        
+    all_buses_vn_kv = voltage_levels.loc[bus_df["voltage_level_id"].values]["nominal_v"].values
+    sub_unique = None
+    sub_unique_id = None
+    if n_busbar_per_sub is not None and buses_for_sub is not None:
+        # I am in a compatibility mode,
+        # I need to use the same convention as grid2op
+        # for the buses labelling
+        bus_df = bus_df.sort_values("voltage_level_id", kind="stable")
+        sub_unique = bus_df["voltage_level_id"].unique()
+        nb_sub_unique = sub_unique.shape[0]
+        sub_unique_id = np.arange(nb_sub_unique)
+        bus_per_sub =  bus_df[["voltage_level_id", "name"]].groupby("voltage_level_id").count()
+        if (bus_per_sub["name"] > n_busbar_per_sub).any():
+            max_bb = bus_per_sub["name"].max()
+            raise RuntimeError(f"Impossible configuration: we found a substation with {max_bb} "
+                               f"while asking for {n_busbar_per_sub}. We cannot load a grid with these "
+                               f"kwargs. If you use LightSimBackend, you need to change `loader_kwargs` "
+                               f"and especially the `n_busbar_per_sub` to be >= {max_bb}")
+        bus_local_id = np.concatenate([np.arange(el) for el in bus_per_sub.values])
+        sub_id_duplicate = np.repeat(sub_unique_id, bus_per_sub.values.ravel())
+        bus_global_id = bus_local_id * nb_sub_unique + sub_id_duplicate
+        bus_df["bus_id"] = bus_global_id
+        all_buses_vn_kv = 1. * voltage_levels["nominal_v"].values
+        ls_to_orig = np.zeros(n_busbar_per_sub * nb_sub_unique, dtype=int) - 1
+        ls_to_orig[bus_df["bus_id"].values] = np.arange(bus_df.shape[0])
+        n_sub = nb_sub_unique
+        n_bb_per_sub = n_busbar_per_sub
+        bus_df = bus_df.sort_index()
+    else:
+        if buses_for_sub is not None:
+            raise NotImplementedError("This is not implemented at the moment")
+        # retrieve the labels from the buses in the original grid
+        bus_df["bus_id"] = -1
+        bus_df.loc[bus_df_orig.index, "bus_id"] = np.arange(bus_df.shape[0]) 
+        bus_df = bus_df.sort_values("bus_id")
+        ls_to_orig = 1 * bus_df["bus_id"].values
+        
+        n_sub = bus_df.shape[0]
+        n_bb_per_sub = None
+        if n_busbar_per_sub is None:
+            warnings.warn("You should avoid using this function without at least `buses_for_sub` or `n_busbar_per_sub`. "
+                          "Setting automatically n_busbar_per_sub=1")
+            n_busbar_per_sub = 1
+            
+        # used to be done in the Backend previously, now we do it here instead
+        bus_init = 1. * all_buses_vn_kv
+        bus_doubled = np.concatenate([bus_init for _ in range(n_busbar_per_sub)])
+        ls_to_orig = np.concatenate((ls_to_orig, np.full((n_busbar_per_sub - 1) * n_sub, fill_value=-1, dtype=ls_to_orig.dtype)))
+        
+    all_buses_vn_kv = np.concatenate([all_buses_vn_kv for _ in range(n_busbar_per_sub)])
     model.set_sn_mva(sn_mva)
     model.set_init_vm_pu(1.06)
-    model.init_bus(voltage_levels.loc[bus_df["voltage_level_id"].values]["nominal_v"].values,
+    model.init_bus(all_buses_vn_kv,
                    0, 0  # unused
                    )
-    model._orig_to_ls = 1 * bus_df_orig["bus_id"].values
+    model._ls_to_orig = ls_to_orig
+    model.set_n_sub(n_sub)
+    if n_bb_per_sub is not None:
+        model._max_nb_bus_per_sub = n_busbar_per_sub
     
     # do the generators
     if sort_index:
         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 * 1e-4 + 1.
-    max_q[~np.isfinite(max_q)] = np.finfo(np.float32).max * 1e-4 - 1.
+    min_float_value = np.finfo(np.float32).min * 1e-4 + 1.
+    max_float_value = np.finfo(np.float32).max * 1e-4 + 1.
+    min_q_aux = 1. * df_gen["min_q"].values
+    too_small = min_q_aux < min_float_value
+    min_q_aux[too_small] = min_float_value
+    min_q = min_q_aux.astype(np.float32)
+    
+    max_q_aux = 1. * df_gen["max_q"].values
+    too_big = np.abs(max_q_aux) > max_float_value
+    max_q_aux[too_big] = np.sign(max_q_aux[too_big]) * max_float_value
+    max_q = max_q_aux.astype(np.float32)
+    min_q[~np.isfinite(min_q)] = min_float_value
+    max_q[~np.isfinite(max_q)] = max_float_value
     gen_bus, gen_disco = _aux_get_bus(bus_df, df_gen)
+
+    # dirty fix for when regulating elements are not the same
+    bus_reg = copy.deepcopy(df_gen["regulated_element_id"].values)
+    vl_reg = copy.deepcopy(df_gen["voltage_level_id"].values)
+    mask_ref_bbs = bus_reg != df_gen.index
+    
+    bbs_df = net.get_busbar_sections().copy()
+    if not (np.isin(bus_reg[mask_ref_bbs], bbs_df.index)).all():
+        raise RuntimeError("At least some generator are in 'remote control' mode "
+                           "and does not control a busbar section, this is not supported "
+                           "at the moment.")
+    vl_reg[mask_ref_bbs] = bbs_df.loc[bus_reg[mask_ref_bbs], "voltage_level_id"].values
     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_v"].values / voltage_levels.loc[df_gen["voltage_level_id"].values]["nominal_v"].values,
+                               df_gen["target_v"].values / voltage_levels.loc[vl_reg]["nominal_v"].values,
                                df_gen["target_q"].values,
                                df_gen["voltage_regulator_on"].values,
                                min_q,
@@ -116,30 +198,44 @@ def init(net : pypo.network,
     else:
         df_line = net.get_lines()
     # per unit
-    branch_from_kv = voltage_levels.loc[df_line["voltage_level1_id"].values]["nominal_v"].values
-    branch_to_kv = voltage_levels.loc[df_line["voltage_level2_id"].values]["nominal_v"].values
+    if net_pu is None:
+        try:
+            net_pu = copy.deepcopy(net)
+            net_pu.per_unit = True
+        except Exception as exc_:
+            from pypowsybl.network import PerUnitView
+            net_pu = PerUnitView(net)
+            warnings.warn("The `PerUnitView` (python side) is less efficient and less "
+                        "tested that the equivalent java class. Please upgrade pypowsybl version")
+    df_line_pu = net_pu.get_lines().loc[df_line.index]
+    # branch_from_kv = voltage_levels.loc[df_line["voltage_level1_id"].values]["nominal_v"].values
+    # branch_to_kv = voltage_levels.loc[df_line["voltage_level2_id"].values]["nominal_v"].values
     
     # only valid for lines with same voltages at both side...
-    # branch_from_pu = branch_from_kv * branch_from_kv / sn_mva
-    # line_r = df_line["r"].values / branch_from_pu
-    # line_x = df_line["x"].values / branch_from_pu  
-    # line_h_or = (1j*df_line["g1"].values + df_line["b1"].values) * branch_from_pu
-    # line_h_ex = (1j*df_line["g2"].values + df_line["b2"].values) * branch_from_pu
+    # # branch_from_pu = branch_from_kv * branch_from_kv / sn_mva
+    # # line_r = df_line["r"].values / branch_from_pu
+    # # line_x = df_line["x"].values / branch_from_pu  
+    # # line_h_or = (1j*df_line["g1"].values + df_line["b1"].values) * branch_from_pu
+    # # line_h_ex = (1j*df_line["g2"].values + df_line["b2"].values) * branch_from_pu
     # real per unit conversion 
     # see https://github.com/powsybl/pypowsybl/issues/642
     # see https://github.com/powsybl/powsybl-core/blob/266442cbbd84f630acf786018618eaa3d496c6ba/ieee-cdf/ieee-cdf-converter/src/main/java/com/powsybl/ieeecdf/converter/IeeeCdfImporter.java#L347
     # for right formula
-    v1 = branch_from_kv
-    v2 = branch_to_kv
-    line_r = sn_mva *  df_line["r"].values / v1 / v2
-    line_x = sn_mva *  df_line["x"].values / v1 / v2
-    tmp_ = np.reciprocal(df_line["r"].values + 1j*df_line["x"].values)
-    b1 = df_line["b1"].values * v1*v1/sn_mva + (v1-v2)*tmp_.imag*v1/sn_mva
-    b2 = df_line["b2"].values * v2*v2/sn_mva + (v2-v1)*tmp_.imag*v2/sn_mva
-    g1 = df_line["g1"].values * v1*v1/sn_mva + (v1-v2)*tmp_.real*v1/sn_mva
-    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)
+    # v1 = branch_from_kv
+    # v2 = branch_to_kv
+    # line_r = sn_mva *  df_line["r"].values / v1 / v2
+    # line_x = sn_mva *  df_line["x"].values / v1 / v2
+    # tmp_ = np.reciprocal(df_line["r"].values + 1j*df_line["x"].values)
+    # b1 = df_line["b1"].values * v1*v1/sn_mva + (v1-v2)*tmp_.imag*v1/sn_mva
+    # b2 = df_line["b2"].values * v2*v2/sn_mva + (v2-v1)*tmp_.imag*v2/sn_mva
+    # g1 = df_line["g1"].values * v1*v1/sn_mva + (v1-v2)*tmp_.real*v1/sn_mva
+    # g2 = df_line["g2"].values * v2*v2/sn_mva + (v2-v1)*tmp_.real*v2/sn_mva
+    # line_h_or = (g1 + 1j * b1)
+    # line_h_ex = (g2 + 1j * b2)
+    line_r = df_line_pu["r"].values
+    line_x = df_line_pu["x"].values
+    line_h_or = (df_line_pu["g1"].values + 1j * df_line_pu["b1"].values)
+    line_h_ex = (df_line_pu["g2"].values + 1j * df_line_pu["b2"].values)
     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,
@@ -159,28 +255,66 @@ def init(net : pypo.network,
         df_trafo = net.get_2_windings_transformers().sort_index()
     else:
         df_trafo = net.get_2_windings_transformers()
-    # TODO net.get_ratio_tap_changers()
-    # TODO net.get_phase_tap_changers()
+        
+    df_trafo_pu = net_pu.get_2_windings_transformers().loc[df_trafo.index]
+    ratio_tap_changer = net_pu.get_ratio_tap_changers()
+    if net.get_phase_tap_changers().shape[0] > 0:
+        raise RuntimeError("Phase tap changer are not handled by the pypowsybl converter (but they are by lightsim2grid)")
+    # phase_tap_changer = net_pu.get_phase_tap_changers()
+    
     shift_ = np.zeros(df_trafo.shape[0])
-    tap_pos = 1.0 * shift_
-    is_tap_hv_side = np.ones(df_trafo.shape[0], dtype=bool)  # TODO
+    tap_position = 1.0 * shift_
+    is_tap_hv_side = np.zeros(df_trafo.shape[0], dtype=bool)  # TODO
     
     # per unit
-    trafo_from_kv = voltage_levels.loc[df_trafo["voltage_level1_id"].values]["nominal_v"].values
-    trafo_to_kv = voltage_levels.loc[df_trafo["voltage_level2_id"].values]["nominal_v"].values
-    trafo_to_pu = trafo_to_kv * trafo_to_kv / sn_mva
+    # trafo_from_kv = voltage_levels.loc[df_trafo["voltage_level1_id"].values]["nominal_v"].values
+    # trafo_to_kv = voltage_levels.loc[df_trafo["voltage_level2_id"].values]["nominal_v"].values
+    # trafo_to_pu = trafo_to_kv * trafo_to_kv / sn_mva
     # tap
-    tap_step_pct = (df_trafo["rated_u1"] / trafo_from_kv - 1.) * 100.
-    has_tap = tap_step_pct != 0.
-    tap_pos[has_tap] += 1
-    tap_step_pct[~has_tap] = 1.0  # or any other values...
+    # tap_step_pct = (df_trafo["rated_u1"] / trafo_from_kv - 1.) * 100.
+    # has_tap = tap_step_pct != 0.
+    # tap_pos[has_tap] += 1
+    # tap_step_pct[~has_tap] = 1.0  # or any other values...
+    # trafo_r = df_trafo["r"].values / trafo_to_pu
+    # trafo_x = df_trafo["x"].values / trafo_to_pu
+    # trafo_h = (df_trafo["g"].values + 1j * df_trafo["b"].values) * trafo_to_pu
+    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)
+    
+    # now get the ratio    
+    # in lightsim2grid (cpp)
+    # RealVect ratio = my_one_ + 0.01 * trafo_tap_step_pct.array() * trafo_tap_pos.array();
+    # in powsybl (https://javadoc.io/doc/com.powsybl/powsybl-core/latest/com/powsybl/iidm/network/TwoWindingsTransformer.html)
+    #  rho = transfo.getRatedU2() / transfo.getRatedU1()
+    # * (transfo.getRatioTapChanger() != null ? transfo.getRatioTapChanger().getCurrentStep().getRho() : 1);
+    # * (transfo.getPhaseTapChanger() != null ? transfo.getPhaseTapChanger().getCurrentStep().getRho() : 1);
+    ratio = 1. * (df_trafo_pu["rated_u2"].values / df_trafo_pu["rated_u1"].values)
+    has_r_tap_changer = np.isin(df_trafo_pu.index, ratio_tap_changer.index)
+    
+    if PYPOWSYBL_VER <= PP_BUG_RATIO_TAP_CHANGER:
+        # bug in per unit view in both python and java
+        ratio[has_r_tap_changer] = 1. * ratio_tap_changer.loc[df_trafo_pu.loc[has_r_tap_changer].index, "rho"].values
+    else:
+        ratio[has_r_tap_changer] *= 1. * ratio_tap_changer.loc[df_trafo_pu.loc[has_r_tap_changer].index, "rho"].values
+    no_tap = ratio == 1.
+    tap_neg = ratio < 1. 
+    tap_positive = ratio > 1. 
+    tap_step_pct = 1. * ratio
+    tap_step_pct[tap_positive] -= 1.
+    tap_step_pct[tap_positive] *= 100.
+    tap_step_pct[tap_neg] = (ratio[tap_neg] - 1.)*100.
+    tap_step_pct[no_tap] = 100.
+    tap_position[tap_positive] += 1
+    tap_position[tap_neg] += 1
+    
     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,
+    model.init_trafo(trafo_r,
+                     trafo_x,
+                     trafo_h,
                      tap_step_pct,
-                     tap_pos,
+                     tap_position,
                      shift_,
                      is_tap_hv_side,
                      tor_bus, # TODO do I need to change hv / lv
@@ -267,8 +401,8 @@ def init(net : pypo.network,
         else:
             try:
                 gen_slack_id_int = int(gen_slack_id)
-            except Exception:
-                raise RuntimeError("'slack_bus_id' should be either an int or a generator names")
+            except Exception as exc_:
+                raise RuntimeError("'slack_bus_id' should be either an int or a generator names") from exc_
             if gen_slack_id_int != gen_slack_id:
                 raise RuntimeError("'slack_bus_id' should be either an int or a generator names")
         model.add_gen_slackbus(gen_slack_id_int, 1.)
@@ -281,6 +415,8 @@ def init(net : pypo.network,
         for gen_id, is_slack in enumerate(gen_is_conn_slack):
             if is_slack:
                 model.add_gen_slackbus(gen_id, 1. / nb_conn)    
+    else:
+        raise RuntimeError("You need to provide at least one slack with `gen_slack_id` or `slack_bus_id`")
     
     # TODO
     # sgen => regular gen (from net.get_generators()) with voltage_regulator off TODO 
@@ -296,13 +432,19 @@ def init(net : pypo.network,
     # and now deactivate all elements and nodes not in the main component
     if only_main_component:
         model.consider_only_main_component()
+    model.init_bus_status()  # automatically disconnect non connected buses
     if not return_sub_id:
         # for backward compatibility
         return model
     else:
         # voltage_level_id is kind of what I call "substation" in grid2op
-        vl_unique = bus_df["voltage_level_id"].unique()
-        sub_df = pd.DataFrame(index=np.sort(vl_unique), data={"sub_id": np.arange(vl_unique.size)})
+        if sub_unique is None:
+            vl_unique = bus_df["voltage_level_id"].unique()
+            sub_df = pd.DataFrame(index=np.sort(vl_unique), data={"sub_id": np.arange(vl_unique.size)})
+        else:
+            # already computed before when innitializing the buses and substations
+            # I don't do it again to ensure consistency
+            sub_df = pd.DataFrame(index=sub_unique, data={"sub_id": sub_unique_id})
         buses_sub_id = pd.merge(left=bus_df, right=sub_df, how="left", left_on="voltage_level_id", right_index=True)[["bus_id", "sub_id"]]
         gen_sub = pd.merge(left=df_gen, right=sub_df, how="left", left_on="voltage_level_id", right_index=True)[["sub_id"]]
         load_sub = pd.merge(left=df_load, right=sub_df, how="left", left_on="voltage_level_id", right_index=True)[["sub_id"]]