pydra-core 0.0.1__py2.py3-none-any.whl

pydra_core/__init__.py

@@ -0,0 +1,32 @@
+__version__ = "0.0.1"
+#############################################################
+# Pydra (v2)
+# Contact: n.vandervegt@hkv.nl
+#############################################################
+
+# Core
+from .core.exceedance_frequency_line import ExceedanceFrequencyLine
+from .core.exceedance_frequency_line_experimental import (
+    ExceedanceFrequencyLineExperimental,
+)
+from .core.hbn import HBN
+
+# Enums
+from .common.enum import Breakwater
+from .common.enum import WaterSystem
+
+# Other
+from .hrdatabase.hrdatabase import HRDatabase
+from .location.location import Location
+from .location.profile.profile import Profile
+
+__all__ = [
+    "ExceedanceFrequencyLine",
+    "ExceedanceFrequencyLineExperimental",
+    "HBN",
+    "Breakwater",
+    "WaterSystem",
+    "HRDatabase",
+    "Location",
+    "Profile",
+]

pydra_core/common/common.py

@@ -0,0 +1,98 @@
+from .enum import WaterSystem
+
+
+class CommonFunctions:
+    """
+    A class with common functions.
+    """
+
+    @staticmethod
+    def is_coast(watersystem: WaterSystem) -> bool:
+        """
+        Returns True if a watersystem belongs to the coast loading model.
+
+        Parameters
+        ----------
+        watersystem : WaterSystem
+            The watersystem
+
+        Returns
+        -------
+        bool
+            True if the watersystem is Coast
+        """
+        if watersystem in [
+            WaterSystem.COAST_SOUTH,
+            WaterSystem.COAST_CENTRAL,
+            WaterSystem.COAST_NORTH,
+            WaterSystem.COAST_DUNES,
+            WaterSystem.WADDEN_SEA_WEST,
+            WaterSystem.WADDEN_SEA_EAST,
+            WaterSystem.WESTERN_SCHELDT,
+        ]:
+            return True
+        return False
+
+    @staticmethod
+    def is_lower_rivier(watersystem: WaterSystem) -> bool:
+        """
+        Returns True if a watersystem belongs to the lower river loading model.
+
+        Parameters
+        ----------
+        watersystem : WaterSystem
+            The watersystem
+
+        Returns
+        -------
+        bool
+            True if the watersystem is a lower river
+        """
+        if watersystem in [
+            WaterSystem.MEUSE_TIDAL,
+            WaterSystem.RHINE_TIDAL,
+            WaterSystem.EUROPOORT,
+        ]:
+            return True
+        return False
+
+    @staticmethod
+    def position_from_line(where, pt, refpts):
+        """
+        Check where a point is located relative to a line
+        """
+
+        def left(pt, refpts):
+            A, B = refpts
+            # Determine if the point is located left or right of the line
+            sign = ((B[0] - A[0]) * (pt[1] - A[1])) - ((B[1] - A[1]) * (pt[0] - A[0]))
+            if sign > 0:
+                left = True
+            else:
+                left = False
+            return left
+
+        if where == "north" or where == "south":
+            # Sorteer punten links naar recht, en kijk het links ligt
+            if refpts[0][0] > refpts[1][0]:
+                leftpoint, rightpoint = refpts[1], refpts[0]
+            else:
+                leftpoint, rightpoint = refpts[0], refpts[1]
+
+            # Bekijk of het punt links of recht van de lijn links naar rechts ligt
+            if where == "north":
+                return left(pt, [leftpoint, rightpoint])
+            else:
+                return left(pt, [rightpoint, leftpoint])
+
+        if where == "west" or where == "east":
+            # Sorteer punten onder naar boven, en kijk het links ligt
+            if refpts[0][1] > refpts[1][1]:
+                downpoint, toppoint = refpts[1], refpts[0]
+            else:
+                downpoint, toppoint = refpts[0], refpts[1]
+
+            if where == "west":
+                return left(pt, [downpoint, toppoint])
+            else:
+                return left(pt, [toppoint, downpoint])

pydra_core/common/enum.py

