linerate 2.1.2__tar.gz → 2.2.0__tar.gz

{linerate-2.1.2 → linerate-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linerate
-Version: 2.1.2
+Version: 2.2.0
 Summary: Library for computing line ampacity ratings for overhead lines
 Author-email: Statnett Datascience <Datascience.Drift@Statnett.no>, Yngve Mardal Moe <yngve.m.moe@gmail.com>
 Requires-Python: >=3.9

{linerate-2.1.2 → linerate-2.2.0}/linerate/models/thermal_model.py

@@ -198,6 +198,7 @@ class ThermalModel(ABC):
         min_ampacity: Ampere = 0,
         max_ampacity: Ampere = 5000,
         tolerance: float = 1.0,
+        accept_invalid_values: bool = False,
     ) -> Ampere:
         r"""Use the bisection method to compute the steady-state thermal rating (ampacity).
 
@@ -216,6 +217,9 @@ class ThermalModel(ABC):
             bisection iterations will stop once the numerical ampacity uncertainty is below
             :math:`\Delta I`. The bisection method will run for
             :math:`\left\lceil\frac{I_\text{min} - I_\text{min}}{\Delta I}\right\rceil` iterations.
+        accept_invalid_values:
+            If True, np.nan is returned whenever the current cannot be found within the provided
+            search interval. If False, a ValueError will be raised instead.
 
         Returns
         -------
@@ -228,6 +232,7 @@ class ThermalModel(ABC):
             min_ampacity=min_ampacity,
             max_ampacity=max_ampacity,
             tolerance=tolerance,
+            accept_invalid_values=accept_invalid_values,
         )
         n = self.span.num_conductors
         return I * n

{linerate-2.1.2 → linerate-2.2.0}/linerate/solver.py

@@ -1,5 +1,5 @@
 from functools import partial
-from typing import Callable, Optional
+from typing import Callable
 
 import numpy as np
 
@@ -13,7 +13,7 @@ def bisect(
     xmin: FloatOrFloatArray,
     xmax: FloatOrFloatArray,
     tolerance: float,
-    invalid_value: Optional[float] = None,
+    accept_invalid_values: bool = False,
 ) -> FloatOrFloatArray:
     r"""Compute the roots of a function using a vectorized bisection method.
 
