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

pydra_core/common/probability.py

@@ -0,0 +1,293 @@
+import numpy as np
+
+from collections import namedtuple
+
+pdstruct = namedtuple("pdstruct", ["delta", "probability", "density", "edges"])
+
+
+class ProbabilityFunctions:
+    """
+    A class with common functions used within statistics.
+    """
+
+    @staticmethod
+    def probability_density(
+        values: np.ndarray,
+        exceedance_probability: np.ndarray,
+        bounded: bool = True,
+        check: bool = True,
+        axis: int = None,
+    ) -> pdstruct:
+        """
+        Function to convert the exceedance probability into a probability
+        density function.
+
+        Parameters
+        ----------
+        values : np.ndarray
+            Values, for example the wind speed discretisation
+        exceedance_probability : np.ndarray
+            Exceedance probability of the values
+        bounded : bool, optional
+            If bounded, add the first and last element based on the min and max
+            in the exceedance probability. Otherwise between 1.0 and 0.0
+            (default : True)
+        check : bool, optional
+            Check whether the values and exceedance probabilities are
+            monotonously increasing (default : True)
+        axis : int, optional
+            Axis (default : None)
+
+        Raises
+        ------
+        ValueError
+            If the values or exceedance probabilities are not monotonously
+            increasing
+
+        Returns
+        -------
+        pdstruct
+            Probability density structure
+        """
+        # For multiple dimensions, use the _nd function
+        if exceedance_probability.ndim > 1:
+            return ProbabilityFunctions.probability_density_nd(
+                values, exceedance_probability, bounded, axis=axis
+            )
+
+        # Check whether the values and exceedance probabilities are monotonously increasing
+        if check:
+            for arr, tag in zip(
+                [values, exceedance_probability], ["Values", "Exceedance probabilities"]
+            ):
+                diff = arr[1:] - arr[:-1]
+                if not (all(diff >= 0) or all(diff <= 0)):
+                    raise ValueError(
+                        tag + "are not monotonously increasing or decreasing.",
+                        arr,
+                        diff,
+                    )
+
+        # Determine the exceedance probability bins
+        bins_edges = (exceedance_probability[1:] + exceedance_probability[:-1]) / 2.0
+
+        # If bounded, add the first and last element based on the min and max in the exceedance probability
+        if bounded:
+            bins_edges = np.concatenate(
+                [[exceedance_probability[0]], bins_edges, [exceedance_probability[-1]]]
+            )
+
+        # Else, determine the bins between the 0 and 1
+        else:
+            if exceedance_probability[0] < exceedance_probability[-1]:
+                bins_edges = np.concatenate([[0.0], bins_edges, [1.0]])
+            else:
+                bins_edges = np.concatenate([[1.0], bins_edges, [0.0]])
+
+        # The difference between the bin_edges are the bins_probabilities
+        bins_probability = np.absolute(bins_edges[1:] - bins_edges[:-1])
+
+        # Determine the delta of the values
+        bins_values = np.concatenate(
+            [[values[0]], (values[1:] + values[:-1]) / 2.0, [values[-1]]]
+        )
+        bins_deltas = np.absolute(np.diff(bins_values))
+
+        # Probability density is the bins_probability divided by the delta
+        probability_density = np.absolute(bins_probability / bins_deltas)
+
+        # Return as a structure
+        return pdstruct(bins_deltas, bins_probability, probability_density, bins_edges)
+
+    @staticmethod
+    def probability_density_nd(
+        values: np.ndarray,
+        exceedance_probability: np.ndarray,
+        bounded: bool = True,
+        axis: int = None,
+    ) -> pdstruct:
+        """
+        Convert the exceedance probability into a probability density function
+        for multidimensional arrays.
+
+        This function converts the exceedance probabilities
+        (exceedance_probability) into a probability density function (PDF) for
+        multidimensional arrays represented by 'values' and
+        'exceedance_probability'.
+
+        Parameters
+        ----------
+        values : np.ndarray
+            Values, e.g., wind speed discretization, for which the PDF is
+            calculated.
+        exceedance_probability : np.ndarray
+            Exceedance probability of the values.
+        bounded (bool):
+            If True, add the first and last element based on the min and max in
+            the exceedance probability. Otherwise, create the PDF between 1.0
+            and 0.0.
+        axis : int, optional
+            The axis along which the PDF is calculated. By default, axis 0 is
+            used.
+
+        Returns
+        -------
+        pdstruct
+            Probability density structure containing the calculated PDF.
+        """
+        # If bounded, add the first and last element based on the min and max
+        # in the exceedance probability
+        if bounded:
+            bins_edges = np.concatenate(
+                [
+                    [exceedance_probability[0]],
+                    (exceedance_probability[1:] + exceedance_probability[:-1]) / 2.0,
+                    [exceedance_probability[-1]],
+                ]
+            )
+
+        # If not
+        else:
+            bins_edges = np.pad(
+                (exceedance_probability[1:] + exceedance_probability[:-1]) / 2,
+                pad_width=(1, 1),
+                mode="constant",
+                constant_values=(0, 1)
+                if (exceedance_probability[0] < exceedance_probability[-1]).all()
+                else (1, 0),
+            )
+
+        # The difference between the bin_edges are the bins_probabilities
+        bins_probability = np.absolute(bins_edges[1:, ...] - bins_edges[:-1, ...])
+
+        # Edges between consecutive values, the difference gives the bin_deltas
+        bins_deltas = np.absolute(
+            np.diff(
+                np.concatenate(
+                    [[values[0]], (values[1:] + values[:-1]) / 2.0, [values[-1]]]
+                )
+            )
+        )
+
+        # Probability density is the bins_probability divided by the delta
+        shp = [1] * bins_probability.ndim
+        if axis is None:
+            axis = 0
+        shp[axis] = -1
+        probability_density = np.absolute(
+            bins_probability / bins_deltas.reshape(tuple(shp))
+        )
+
+        # Return as a structure
+        return pdstruct(bins_deltas, bins_probability, probability_density, bins_edges)
+
+    @staticmethod
+    def get_hnl_disc_array(vmin: float, vmax: float, step: float) -> np.ndarray:
+        """
+        Get a discretized array of values between vmin and vmax with the given
+        step size.
+
+        This function generates a discretized array of values in the specified
+        range [vmin, vmax] with a given step size. The array includes the vmin
+        and vmax values and is uniformly spaced with steps of the specified
+        size.
+
+        Parameters
+        ----------
+        vmin : float
+            Minimum value of the range.
+        vmax : float
+            Maximum value of the range.
+        step : float
+            Step size between values.
+
+        Returns
+        -------
+        np.array
+            Discretized array of values.
+        """
+        # Calculate the number of steps between vmin and vmax and create the
+        # discretized array
+        n = round((vmax - vmin) / step)
+        levels = np.arange(vmin, vmin + (n + 0.1) * step, step)
+
+        # Ensure that the last element of the array is exactly equal to vmax
+        levels[-1] = vmax
+        return levels
+
+    @staticmethod
+    def conditional_probability(probability: np.ndarray, axis: int) -> np.ndarray:
+        """
+        Calculate the conditional probability along an axis, taking into account
+        dividing by zero.
+
+        This function calculates the conditional probability along the
+        specified 'axis' of the input 'probability' array. The conditional
+        probability is the probability of an event occurring given that another
+        event has occurred. If the denominator is zero along the specified
+        'axis', the result is set to zero to avoid division by zero errors.
+
+        Parameters
+        ----------
+        probability : np.ndarray
+            Array with probabilities
+        axis : int
+            Axis for which the conditional probability has to be calculated
+
+        Returns
+        -------
+        np.ndarray
+            Conditional probability
+        """
+        # Calculate the denominator as the sum of probabilities along the
+        # specified 'axis'
+        denominator = np.sum(probability, axis=axis)
+
+        # Create a shape with all ones, except for the axis that will be used
+        # for broadcasting
+        shape = list(denominator.shape)
+        shape.insert(axis, -1)
+
+        # Calculate the conditional probability using element-wise division,
+        # handling division by zero
+        cond = np.divide(
+            probability,
+            denominator.reshape(shape),
+            out=np.zeros_like(probability),
+            where=(denominator != 0).reshape(shape),
+        )
+
+        return cond
+
+    @staticmethod
+    def calculate_boundaries(levels: np.ndarray):
+        """
+        Calculate the boundaries for the input array.
+
+        This function calculates the boundaries between adjacent elements in
+        the input 'arr' array. The boundaries are computed as the midpoints
+        between consecutive elements, with additional values added at the start
+        and end based on the step differences.
+
+        Parameters
+        ----------
+        levels : np.ndarray
+            Input array for which boundaries are to be calculated.
+
+        Returns
+        -------
+        ndarray
+            Array containing the calculated boundaries.
+        """
+        # Calculate the step differences between consecutive elements
+        lower_step = levels[2] - levels[1]
+        upper_step = levels[-1] - levels[-2]
+
+        # Calculate midpoints between consecutive elements
+        mid = (levels[1:] + levels[:-1]) / 2
+
+        # Calculate the boundaries array by concatenating the midpoints with
+        # additional boundary values
+        bounds = np.concatenate([[mid[0] - lower_step], mid, [mid[-1] + upper_step]])
+
+        return bounds

