384 bug voltage drop should be considered when selecting cable to connect new components

edisgo/config/config_grid_default.cfg

@@ -50,6 +50,11 @@ upper_limit_voltage_level_6 = 0.2
 upper_limit_voltage_level_5 = 5.5
 upper_limit_voltage_level_4 = 20.0
 
+lv_max_voltage_deviation = 0.03
+# from VDE-AR-N 4100 (VDE-AR-N 4100) Anwendungsregel: 2019-04
+mv_max_voltage_deviation = 0.02
+# from VDE-AR-N 4110 (VDE-AR-N 4110) Anwendungsregel: 2023-09
+
 [disconnecting_point]
 
 # Positioning of disconnecting points: Can be position at location of most

edisgo/tools/tools.py

@@ -193,7 +193,109 @@ def drop_duplicated_columns(df, keep="last"):
     return df.loc[:, ~df.columns.duplicated(keep=keep)]
 
 
-def select_cable(edisgo_obj, level, apparent_power):
+def calculate_voltage_diff_per_line(
+    s_max: float | np.ndarray,
+    r_total: float | np.ndarray,
+    x_total: float | np.ndarray,
+    v_nom: float | np.ndarray,
+    sign: int = -1,
+    cos_phi: float = 0.95,
+) -> float | np.ndarray:
+    """
+    Calculate the voltage difference across a line in kV.
+
+    Parameters
+    ----------
+    s_max : float or array-like
+        Apparent power the cable must carry in MVA.
+    r_total : float or array-like
+        Total resistance in Ohms.
+    x_total : float or array-like
+        Total reactance in Ohms.
+    v_nom : float or array-like
+        Nominal voltage in kV.
+    sign : int, optional
+        Sign of the reactance. -1 for inductive and +1 for capacitive. Default is -1.
+    cos_phi : float, optional
+        Power factor (cosine of the phase angle) of the load or generator.
+        Default is 0.95.
+
+    Returns
+    -------
+    float or array-like
+        Voltage difference in kV.
+    """
+    sin_phi = np.sqrt(1 - cos_phi**2)
+    # Calculate the voltage difference using the formula from VDE-AR-N 4105
+    voltage_diff = np.abs(
+        (s_max * 1e6 / (v_nom * 1e3)) * (r_total * cos_phi + sign * x_total * sin_phi)
+    )  # in V
+    return voltage_diff / 1e3  # Convert to kV
+
+
+def voltage_diff_pu(
+    R_per_km: float | np.ndarray,
+    L_per_km: float | np.ndarray,
+    length: float,
+    num_parallel: int,
+    v_nom: float | np.ndarray,
+    s_max: float | np.ndarray,
+    cos_phi: float = 0.95,
+    sign: int = -1,
+) -> float | np.ndarray:
+    """
+    Calculate the voltage difference per unit of nominal voltage.
+
+    Parameters
+    ----------
+    R_per_km : float or array-like
+        Resistance per kilometer of the cable in ohm/km.
+    L_per_km : float or array-like
+        Inductance per kilometer of the cable in mH/km.
+    length : float
+        Length of the cable in km.
+    num_parallel : int
+        Number of parallel cables.
+    v_nom : int
+        Nominal voltage in kV.
+    s_max : float
+        Apparent power the cable must carry in MVA.
+    cos_phi : float, optional
+        Cosine phi of the load or generator. Default: 0.95.
+    sign : int, optional
+        Sign of the reactance. -1 for inductive and +1 for capacitive. Default is -1.
+
+    Returns
+    -------
+    float
+        Voltage difference in per unit of nominal voltage.
+    """
+    # Calculate total resistance and reactance for the given length and
+    # number of parallel cables
+    r_total = calculate_line_resistance(R_per_km, length, num_parallel)
+    x_total = calculate_line_reactance(L_per_km, length, num_parallel)
+
+    # Calculate the voltage drop or increase
+    delta_v = calculate_voltage_diff_per_line(
+        s_max, r_total, x_total, v_nom, sign=sign, cos_phi=cos_phi
+    )
+
+    # Convert voltage difference to per unit of nominal voltage
+    voltage_difference_pu = delta_v / v_nom
+
+    return voltage_difference_pu
+
+
+def select_cable(
+    edisgo_obj: EDisGo,
+    level: str,
+    apparent_power: float,
+    length: float = 0,
+    max_voltage_diff: float | None = None,
+    max_cables: int = 7,
+    cos_phi: float | None = 0.95,
+    inductive_reactance: bool = True,
+) -> tuple[pd.Series, int]:
     """
     Selects suitable cable type and quantity using given apparent power.
 
@@ -209,6 +311,17 @@ def select_cable(edisgo_obj, level, apparent_power):
         'lv'.
     apparent_power : float
         Apparent power the cable must carry in MVA.
+    length : float
+        Length of the cable in km. Default: 0.
+    max_voltage_diff : float
+        Maximum voltage difference in pu. Default: None.
+    max_cables : int
+        Maximum number of parallel cables to consider. Default is 7.
+    cos_phi : float
+        Cosine phi of the load or generator. Default: 0.95.
+    inductive_reactance : bool
+        If True, inductive reactance is considered. Default
+        is True. If False, capacitive reactance is considered.
 
     Returns
     -------
@@ -219,39 +332,76 @@ def select_cable(edisgo_obj, level, apparent_power):
         Number of necessary parallel cables.
 
     """
