Merge remote-tracking branch 'origin/structure_dict_extension' into structure_dict_extension

Author: lezneew

.github/workflows/github_test_action.yml

@@ -49,12 +49,12 @@ jobs:
       - name: Test with pytest
         if: ${{ matrix.python-version != '3.10' }}
         run: |
-          uv run pytest -n=auto --splits 2 --group ${{ matrix.group }} --ignore=pandapower/test/opf
+          uv run pytest --splits 2 --group ${{ matrix.group }} --ignore=pandapower/test/opf
       - name: Test with pytest, Codecov and Coverage
         if: ${{ matrix.python-version == '3.10' }}
         run: |
           uv pip install pytest-cov numpy~=1.26
-          uv run pytest -n=auto --cov=./ --cov-report=xml --splits 2 --group ${{ matrix.group }} --ignore=pandapower/test/opf
+          uv run pytest --cov=./ --cov-report=xml --splits 2 --group ${{ matrix.group }} --ignore=pandapower/test/opf
           cp ./coverage.xml ./coverage-${{ matrix.group }}.xml
       - name: Upload coverage as artifact
         if: ${{ matrix.python-version == '3.10' }}
@@ -86,7 +86,7 @@ jobs:
           uv pip list
       - name: Test with pytest
         run: |
-          uv run pytest -n=auto --splits 2 --group ${{ matrix.group }} --ignore=pandapower/test/opf
+          uv run pytest --splits 2 --group ${{ matrix.group }} --ignore=pandapower/test/opf
 
   opf:
     # needs: build
@@ -133,7 +133,7 @@ jobs:
       - name: Test with pytest, Codecov and Coverage
         run: |
           pytest --cov=./ --cov-report=xml pandapower/test/opf
-          # uv run python-jl -m pytest -n=auto --cov=./ --cov-report=xml
+          # uv run python-jl -m pytest --cov=./ --cov-report=xml
           cp ./coverage.xml ./coverage-${{ matrix.group }}.xml
 
   upload-coverage:
@@ -342,7 +342,7 @@ jobs:
       - name: Test with pytest
         # Careful when copying this command. The PYTHONPATH setup is Linux specific syntax.
         run: |
-          pytest --nbmake -n=auto --nbmake-timeout=900 --timeout=900 "./tutorials"
+          pytest --nbmake --nbmake-timeout=900 --timeout=900 "./tutorials"
 
   tutorial_warnings_tests:
     needs: build
@@ -358,7 +358,7 @@ jobs:
           python -m pip list
       - name: Test with pytest
         run: |
-          pytest -W error --nbmake -n=auto --nbmake-timeout=900 --timeout=900 "./tutorials"
+          pytest -W error --nbmake --nbmake-timeout=900 --timeout=900 "./tutorials"
 
   docs_check:
     needs: build

.github/workflows/test_release.yml

@@ -55,4 +55,4 @@ jobs:
 
       - name: Test with pytest
         run: |
-          uv run pytest -n=auto --splits 2 --group ${{ matrix.group }}
+          uv run pytest --splits 2 --group ${{ matrix.group }}

.test_durations