@@ -32,10 +32,10 @@ def bisect(
         bounded within an interval of size :math:`\Delta x` or less. The bisection method will
         run for :math:`\left\lceil\frac{x_\max - x_\min}{\Delta x}\right\rceil`
         iterations.
-    invalid_value:
-        This value is used whenever
-        :math:`\text{sign}(f(\mathbf{x}_\min)) = \text{sign}(f(\mathbf{x}_\max))`. If not provided
-        np.nan is used.
+    accept_invalid_values:
+        If True, np.nan is returned whenever
+        :math:`\text{sign}(f(\mathbf{x}_\min)) = \text{sign}(f(\mathbf{x}_\max))`
+        If False, a ValueError will be raised.
 
     Returns
     -------
@@ -44,7 +44,7 @@ def bisect(
         there is a root :math:`x_i \in [\tilde{x}_i - 0.5 \Delta x, \tilde{x}_i + 0.5 \Delta x]`
         so :math:`f_i(x_i) = 0`.
     """
-    _invalid_value = np.nan if invalid_value is None else invalid_value
+    _invalid_value = np.nan
 
     if not np.all(np.isfinite(xmin)) or not np.all(np.isfinite(xmax)):
         raise ValueError("xmin and xmax must be finite.")
@@ -54,14 +54,15 @@ def bisect(
     f_right = f(xmax)
 
     invalid_mask = np.sign(f_left) == np.sign(f_right)
-    if np.any(invalid_mask) and invalid_value is None:
+    if np.any(invalid_mask) and not accept_invalid_values:
         raise ValueError(
             "f(xmin) and f(xmax) have the same sign. Consider increasing the search interval."
         )
     elif isinstance(invalid_mask, bool) and invalid_mask:
         return _invalid_value
 
-    while interval > tolerance:
+    nan_mask = np.isnan(f_left) | np.isnan(f_right)
+    while interval > tolerance and not np.all(nan_mask):
         xmid = 0.5 * (xmax + xmin)
         interval *= 0.5
         f_mid = f(xmid)
@@ -72,7 +73,10 @@ def bisect(
         f_left = np.where(mask, f_mid, f_left)
         f_right = np.where(mask, f_right, f_mid)
 
+        nan_mask = np.isnan(f_left) | np.isnan(f_right)
+
     out = np.where(invalid_mask, _invalid_value, 0.5 * (xmax + xmin))
+    out = np.where(nan_mask, np.nan, out)
     return out
 
 
@@ -121,7 +125,7 @@ def compute_conductor_ampacity(
     min_ampacity: Ampere = 0,
     max_ampacity: Ampere = 5_000,
     tolerance: float = 1,  # Ampere
-    invalid_value=None,
+    accept_invalid_values: bool = False,
 ) -> Ampere:
     r"""Use the bisection method to compute the steady-state thermal rating (ampacity).
 
@@ -144,10 +148,9 @@ def compute_conductor_ampacity(
         bisection iterations will stop once the numerical ampacity uncertainty is below
         :math:`\Delta I`. The bisection method will run for
         :math:`\left\lceil\frac{I_\text{max} - I_\text{min}}{\Delta I}\right\rceil` iterations.
-    invalid_value:
-        if the optimization problem is invalid, this value is returned instead of an error.
-        Suggested value: 0 for 0-ampacity when max_conductor_temperature is exceeded for all
-        ampacities.
+    accept_invalid_values:
+        If True, np.nan is returned whenever the current cannot be found within the provided
+        search interval. If False, a ValueError will be raised instead.
 
     Returns
     -------
@@ -156,4 +159,6 @@ def compute_conductor_ampacity(
     """
     f = partial(heat_balance, max_conductor_temperature)
 
-    return bisect(f, min_ampacity, max_ampacity, tolerance, invalid_value=invalid_value)
+    return bisect(
+        f, min_ampacity, max_ampacity, tolerance, accept_invalid_values=accept_invalid_values
+    )

{linerate-2.1.2 → linerate-2.2.0}/linerate.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linerate
-Version: 2.1.2
+Version: 2.2.0
 Summary: Library for computing line ampacity ratings for overhead lines
 Author-email: Statnett Datascience <Datascience.Drift@Statnett.no>, Yngve Mardal Moe <yngve.m.moe@gmail.com>
 Requires-Python: >=3.9

{linerate-2.1.2 → linerate-2.2.0}/tests/test_solver.py

@@ -87,3 +87,35 @@ def test_bisect_raises_valueerror_when_infinite_in_array_input():
             xmax=np.array([10_000, 10_000]),
             tolerance=1e-8,
         )
+
+
+def test_bisect_returns_dtype_float_if_not_accept_invalid_values():
+    def heat_balance(currents: np.array):
+        A = currents
+        T = 90
+        res = (A - 100 * T) * (currents + 100 * T)
+        return res
+
+    solution = solver.bisect(
+        heat_balance,
+        xmin=np.array([0, 0]),
+        xmax=np.array([10_000, 10_000]),
+        tolerance=1e-8,
+        accept_invalid_values=False,
+    )
+
+    assert solution.dtype == np.float64
+
+
+def test_bisect_return_nan_if_heat_balance_returns_nan():
+    def heat_balance(currents: np.array):
+        return np.ones_like(currents) * np.nan
+
+    solution = solver.bisect(
+        heat_balance,
+        xmin=np.array([0, 0]),
+        xmax=np.array([10_000, 10_000]),
+        tolerance=1e-8,
+    )
+
+    np.testing.assert_array_equal(np.isnan(solution), np.full_like(solution, True, dtype=bool))