-
-    cable_count = 1
-
+    if not cos_phi:
+        cos_phi = 0.95
+    if inductive_reactance:
+        sign = -1
+    else:
+        sign = 1
     if level == "mv":
         cable_data = edisgo_obj.topology.equipment_data["mv_cables"]
         available_cables = cable_data[
             cable_data["U_n"] == edisgo_obj.topology.mv_grid.nominal_voltage
         ]
+        if not max_voltage_diff:
+            max_voltage_diff = edisgo_obj.config["grid_connection"][
+                "mv_max_voltage_deviation"
+            ]
     elif level == "lv":
         available_cables = edisgo_obj.topology.equipment_data["lv_cables"]
+        if not max_voltage_diff:
+            max_voltage_diff = edisgo_obj.config["grid_connection"][
+                "lv_max_voltage_deviation"
+            ]
     else:
         raise ValueError(
             "Specified voltage level is not valid. Must either be 'mv' or 'lv'."
         )
-
+    cable_count = 1
     suitable_cables = available_cables[
         calculate_apparent_power(
             available_cables["U_n"], available_cables["I_max_th"], cable_count
         )
         > apparent_power
     ]
+    if length != 0:
+        suitable_cables = suitable_cables[
+            voltage_diff_pu(
+                R_per_km=available_cables["R_per_km"],
+                L_per_km=available_cables["L_per_km"],
+                length=length,
+                num_parallel=cable_count,
+                v_nom=available_cables["U_n"],
+                s_max=apparent_power,
+                cos_phi=cos_phi,
+                sign=sign,
+            )
+            < max_voltage_diff
+        ]
 
     # increase cable count until appropriate cable type is found
-    while suitable_cables.empty and cable_count < 7:
+    while suitable_cables.empty and cable_count < max_cables:  # parameter
         cable_count += 1
         suitable_cables = available_cables[
             calculate_apparent_power(
-                available_cables["U_n"],
-                available_cables["I_max_th"],
-                cable_count,
+                available_cables["U_n"], available_cables["I_max_th"], cable_count
             )
             > apparent_power
         ]