@@ -1938,7 +1938,17 @@ def SVabc_from_SV012(
 
 
 def _add_dcline_gens(net: pandapowerNet) -> None:
+    """
+    For each HVDC Link create consumption and supply generator
+    
+    Parameters:
+        net: network to add the generators to
+
+    Returns:
+        None
+    """
     from pandapower.create import create_gen
+    
     for dctab in net.dcline.itertuples():
         p_mw = np.abs(dctab.p_mw)
         p_loss = p_mw * (1 - dctab.loss_percent / 100) - dctab.loss_mw  # type: ignore[operator]

pandapower/auxiliary.py

@@ -139,7 +139,7 @@ def create_switches(
     buses: Sequence,
     elements: Sequence,
     et: SwitchElementType | Sequence[str],
-    closed: bool = True,
+    closed: bool | Iterable[bool] = True,
     type: SwitchType | None = None,
     name: Iterable[str] | None = None,
     index: Int | Iterable[Int] | None = None,

pandapower/create/switch_create.py

@@ -6,7 +6,12 @@
 import numpy as np
 import pandas as pd
 
-from pandapower.auxiliary import _init_runpp_options, _add_dcline_gens, LoadflowNotConverged
+from pandapower.auxiliary import (
+    _init_runpp_options,
+    _add_dcline_gens,
+    LoadflowNotConverged,
+    pandapowerNet,
+)
 from pandapower.create import create_ext_grid, create_bus, create_impedance, create_transformer_from_parameters, \
     create_load
 from pandapower.diagnostic import diagnostic
@@ -27,7 +32,7 @@
 impedance_columns = ["from_bus", "to_bus", "rft_pu", "xft_pu", "rtf_pu", "xtf_pu", "gf_pu", "bf_pu", "gt_pu", "bt_pu"]
 
 
-def _runpp_except_voltage_angles(net, **kwargs):
+def _runpp_except_voltage_angles(net: pandapowerNet, **kwargs) -> pandapowerNet:
     if "calculate_voltage_angles" not in kwargs or not kwargs["calculate_voltage_angles"]:
         runpp(net, **kwargs)
     else:
@@ -404,15 +409,19 @@ def match_cost_functions_and_eq_net(net, boundary_buses, eq_type):
 
 def _check_network(net):
     """
-    This function will perfoms some checks and modifications on the given grid model.
+    This function will perform some checks and modifications on the given grid model.
+    
+    Check inactive elements
+    Check dc lines and replace by gen if exists
+    Check controller names
     """
-    # --- check invative elements
+    # --- check inactive elements
     if net.res_bus.vm_pu.isnull().any():
         logger.info("There are some inactive buses. It is suggested to remove "
                     "them using 'pandapower.drop_inactive_elements()' "
                     "before starting the grid equivalent calculation.")
 
-    # --- check dclines
+    # --- check and replace dclines by gens
     if "dcline" in net and len(net.dcline.query("in_service")) > 0:
         _add_dcline_gens(net)
         dcline_index = net.dcline.index.values

pandapower/grid_equivalents/auxiliary.py

@@ -4,24 +4,24 @@
 import pandas as pd
 
 from pandapower.create import create_group_from_dict
-from pandapower.grid_equivalents.auxiliary import drop_assist_elms_by_creating_ext_net, \
-    drop_internal_branch_elements, add_ext_grids_to_boundaries, \
-    _ensure_unique_boundary_bus_names, match_cost_functions_and_eq_net, \
-    _check_network, _runpp_except_voltage_angles
-from pandapower.grid_equivalents.rei_generation import _create_net_zpbn, \
-    _get_internal_and_external_nets, _calculate_equivalent_Ybus, \
-    _create_bus_lookups, _calclate_equivalent_element_params, \
-    _replace_ext_area_by_impedances_and_shunts
-from pandapower.grid_equivalents.ward_generation import \
-    _calculate_ward_and_impedance_parameters, \
-    _calculate_xward_and_impedance_parameters, \
-    create_passive_external_net_for_ward_admittance, \
-    _replace_external_area_by_wards, _replace_external_area_by_xwards
+from pandapower.grid_equivalents.auxiliary import (
+    drop_assist_elms_by_creating_ext_net, drop_internal_branch_elements, add_ext_grids_to_boundaries,
+    _ensure_unique_boundary_bus_names, match_cost_functions_and_eq_net, _check_network, _runpp_except_voltage_angles
+)
+from pandapower.grid_equivalents.rei_generation import (
+    _create_net_zpbn, _get_internal_and_external_nets, _calculate_equivalent_Ybus, _create_bus_lookups,
+    _calclate_equivalent_element_params, _replace_ext_area_by_impedances_and_shunts
+)
+from pandapower.grid_equivalents.ward_generation import (
+    _calculate_ward_and_impedance_parameters, _calculate_xward_and_impedance_parameters,
+    create_passive_external_net_for_ward_admittance, _replace_external_area_by_wards, _replace_external_area_by_xwards
+)
 from pandapower.groups import isin_group, set_group_reference_column
-from pandapower.run import runpp
 from pandapower.toolbox.data_modification import reindex_buses
-from pandapower.toolbox.grid_modification import replace_ward_by_internal_elements, replace_xward_by_internal_elements, \
-    drop_buses, drop_elements_at_buses, merge_nets, fuse_buses
+from pandapower.toolbox.grid_modification import (
+    replace_ward_by_internal_elements, replace_xward_by_internal_elements, drop_buses, drop_elements_at_buses,
+    merge_nets, fuse_buses
+)
 from pandapower.topology.create_graph import create_nxgraph
 from pandapower.topology.graph_searches import connected_component, connected_components
 
@@ -144,11 +144,6 @@ def get_equivalent(
         logger.debug("xward elements of the external network are replaced by internal elements.")
         replace_xward_by_internal_elements(net, xwards=ext_buses_with_xward.index)
 
-    # --- switch from ward injection to ward addmittance if requested
-    if eq_type in ["ward", "xward"] and ward_type == "ward_admittance":
-        create_passive_external_net_for_ward_admittance(
-            net, all_external_buses, boundary_buses, runpp_fct=runpp_fct, **kwargs)
-
     # --- rei calculations
     if eq_type == "rei":
         # --- create zero power balance network
@@ -182,6 +177,11 @@ def get_equivalent(
 
     # --- ward and xward calculations
     elif eq_type in ["ward", "xward"]:
+        # --- switch from ward injection to ward addmittance if requested
+        if ward_type == "ward_admittance":
+            create_passive_external_net_for_ward_admittance(
+                net, all_external_buses, boundary_buses, runpp_fct=runpp_fct, **kwargs)
+
         net_internal, net_external = _get_internal_and_external_nets(
             net, boundary_buses, all_internal_buses, all_external_buses,
             calc_volt_angles=calculate_voltage_angles, runpp_fct=runpp_fct)
@@ -201,34 +201,38 @@ def get_equivalent(
 
         if eq_type == "ward":
             # --- calculate equivalent impedance and wards
-            ward_parameter_no_power, impedance_parameter = \
-                _calculate_ward_and_impedance_parameters(Ybus_eq, bus_lookups,
-                                                         show_computing_time)
+            ward_parameter_no_power, impedance_parameter = _calculate_ward_and_impedance_parameters(
+                Ybus_eq, bus_lookups, show_computing_time
+            )
 
             # --- replace external network by equivalent elements
-            _replace_external_area_by_wards(net_external, bus_lookups,
-                                            ward_parameter_no_power,
-                                            impedance_parameter,
-                                            ext_buses_with_xward,
-                                            show_computing_time,
-                                            calc_volt_angles=calculate_voltage_angles,
-                                            runpp_fct=runpp_fct)
+            _replace_external_area_by_wards(
+                net_external,
+                bus_lookups,
+                ward_parameter_no_power,
+                impedance_parameter,
+                ext_buses_with_xward,
+                show_computing_time,
+                calc_volt_angles=calculate_voltage_angles,
+                runpp_fct=runpp_fct
+            )
         else:  # eq_type == "xward"
             # --- calculate equivalent impedance and xwards
-            xward_parameter_no_power, impedance_parameter = \
-                _calculate_xward_and_impedance_parameters(net_external,
-                                                          Ybus_eq,
-                                                          bus_lookups,
-                                                          show_computing_time)
+            xward_parameter_no_power, impedance_parameter = _calculate_xward_and_impedance_parameters(
+                net_external, Ybus_eq, bus_lookups, show_computing_time
+            )
 
             # --- replace external network by equivalent elements
-            _replace_external_area_by_xwards(net_external, bus_lookups,
-                                             xward_parameter_no_power,
-                                             impedance_parameter,
-                                             ext_buses_with_xward,
-                                             show_computing_time,
-                                             calc_volt_angles=calculate_voltage_angles,
-                                             runpp_fct=runpp_fct)
+            _replace_external_area_by_xwards(
+                net_external,
+                bus_lookups,
+                xward_parameter_no_power,
+                impedance_parameter,
+                ext_buses_with_xward,
+                show_computing_time,
+                calc_volt_angles=calculate_voltage_angles,
+                runpp_fct=runpp_fct
+            )
         net_eq = net_external
     else:
         raise NotImplementedError(f"The {eq_type=} is unknown.")

pandapower/grid_equivalents/get_equivalent.py

@@ -523,33 +523,35 @@ def _get_internal_and_external_nets(net, boundary_buses, all_internal_buses,
                                     all_external_buses, show_computing_time=False,
                                     calc_volt_angles=True,
                                     runpp_fct=_runpp_except_voltage_angles, **kwargs):
-    "This function identifies the internal area and the external area"
+    """
+    This function identifies the internal area and the external area
+    """
     t_start = time.perf_counter()
     if not all_internal_buses:
         net_internal = None
     else:
         net_internal = deepcopy(net)
-        drop_measurements_and_controllers(net_internal, all_external_buses)
+        drop_measurements_and_controllers(net_internal, all_external_buses, True)
         drop_and_edit_cost_functions(net_internal, all_external_buses + boundary_buses, True, True)
         drop_buses(net_internal, all_external_buses)
 
     net_external = deepcopy(net)
     if "group" in net_external:
-        net_external.group = net_external.group.drop(net_external.group.index)
+        net_external.group = net_external.group[:0]  # clear dataframe
     drop_and_edit_cost_functions(net_external, all_internal_buses, True, True)
     drop_measurements_and_controllers(net_external, net_external.bus.index.tolist())
     drop_buses(net_external, all_internal_buses)
     replace_motor_by_load(net_external, all_external_buses)
     #    add_ext_grids_to_boundaries(net_external, boundary_buses, runpp_fct=runpp_fct, **kwargs)
     #    runpp_fct(net_external, calculate_voltage_angles=calc_volt_angles, **kwargs)
-    _integrate_power_elements_connected_with_switch_buses(net, net_external,
-                                                          all_external_buses)  # for sgens, gens, and loads
+
+    # for sgens, gens, and loads:
+    _integrate_power_elements_connected_with_switch_buses(net, net_external, all_external_buses)
+
     runpp_fct(net_external, calculate_voltage_angles=calc_volt_angles, **kwargs)
     t_end = time.perf_counter()
     if show_computing_time:
-        logger.info("\"get_int_and_ext_nets\" " +
-                    "finished in %s seconds:" % round((t_end - t_start), 2))
-
+        logger.info(f'"get_int_and_ext_nets" finished in {t_end - t_start:.02f} seconds.')
     return net_internal, net_external
 
 

pandapower/grid_equivalents/rei_generation.py

@@ -12,11 +12,12 @@
 logger = logging.getLogger(__name__)
 
 
-def _calculate_ward_and_impedance_parameters(Ybus_eq, bus_lookups, show_computing_time, power_eq=0):
-    """calculates the wards and equivalente impedance to represente the
-    external network"""
+def _calculate_ward_and_impedance_parameters(Ybus_eq, bus_lookups, show_computing_time):
+    """
+    calculates the wards and equivalent impedance to represent the external network
+    """
     t_start = time.perf_counter()
-    # --- calculate ward paramter
+    # --- calculate ward parameter
     b_buses_ppc = bus_lookups["bus_lookup_ppc"]["b_area_buses"]
     b_buses_pd = bus_lookups["bus_lookup_pd"]["b_area_buses"]
     nb_b_buses_ppc = len(b_buses_ppc)
@@ -27,36 +28,35 @@ def _calculate_ward_and_impedance_parameters(Ybus_eq, bus_lookups, show_computin
     ward_parameter["shunt"] = Ybus_eq.sum(axis=1)[-nb_b_buses_ppc:]
     ward_parameter["power_eq"] = 0 + 1j * 0  # power_eq.power_eq.values
 
-    # --- calculate impedance paramter
+    # --- calculate impedance parameter
     params = Ybus_eq[-nb_b_buses_ppc:, -nb_b_buses_ppc:]
     nl = nb_b_buses_ppc * (nb_b_buses_ppc - 1) // 2
     impedance_parameter = pd.DataFrame(
         data=np.arange(nl * len(impedance_columns)).reshape((nl, len(impedance_columns))), columns=impedance_columns,
         dtype=np.float64)
     k = 0
     for i in range(nb_b_buses_ppc):
-        for j in range(nb_b_buses_ppc):
-            if j > i:
-                if np.abs(params[i, j]) > 1e-10:
-                    impedance_parameter.loc[k, 'from_bus'] = b_buses_pd[i]
-                    impedance_parameter.loc[k, 'to_bus'] = b_buses_pd[j]
-                    impedance_parameter.loc[k, 'rft_pu'] = (-1 / params[i, j]).real
-                    impedance_parameter.loc[k, 'xft_pu'] = (-1 / params[i, j]).imag
-                    impedance_parameter.loc[k, 'rtf_pu'] = (-1 / params[j, i]).real
-                    impedance_parameter.loc[k, 'xtf_pu'] = (-1 / params[j, i]).imag
-                    k += 1
-                else:
-                    impedance_parameter = impedance_parameter[:-1]
+        for j in range(i+1, nb_b_buses_ppc):
+            if np.abs(params[i, j]) > 1e-10:
+                impedance_parameter.loc[k, 'from_bus'] = b_buses_pd[i]
+                impedance_parameter.loc[k, 'to_bus'] = b_buses_pd[j]
+                impedance_parameter.loc[k, 'rft_pu'] = (-1 / params[i, j]).real
+                impedance_parameter.loc[k, 'xft_pu'] = (-1 / params[i, j]).imag
+                impedance_parameter.loc[k, 'rtf_pu'] = (-1 / params[j, i]).real
+                impedance_parameter.loc[k, 'xtf_pu'] = (-1 / params[j, i]).imag
+                k += 1
+            else:
+                impedance_parameter = impedance_parameter[:-1]
     t_end = time.perf_counter()
     if show_computing_time:
-        logger.info("\"calculate_ward_and_impedance_parameters\" finished in %s seconds:" % round((
-                t_end - t_start), 2))
+        logger.info(f'"calculate_ward_and_impedance_parameters" finished in {t_end-t_start:02f} seconds.')
     return ward_parameter, impedance_parameter
 
 
-def _calculate_xward_and_impedance_parameters(net_external, Ybus_eq, bus_lookups,
-                                              show_computing_time, power_eq=0):
-    """calculates the xwards and the equivalent impedance"""
+def _calculate_xward_and_impedance_parameters(net_external, Ybus_eq, bus_lookups, show_computing_time):
+    """
+    calculates the xward and the equivalent impedance
+    """
     t_start = time.perf_counter()
     xward_parameter, impedance_parameter = \
         _calculate_ward_and_impedance_parameters(Ybus_eq, bus_lookups, False)
@@ -65,13 +65,10 @@ def _calculate_xward_and_impedance_parameters(net_external, Ybus_eq, bus_lookups
             -1 / xward_parameter.shunt.values.imag /
             net_external.sn_mva * net_external.bus.vn_kv[xward_parameter.bus_pd].values ** 2  #/2
     )
-    # np.square(net_external.bus.vn_kv[xward_parameter.bus_pd.values].values) / \
-    # net_external.sn_mva/2
     xward_parameter["vm_pu"] = net_external.res_bus.vm_pu[xward_parameter.bus_pd.values].values
     t_end = time.perf_counter()
     if show_computing_time:
-        logger.info("\"calculate_xward_and_impedance_parameters\" finished in %s seconds:" % round((
-                t_end - t_start), 2))
+        logger.info(f'"calculate_xward_and_impedance_parameters" finished in {t_end-t_start:02f} seconds.')
     return xward_parameter, impedance_parameter