@@ -0,0 +1,63 @@
+from enum import Enum
+
+
+class WaterSystem(Enum):
+    """
+    A class representing different water systems in the Netherlands.
+
+    WaterSystem is an enumeration representing a specific water system in The
+    Netherlands and is defined with a unique integer value (WBI2017 Appendix
+    II). The enumeration members include both tidal and non-tidal water
+    systems, such as rivers, lakes, seas, and coastal regions.
+    """
+
+    RHINE_NON_TIDAL = 1
+    MEUSE_NON_TIDAL = 2
+    RHINE_TIDAL = 3
+    MEUSE_TIDAL = 4
+    IJSSEL_DELTA = 5
+    VECHT_DELTA = 6
+    IJSSEL_LAKE = 7
+    MARKER_LAKE = 8
+    WADDEN_SEA_EAST = 9
+    WADDEN_SEA_WEST = 10
+    COAST_NORTH = 11
+    COAST_CENTRAL = 12
+    COAST_SOUTH = 13
+    EASTERN_SCHELDT = 14
+    WESTERN_SCHELDT = 15
+    COAST_DUNES = 16
+    EUROPOORT = 17
+    MEUSE_VALLEY_NON_TIDAL = 18
+    VELUWE_LAKES = 19
+    GREVELINGEN = 20
+    VOLKERAK_ZOOMMEER = 21
+    HOLLANDSCHE_IJSSEL = 22
+    DIEFDIJK = 23
+
+
+class Breakwater(Enum):
+    """
+    Breakwater classes for profiles.
+
+    The 'Breakwater' is an enumeration representing specific types of
+    breakwaters located in front of the profile.
+    """
+
+    NO_BREAKWATER = 0
+    CAISSON = 1
+    VERTICAL_WALL = 2
+    RUBBLE_MOUND = 3
+
+
+class WaveShapeType(Enum):
+    """
+    Different wave form types.
+
+    The 'WaveShapeType' is an enumeration representing specific types of wave
+    forms used for slow stochastics. It can either be a discharge wave or a
+    lake level wave.
+    """
+
+    DISCHARGE = 0
+    LAKE_LEVEL = 1

pydra_core/common/interpolate.py