pydra_core/core/calculation.py

@@ -0,0 +1,51 @@
+from abc import ABC, abstractmethod
+from typing import Union
+
+from ..hrdatabase.hrdatabase import HRDatabase
+from ..location.location import Location
+
+
+class Calculation(ABC):
+    """
+    Base class for calculation modules
+    """
+
+    @abstractmethod
+    def __init__(self):
+        """
+        Init class, differs per calculation
+        """
+        pass
+
+    def calculate(self, input: Union[Location, HRDatabase]):
+        """
+        Execute a calculation
+
+        Parameters
+        ----------
+        input : Union[Location, HRDatabase]
+            The input
+        """
+        # Depending on the type of input, call CalculateLocation
+        if isinstance(input, Location):
+            return self.calculate_location(input)
+
+        elif isinstance(input, HRDatabase):
+            return {
+                loc: self.calculate_location(input.get_location(loc)) for loc in input
+            }
+
+        else:
+            raise NotImplementedError("[ERROR] Input type not implemented")
+
+    @abstractmethod
+    def calculate_location(self, location: Location):
+        """
+        Executes a calculation for a location
+
+        Parameter
+        ---------
+        location : Location
+            The Location object
+        """
+        pass

pydra_core/core/datamodels/frequency_line.py

@@ -0,0 +1,60 @@
+import numpy as np
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from ...common.interpolate import Interpolate
+
+
+@dataclass
+class FrequencyLine:
+    """
+    Represents a frequency line with associated levels and exceedance frequencies.
+
+    Parameters
+    ----------
+    level : np.ndarray
+        An array of levels.
+    exceedance_frequency : np.ndarray
+        An array of corresponding exceedance frequencies.
+    """
+
+    # Init variables
+    level: np.ndarray
+    exceedance_frequency: np.ndarray
+
+    def interpolate_exceedance_probability(self, exceedance_probability: np.ndarray):
+        exceedance_probability = np.atleast_1d(exceedance_probability)
+        order_x = np.argsort(exceedance_probability)
+        order_xp = np.argsort(self.exceedance_frequency)
+        f = Interpolate.inextrp1d(
+            x=np.log(exceedance_probability)[order_x],
+            xp=np.log(self.exceedance_frequency)[order_xp],
+            fp=self.level[order_xp],
+        )
+        return f[np.argsort(order_x)]
+
+    def interpolate_level(self, level: np.ndarray):
+        return np.exp(
+            Interpolate.inextrp1d(
+                x=level, xp=self.level, fp=np.log(self.exceedance_frequency)
+            )
+        )
+
+    def to_file(self, path: Path, overwrite=False):
+        if not overwrite and path.exists():
+            raise OSError(
+                f'Path "{path}" already exists. Choose overwrite=True or give another path.'
+            )
+
+        with path.open("w") as f:
+            f.write(f"{len(self.level):5d}\n")
+            for niveau, ovfreq in zip(self.level, self.exceedance_frequency):
+                f.write(f"{niveau:11.6f} {ovfreq:14.7e}\n")
+
+    def drop_zeros(self):
+        idx = self.exceedance_frequency == 0.0
+        if idx.all():
+            raise ValueError("All exceedance frequencies are 0.")
+        self.exceedance_frequency = self.exceedance_frequency[~idx]
+        self.level = self.level[~idx]