+        if length != 0:
+            suitable_cables = suitable_cables[
+                voltage_diff_pu(
+                    R_per_km=available_cables["R_per_km"],
+                    L_per_km=available_cables["L_per_km"],
+                    length=length,
+                    num_parallel=cable_count,
+                    v_nom=available_cables["U_n"],
+                    s_max=apparent_power,
+                    cos_phi=cos_phi,
+                    sign=sign,
+                )
+                < max_voltage_diff
+            ]
     if suitable_cables.empty:
         raise exceptions.MaximumIterationError(
             "Could not find a suitable cable for apparent power of "

tests/tools/test_tools.py

@@ -30,6 +30,56 @@ def test_calculate_line_reactance(self):
         data = tools.calculate_line_reactance(np.array([2, 3]), 3, 2)
         assert_allclose(data, np.array([1.88496 / 2, 2.82743 / 2]), rtol=1e-5)
 
+    def test_voltage_diff(self):
+        data = tools.calculate_voltage_diff_per_line(50, 0.125, 0.36, 20, -1, 0.9)
+        correct_value = 0.11105090491866049
+        assert np.isclose(data, correct_value)
+        data = tools.calculate_voltage_diff_per_line(
+            np.array([50, 50]),
+            np.array([0.125, 0.125]),
+            np.array([0.36, 0.36]),
+            20,
+            -1,
+            0.9,
+        )
+        assert_allclose(data, np.array([correct_value, correct_value]), rtol=1e-5)
+        data = tools.calculate_voltage_diff_per_line(50, 0.125, 0.36, 40, -1, 0.9)
+        assert np.isclose(data, correct_value / 2)
+        data = tools.calculate_voltage_diff_per_line(100, 0.125, 0.36, 20, -1, 0.9)
+        assert np.isclose(data, correct_value * 2)
+        data = tools.calculate_voltage_diff_per_line(
+            np.array([100, 100]),
+            np.array([0.125, 0.125]),
+            np.array([0.36, 0.36]),
+            np.array([20, 20]),
+            -1,
+            0.9,
+        )
+        assert_allclose(
+            data, np.array([correct_value * 2, correct_value * 2]), rtol=1e-5
+        )
+
+    def test_voltage_diff_pu(self):
+        data = tools.voltage_diff_pu(0.1, 0.350, 1, 1, 20, 50, 0.9, -1)
+        correct_value = 0.52589253567891375 * 1e-2
+        assert np.isclose(data, correct_value)
+        data = tools.voltage_diff_pu(
+            np.array([0.1, 0.1]), np.array([0.35, 0.35]), 1, 1, 20, 50, 0.9, -1
+        )
+        assert_allclose(data, np.array([correct_value, correct_value]), rtol=1e-5)
+        data = tools.voltage_diff_pu(0.1, 0.35, 2, 1, 20, 50, 0.9, -1)
+        assert np.isclose(data, 2 * correct_value)
+        data = tools.voltage_diff_pu(
+            np.array([0.1, 0.1]), np.array([0.35, 0.35]), 2, 1, 20, 50, 0.9, -1
+        )
+        assert_allclose(
+            data,
+            np.array([2 * correct_value, 2 * correct_value]),
+            rtol=1e-5,
+        )
+        data = tools.voltage_diff_pu(0.1, 0.35, 1, 2, 20, 50, 0.9, -1)
+        assert np.isclose(data, correct_value / 2)
+
     def test_calculate_line_resistance(self):
         # test single line
         data = tools.calculate_line_resistance(2, 3, 1)
@@ -97,6 +147,7 @@ def test_drop_duplicated_columns(self):
         assert (check_df.loc[:, "a"] == [4, 5, 6]).all()
 
     def test_select_cable(self):
+        # no length given
         cable_data, num_parallel_cables = tools.select_cable(self.edisgo, "mv", 5.1)
         assert cable_data.name == "NA2XS2Y 3x1x150 RE/25"
         assert num_parallel_cables == 1
@@ -109,6 +160,38 @@ def test_select_cable(self):
         assert cable_data.name == "NAYY 4x1x150"
         assert num_parallel_cables == 1
 
+        # length given
+        cable_data, num_parallel_cables = tools.select_cable(self.edisgo, "mv", 5.1, 2)
+        assert cable_data.name == "NA2XS2Y 3x1x150 RE/25"
+        assert num_parallel_cables == 1
+
+        cable_data, num_parallel_cables = tools.select_cable(self.edisgo, "mv", 40, 1)
+        assert cable_data.name == "NA2XS(FL)2Y 3x1x500 RM/35"
+        assert num_parallel_cables == 2
+
+        cable_data, num_parallel_cables = tools.select_cable(self.edisgo, "lv", 0.18, 1)
+        assert cable_data.name == "NAYY 4x1x300"
+        assert num_parallel_cables == 3
+
+        cable_data, num_parallel_cables = tools.select_cable(
+            self.edisgo, "lv", 0.18, 1, max_voltage_diff=0.01, max_cables=100
+        )
+        assert cable_data.name == "NAYY 4x1x300"
+        assert num_parallel_cables == 8
+
+        cable_data, num_parallel_cables = tools.select_cable(
+            self.edisgo,
+            "lv",
+            0.18,
+            1,
+            max_voltage_diff=0.01,
+            max_cables=100,
+            cos_phi=1,
+            inductive_reactance=False,
+        )
+        assert cable_data.name == "NAYY 4x1x300"
+        assert num_parallel_cables == 12
+
     def test_get_downstream_buses(self):
         # ######## test with LV bus ########
         buses_downstream = tools.get_downstream_buses(