@@ -0,0 +1,345 @@
+import numpy as np
+
+
+class Interpolate:
+    """
+    A class with common functions used for interpolation.
+    """
+
+    @staticmethod
+    def inextrp1d(x, xp, fp):
+        """
+        Interpolate an array along the given axis.
+        Similar to np.interp, but with extrapolation outside range.
+
+        Parameters
+        ----------
+        x : np.array
+            Array with positions to interpolate at
+        xp : np.array
+            Array with positions of known values
+        fp : np.array
+            Array with values as known positions to interpolate between
+
+        Returns
+        -------
+        np.array
+            interpolated array
+        """
+        # Determine lower bounds
+        intidx = np.minimum(np.maximum(0, np.searchsorted(xp, x) - 1), len(xp) - 2)
+
+        # Determine interpolation fractions
+        fracs = (x - xp[intidx]) / (xp[intidx + 1] - xp[intidx])
+
+        # Interpolate (1-frac) * f_low + frac * f_up
+        f = (1 - fracs) * fp[intidx] + fp[intidx + 1] * fracs
+
+        return f
+
+    @staticmethod
+    def inextrp1d_log_probability(
+        x: np.ndarray, xp: np.ndarray, fp: np.ndarray
+    ) -> np.ndarray:
+        """
+        Perform 1D log-interpolation of log-probability values using piecewise
+        linear interpolation.
+
+        This function interpolates log-probability values for input points 'x'
+        using a given set of log-probabilities 'fp' and corresponding
+        probabilities 'xp'. The interpolation is performed in a piecewise
+        manner, taking into account the logarithmic nature of the data.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input points at which log-probabilities are to be interpolated.
+        xp : np.ndarray
+            Known data points representing the probabilities.
+        fp : np.ndarray
+            Log-probabilities corresponding to the known data points 'xp'.
+
+        Returns
+        -------
+        np.ndarray
+            Interpolated log-probability values for the input points 'x'.
+
+        Raises:
+            ValueError: If the provided xp values (probabilities) are not
+            monotonically increasing.
+
+        Notes
+        -----
+        -   The input array 'xp' should be strictly increasing; otherwise, a
+            ValueError is raised.
+        """
+        # Check whether the probabilities are monotonically decreasing
+        if not (np.diff(xp) >= 0.0).all():
+            raise ValueError(
+                "[ERROR] xp-values are not monotonically increasing or decreasing"
+            )
+
+        # Determine lower bounds
+        intidx = np.minimum(np.maximum(0, np.searchsorted(xp, x) - 1), len(xp) - 2)
+
+        # Split in log and linear part
+        iszero = xp[intidx] == 0.0
+        intidx_log = intidx[~iszero]
+        intidx_lin = intidx[iszero]
+
+        # Determine interpolation fractions
+        fracs = np.zeros(len(x), dtype=float)
+        fracs[~iszero] = (np.log(x[~iszero]) - np.log(xp[intidx_log])) / (
+            np.log(xp[intidx_log + 1]) - np.log(xp[intidx_log])
+        )
+        fracs[iszero] = (x[iszero] - xp[intidx_lin]) / (
+            xp[intidx_lin + 1] - xp[intidx_lin]
+        )
+
+        # Interpolate (1-frac) * f_low + frac * f_up
+        f = (1 - fracs) * fp[intidx] + fp[intidx + 1] * fracs
+
+        return f
+
+    @staticmethod
+    def triangular_interpolation(
+        x1: float,
+        y1: float,
+        h1: float,
+        x2: float,
+        y2: float,
+        h2: float,
+        x3: float,
+        y3: float,
+        h3: float,
+        x: float,
+        y: float,
+    ) -> float:
+        """
+        Performs triangular interpolation to calculate the parameter value
+        (water level) at a given point within a triangle.
+
+        Parameters
+        ----------
+        x1 : float
+            X-coordinate of the first input location.
+        y1 : float
+            Y-coordinate of the first input location.
+        h1 : float
+            Parameter value (water level) at the first input location.
+        x2 : float
+            X-coordinate of the second input location.
+        y2 : float
+            Y-coordinate of the second input location.
+        h2 : float
+            Parameter value (water level) at the second input location.
+        x3 : float
+            X-coordinate of the third input location.
+        y3 : float
+            Y-coordinate of the third input location.
+        h3 : float
+            Parameter value (water level) at the third input location.
+        x : float
+            X-coordinate of the point to interpolate.
+        y : float
+            Y-coordinate of the point to interpolate.
+
+        Returns
+        -------
+        float
+            The interpolated parameter value (water level) at the given point.
+        """
+        # Check if the input locations are invalid
+        if (
+            (x1 == x2 and y1 == y2)
+            or (x1 == x3 and y1 == y3)
+            or (x2 == x3 and y2 == y3)
+        ):
+            raise ValueError(
+                "[ERROR] Two input locations in triangle interpolation are exactly the same. This is not allowed."
+            )
+        if (x1 == x2 == x3) or (y1 == y2 == y3):
+            raise ValueError(
+                "[ERROR] The three input locations in triangle interpolation are collinear. This is not allowed."
+            )
+
+        # Check if the locations are on the same line
+        a_1 = (y1 - y2) / (x1 - x2)
+        b_1 = y1 - a_1 * x1
+        a_2 = (y3 - y2) / (x3 - x2)
+        b_2 = y3 - a_1 * x3
+        if (a_1 == a_2) and (b_1 == b_2):
+            raise ValueError(
+                "[ERROR] The three input locations in triangle interpolation are collinear. This is not allowed."
+            )
+
+        # Calculate auxiliary parameter a
+        a = x1 * (y2 - y3) - x2 * (y1 - y3) + x3 * (y1 - y2)
+
+        # Parameter a should not be equal to 0
+        if a == 0.0:
+            raise ValueError(
+                "[ERROR] In triangle interpolation, there is an auxiliary parameter (a) that should not be equal to 0, but it is currently set to 0."
+            )
+
+        # Calculate parameters B1, B2 en B3
+        b1 = h1 * (y2 - y3) - h2 * (y1 - y3) + h3 * (y1 - y2)
+        b2 = x1 * (h2 - h3) - x2 * (h1 - h3) + x3 * (h1 - h2)
+        b3 = (
+            x1 * (y2 * h3 - y3 * h2)
+            - x2 * (y1 * h3 - y3 * h1)
+            + x3 * (y1 * h2 - y2 * h1)
+        )
+
+        # Calculate the value at (x, y) using the triangular interpolation
+        triangular_interp = (b1 / a) * x + (b2 / a) * y + b3 / a
+        return triangular_interp
+
+
+class InterpStruct:
+    """
+    Interpolation helper class.
+
+    This class provides functionality for 1D interpolation of arrays along a
+    specified axis. It is designed to interpolate arrays using piecewise linear
+    interpolation based on provided data points.
+    """
+
+    def __init__(self, x: np.ndarray, xp: np.ndarray):
+        """
+        Initialize the InterpStruct object and calculate interpolation factors.
+
+        This method is used internally to calculate interpolation factors based
+        on given data points 'x' and 'xp'. It sets the 'xp', 'x', 'intidx', and
+        'fracs' attributes of the InterpStruct object.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input data points used for interpolation.
+        xp : np.ndarray
+            Known data points representing the interpolation axis.
+        """
+        self.xp = np.asarray(xp)
+        self.x = np.asarray(x)
+        self.intidx = np.minimum(
+            np.maximum(0, np.searchsorted(self.xp, self.x) - 1), len(self.xp) - 2
+        )
+        self.fracs = (self.x - self.xp[self.intidx]) / (
+            self.xp[self.intidx + 1] - self.xp[self.intidx]
+        )
+
+    def interp(
+        self,
+        fp: np.ndarray,
+        axis: int = 0,
+        extrapolate: bool = True,
+        left: bool = None,
+        right: bool = None,
+    ):
+        """
+        Interpolate a (multidimensional) array along the given axis using
+        piecewise linear interpolation.
+
+        Parameters
+        ----------
+        fp : np.ndarray
+            Array with values to interpolate.
+        axis : int, optional
+            Axis along which the interpolation is performed (default is 0).
+        extrapolate : bool, optional
+            If True, allow extrapolation of values outside the range of 'xp'.
+            If False, set the values outside the interpolation range to NaN
+            (default is True).
+        left : float or None, optional
+            Value to use for extrapolation on the left side. If None, the left
+            extrapolation will result in NaN (default is None).
+        right : float or None, optional:
+            Value to use for extrapolation on the right side. If None, the
+            right extrapolation will result in NaN (default is None).
+
+        Returns
+        -------
+        ndarray
+            Interpolated multidimensional array.
+
+        Raises
+        ------
+            ValueError: If the given axis is higher than the dimensions of the
+            'fp' array.
+        """
+        # Convert to array if needed
+        if isinstance(fp, list):
+            fp = np.asarray(fp)
+
+        # Check given axis and fp shape
+        if axis > fp.ndim - 1:
+            raise ValueError(
+                f"Given axis ({axis}) is higher than dimensions of fp array ({fp.ndim})."
+            )
+
+        # Create shape with all ones, except for the array which is used for
+        # interpolation
+        shape = [1] * fp.ndim
+        shape[axis] = len(self.fracs)
+
+        # Interpolate (1-frac) * f_low + frac * f_up
+        f = (1 - self.fracs.reshape(shape)) * np.take(
+            fp, self.intidx, axis=axis
+        ) + np.take(fp, self.intidx + 1, axis=axis) * self.fracs.reshape(shape)
+
+        # If 'extrapolate' is False, set values outside the interpolation range
+        # to NaN or the specified values
+        if not extrapolate:
+            if left is not None:
+                f[(self.x < self.xp[0])] = left
+            else:
+                f[(self.x < self.xp[0])] = np.nan
+            if right is not None:
+                f[(self.x > self.xp[-1])] = right
+            else:
+                f[(self.x > self.xp[-1])] = np.nan
+
+        return f
+
+    def interp_angle(
+        self, fp: np.ndarray, axis: int = 0, extrapolate: bool = True
+    ) -> np.ndarray:
+        """
+        Interpolate angles (in degrees) using piecewise linear interpolation.
+
+        This function performs interpolation of angles represented by 'fp'
+        using piecewise linear interpolation. The angles are given in degrees
+        and can be provided as a 1D or 2D array.
+
+        Parameters
+        ----------
+        fp : np.ndarray
+            Input angles (in degrees) to be interpolated.
+        axis : int, optional
+            The axis along which the interpolation is performed (default is 0).
+        extrapolate : bool, optional
+            If True, allow extrapolation of values outside the range of
+            'self.xp'. If False, set the angles outside the interpolation
+            range to NaN (default is True).
+
+        Returns
+        -------
+        np.ndarray
+            Interpolated angles in degrees.
+        """
+        # Convert angles from degrees to cosine and sine values and perform
+        # interpolation along the specified 'axis'
+        xint = self.interp(np.cos(np.radians(fp)), axis=axis)
+        yint = self.interp(np.sin(np.radians(fp)), axis=axis)
+
+        # Compute the interpolated angle in degrees using arctan2 and wrap it
+        # to the range [0, 360)
+        f = np.degrees(np.arctan2(yint, xint)) % 360
+
+        # If 'extrapolate' is False, set angles outside the interpolation range
+        # to NaN
+        if not extrapolate:
+            f[(self.x < self.xp[0]) | (self.x > self.xp[-1])] = np.nan
+
+        return f