pydra_core/core/exceedance_frequency_line.py

@@ -0,0 +1,224 @@
+import numpy as np
+
+from copy import deepcopy
+from scipy.stats import norm
+
+from .calculation import Calculation
+from .datamodels.frequency_line import FrequencyLine
+from ..location.location import Location
+
+
+class ExceedanceFrequencyLine(Calculation):
+    """
+    Calculate a frequency line for a result variable (e.g. h (waterlevel), hs (significant wave height)) for a location
+    """
+
+    def __init__(
+        self,
+        result_variable: str,
+        model_uncertainty: bool = True,
+        levels: list = None,
+        step_size: float = 0.1,
+    ):
+        """
+        The __init__ method initializes an instance of the ExceedanceFrequencyLine class. It takes in several parameters to configure the calculation of the frequency line.
+
+        Parameters
+        ----------
+        result_variable: str
+            The result variable for which the frequency line will be calculated.
+        model_uncertainty: bool
+            Enable or disable the use of model uncertainties when calculating the frequency line. Default is True.
+        levels: list (optional):
+            The levels at which the exceedance probability has to be calculated. If not specified, the levels will be chosen between the 1st and 99th percentile of the values in the HRDatabase.
+        step_size: float (optional)
+            The step size of the frequency line. Default is 0.1.
+        """
+        # Inherit
+        super().__init__()
+
+        # Save settings
+        self.set_result_variable(result_variable.lower())
+        self.use_model_uncertainty(model_uncertainty)
+        self.set_levels(levels)
+        self.set_step_size(step_size)
+        self.model_uncertainty_steps = None
+
+    def calculate_location(self, location: Location) -> FrequencyLine:
+        """
+        Calculate the exceedance probability of the variable at a given set of levels.
+        If the levels are not specified, they will be chosen at the 1st and 99th percentile of all values in the database.
+
+        Parameter
+        ---------
+        location : Location
+            The Location object
+
+        Returns
+        -------
+        FrequencyLine
+            Frequency line of the result variable
+        """
+        # Copy the levels
+        levels = self.levels
+
+        # Obtain location object
+        model = location.get_model()
+        loading = model.get_loading()
+        monz = model.get_statistics().get_model_uncertainties()
+
+        # Check if the levels are defined, if not, define it between the 1st and 99th percentile
+        if levels is None:
+            lower, upper = loading.get_quantile_range(
+                self.result_variable, 0.01, 0.99, 3
+            )
+            levels = np.arange(lower, upper + 0.5 * self.step_size, self.step_size)
+
+        # Model uncertainty
+        if self.model_uncertainty:
+            # Model uncertainty steps (if None use default)
+            if self.model_uncertainty_steps is None:
+                self.model_uncertainty_steps = monz.step_size[self.result_variable]
+
+            # Discretise
+            _, edges = monz.model_uncertainties[1, self.result_variable].discretise(
+                self.model_uncertainty_steps
+            )
+            p = np.diff(norm.cdf(edges))
+
+        # If not
+        else:
+            self.model_uncertainty_steps = 1
+            p = [1.0]
+
+        # Discretise
+        exp = 0
+        for _ip, _p in enumerate(p):
+            # Deepcopy
+            _model = deepcopy(model)
+            _loading = _model.get_loading()
+
+            # Adjust loading models
+            if self.model_uncertainty:
+                for deelmodel, result in _loading.model.items():
+                    _unc = monz.model_uncertainties[deelmodel[1], self.result_variable]
+                    _disc, _ = _unc.discretise(self.model_uncertainty_steps)
+                    _data = getattr(result, self.result_variable)
+                    _data = (
+                        _data + _disc[_ip]
+                        if self.result_variable == "h"
+                        else _data * _disc[_ip]
+                    )
+                    setattr(result, self.result_variable, _data)
+
+            # Repair
+            _loading.repair_loadingmodels(self.result_variable)
+
+            # Splits uit naar trage stochasten en windrichting
+            p_h_slow = _model.calculate_probability_loading(
+                result_variable=self.result_variable,
+                levels=levels,
+                model_uncertainty=False,
+                split_input_variables=list(_model.statistics.stochastics_slow.keys()),
+                given=list(_model.statistics.stochastics_slow.keys()),
+            )
+
+            # Reken kansen om naar overschrijdingskansen door over de eerste te sommeren
+            ep_h_slow = np.cumsum(p_h_slow[::-1], axis=0)[-2::-1]
+
+            # Process slow stochastics (they are always at the last axes of the matrix)
+            if len(list(_model.statistics.stochastics_slow.keys())) > 0:
+                p_trapezoidal = _model.process_slow_stochastics(ep_h_slow)
+                exceedance_probability = (
+                    p_trapezoidal * location.get_settings().periods_base_duration
+                )
+
+            # Zo niet, geef de overschrijdingskansen direct terug
+            else:
+                exceedance_probability = (
+                    ep_h_slow * location.settings.periods_block_duration
+                )
+
+            # TODO: Check if this is correct?
+            # Save
+            if _ip:
+                exp = exp + exceedance_probability * _p
+            else:
+                exp = exceedance_probability * _p
+
+            # exp = (
+            #     exp + exceedance_probability * _p
+            #     if _ip
+            #     else exceedance_probability * _p
+            # )
+
+        # Return the frequency line
+        return FrequencyLine(levels, exp)
+
+    def set_result_variable(self, result_variable: str):
+        """
+        Change the result variable for which the frequency line will be calculated.
+
+        Parameters
+        ----------
+        result_variable : str
+            The result variable for which the frequency line will be calculated
+        """
+        # Raise an error when assigning the wave direction (dir)
+        if result_variable == "dir":
+            raise ValueError(
+                "[ERROR] Cannot calculate a frequency line for the wave direction (dir)."
+            )
+
+        # Save result variable
+        self.result_variable = result_variable
+
+    def set_levels(self, levels: list = None):
+        """
+        Change the levels.
+        If levels is not defined, the frequency line is calculated based upon the 1st and 99th percentile.
+
+        Parameters
+        ----------
+        levels : list, optional
+            The levels at which the exceedance probability has to be calculated
+        """
+        self.levels = levels
+
+    def set_step_size(self, step_size: float):
+        """
+        Change the step size of the frequency line.
+
+        Parameters
+        ----------
+        step_size : float
+            The step size of the frequency line
+        """
+        # Cannot be smaller or equal to 0
+        if step_size <= 0:
+            raise ValueError("[ERROR] Step size should be larger than 0.")
+
+        # Save step size
+        self.step_size = step_size
+
+    def use_model_uncertainty(self, model_uncertainty: bool):
+        """
+        Use model uncertainty when calculating a frequency line.
+
+        Parameters
+        ----------
+        model_uncertainty : bool
+            Enable or disable the use of model uncertainties
+        """
+        self.model_uncertainty = model_uncertainty
+
+    def set_model_uncertainty_steps(self, model_uncertainty_steps: int):
+        """
+        Set the number of model uncertainty steps
+
+        Parameters
+        ----------
+        model_uncertainty_steps : int
+            Number of model uncertainty steps
+        """
+        self.model_uncertainty_steps = model_uncertainty_steps