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

pydra_core/location/model/statistics/stochastics/wind_speed.py

@@ -0,0 +1,196 @@
+import numpy as np
+
+from scipy.stats import norm
+
+from .discrete_probability import DiscreteProbability
+from .sigma_function import SigmaFunction
+from ....settings.settings import Settings
+from .....common.interpolate import Interpolate
+from .....io.file_hydranl import FileHydraNL
+
+
+class WindSpeed:
+    """
+    Class to describe the wind speed statistics.
+    Wind speed statistics are conditional on the wind direction.
+    """
+
+    def __init__(self, settings: Settings):
+        """
+        Constructor class for the WindSpeed statistics.
+
+        Parameters
+        ----------
+        settings : Settings
+            The Settings object
+        """
+        # Default None, only initialized when correcting with sigma function
+        self.k_u = None
+
+        # Read wind speed
+        self.__read_wind_speed(settings)
+
+        # Scale for block_duration
+        if (settings.block_duration != 12.0) and (settings.block_duration is not None):
+            self.epu = 1.0 - (1.0 - self.epu) ** (settings.block_duration / 12.0)
+        self.block_duration_wind = settings.block_duration
+
+    def __len__(self):
+        """
+        Return the number of wind speed discretisations
+
+        Returns
+        -------
+        int
+            Number of discretisations
+        """
+        return self.nu
+
+    def __read_wind_speed(self, settings: Settings) -> None:
+        """
+        Read and process the wind speed statistics
+
+        Parameters
+        ----------
+        settings : Settings
+            The Settings object
+        """
+        # Read the wind speed and exceedance probabilities
+        lu, eplu = FileHydraNL.read_file_ncolumns(settings.wind_speed_probability)
+
+        # If the u_max in the settings is larger than the maximum wind speed in the statistics
+        if settings.u_max > max(lu):
+            # Calculate the number of wind speeds to add
+            nuhoger = int(round(max(1.0, settings.u_max - max(lu))))
+
+            # Add the wind speeds with a step of 1
+            u = np.concatenate(
+                [lu, np.linspace(max(lu), settings.u_max, nuhoger + 1)[1:]]
+            )
+            self.epu = np.zeros((len(u), eplu.shape[1]))
+
+            # Add exceedance probabilities (extrapolate)
+            for i, col in enumerate(eplu.T):
+                # If the last value is 0 or less, add zeroes
+                if col[-1] <= 0.0:
+                    self.epu[len(lu) :, i] = 0.0
+
+                # Otherwise, extrapolate logarithmically
+                else:
+                    self.epu[:, i] = np.exp(
+                        Interpolate.inextrp1d(x=u, xp=lu, fp=np.log(col))
+                    )
+
+        # Otherwise, do nothing
+        else:
+            u = lu[:]
+            self.epu = eplu[:, :]
+
+        # If a stepsize for the windspeed is defined
+        if settings.u_step is not None:
+            # Create a new grid
+            ugrid = np.concatenate(
+                [np.arange(0, settings.u_max, settings.u_step), [settings.u_max]]
+            )
+
+            # Interpolate the exceedance probabilities for this grid
+            epu = []
+            for col in self.epu.T:
+                logep = col
+                logep[logep > 0.0] = np.log(logep[logep > 0.0])
+                epu.append(np.exp(Interpolate.inextrp1d(x=ugrid, xp=u, fp=logep)))
+
+            # Vervang overschrijdingskansen en u
+            self.epu = np.c_[epu].T
+            u = ugrid
+
+        # Add the results to the object
+        self.u = u
+        self.nu = len(u)
+
+    def correct_with_sigma_function(
+        self, sigma_function: SigmaFunction, wind_direction: DiscreteProbability
+    ) -> None:
+        """
+        Correct with statistics with sigma function.
+
+        Parameters
+        ----------
+        sigma_function : SigmaFunction
+            The SigmaFunction statistics object
+        """
+        # Init a matrix
+        self.k_u = np.ones((self.nu, len(wind_direction))) * -99.0
+
+        # Per windrichting
+        for ir in range(len(wind_direction)):
+            # Als er correlatie is (sigma > 0)
+            if sigma_function.correlation[ir]:
+                lim1 = -4 * max(sigma_function.sigma[:, ir])
+                lim2 = 20.0 + 4 * max(sigma_function.sigma[:, ir])
+                f_y_m = np.linspace(lim1, lim2, 351)
+                f_y_sigma = self.__wind_transformation(
+                    f_y_m,
+                    0.0,
+                    sigma_function.sigma_sea_level,
+                    sigma_function.sigma[:, ir],
+                )
+
+                # Kansverdeling schalen of de hoogste ONDERschrijdingskans gelijk stellen aan 1
+                if f_y_sigma[-1] > 1.0:
+                    f_y_sigma /= f_y_sigma[-1]
+                else:
+                    f_y_sigma[-1] = 1.0
+
+                ondkansu = 1.0 - self.epu[:, ir]
+                self.k_u[:, ir] = Interpolate.inextrp1d(
+                    x=ondkansu, xp=f_y_sigma, fp=f_y_m
+                )
+
+    def __wind_transformation(self, y, mu, transzee, sigmafunctie):
+        """
+        Transform the wind speed statistics for correlation with the sea level.
+        """
+        if min(sigmafunctie) <= 0.0:
+            raise ValueError()
+
+        stap = 0.05
+        x = np.arange(0, 20 + 0.1 * stap, stap)
+        sigma = Interpolate.inextrp1d(x=x, xp=transzee, fp=sigmafunctie)
+
+        if min(sigma) <= 0.0:
+            raise ValueError()
+
+        yn = (y[None, :] - x[:, None] - mu) / sigma[:, None]
+
+        dx = np.diff(np.r_[x[0], (x[1:] + x[:-1]) / 2.0, x[-1]])
+
+        f_y_sigma = (
+            np.exp(-x[:, None]) * norm.cdf(x=yn, loc=0.0, scale=1.0) * dx[:, None]
+        ).sum(0)
+
+        return f_y_sigma
+
+    def get_discretisation(self) -> np.ndarray:
+        """
+        Return the wind speed discretisation.
+
+        Returns
+        -------
+        np.ndarray
+            1D array with discretisation
+        """
+        return self.u
+
+    def get_exceedance_probability(self) -> np.ndarray:
+        """
+        Return exceedance probility of the wind speed, conditional on the wind
+        direction.
+
+        Returns
+        -------
+        np.ndarray
+            A 2D array with the wind speed exceedance probability conditional
+            on the wind direction (r x u)
+        """
+        return self.epu

pydra_core/location/model/statistics/water_systems/statistics_coast.py

@@ -0,0 +1,153 @@
+import numpy as np
+
+from scipy.stats import norm
+
+from ..statistics import Statistics
+from ..stochastics.discrete_probability import DiscreteProbability
+from ..stochastics.model_uncertainty import ModelUncertainty
+from ..stochastics.sea_level.sea_level_point import SeaLevelPoint
+from ..stochastics.sea_level.sea_level_triangular import SeaLevelTriangular
+from ..stochastics.sigma_function import SigmaFunction
+from ..stochastics.wind_speed import WindSpeed
+from ....settings.settings import Settings
+from .....common.interpolate import Interpolate
+from .....common.probability import ProbabilityFunctions
+
+
+class StatisticsCoast(Statistics):
+    """
+    Statistics class for the Coast
+    Water systems: Coast (North, Central, South), Waddensea (West, East) and Western scheldt
+    """
+
+    def __init__(self, settings: Settings):
+        """
+        Init the Statistics class
+
+        Parameters
+        ----------
+        settings : Settings
+            The Settings object
+        """
+        # Inherit initialisation method from parent
+        super().__init__(settings)
+
+        # Sea level (Most parts require triangular interpolation, some one point (Den Helder))
+        if settings.sea_level_probability is not None:
+            self.sea_level = SeaLevelPoint(settings)
+        else:
+            self.sea_level = SeaLevelTriangular(settings)
+
+        # Sigmafunctie
+        self.sigma_function = SigmaFunction(settings)
+
+        # Wind
+        self.wind_direction = DiscreteProbability(settings.wind_direction_probability)
+        self.wind_speed = WindSpeed(settings)
+        self.wind_speed.correct_with_sigma_function(
+            self.sigma_function, self.wind_direction
+        )
+
+        # Calculate the probability P(m, u, r)
+        self.__calculate_combined_probabilities()
+
+        # Model uncertainty
+        self.model_uncertainties = ModelUncertainty(settings)
+
+        # Discrete, slow, fast stochatics
+        # TODO: Replace with framework
+        self.stochastics_discrete = {
+            "r": self.wind_direction.get_discretisation(),
+            "k": [1],
+        }
+        self.stochastics_fast = {
+            "u": self.wind_speed.get_discretisation(),
+            "m": self.sea_level.get_discretisation(),
+        }
+        self.stochastics_slow = {}
+
+    def calculate_probability(
+        self, wind_direction: float, closing_situation: int = 1, given: list = []
+    ):
+        """
+        Calculate the probability of occurence for the discretisation given the wind direction.
+
+        Parameters
+        ----------
+        wind_direction : float
+            Wind direction
+        closing_situation : int
+            Closing situation, (irrelevant for Coast)
+        given : list
+            Given stochasts
+        """
+        # Probability of wind direction
+        ir = self.wind_direction.get_discretisation().tolist().index(wind_direction)
+        kanswr = 1.0 if "r" in given else self.wind_direction.get_probability()[ir]
+
+        # Probability of a sea level and wind speed given a wind direction
+        kans_um_r = self.p_mur[:, :, ir]
+
+        # If given, calculate the conditional probabilities
+        if "u" in given:
+            kans_um_r[:] = ProbabilityFunctions.conditional_probability(
+                kans_um_r, axis=0
+            )
+        if "m" in given:
+            kans_um_r[:] = ProbabilityFunctions.conditional_probability(
+                kans_um_r, axis=1
+            )
+
+        # Combine all probabilities
+        probability = kans_um_r[:, :] * kanswr
+
+        # Return probability
+        return probability
+
+    def __calculate_combined_probabilities(self):
+        # Statistics
+        m = self.sea_level
+        s = self.sigma_function
+        r = self.wind_direction
+        u = self.wind_speed
+
+        # Initialize an empty matrix
+        self.p_mur = np.zeros((len(u), len(m), len(r)))
+
+        # Per wind direction
+        for ir in range(len(r)):
+            # Calculate the probability density of the sea level given the wind direction
+            pd_m = ProbabilityFunctions.probability_density(
+                m.get_discretisation(), m.get_exceedance_probability()[:, ir]
+            )
+
+            # If there is correlation (sigma > 0)
+            if s.correlation[ir]:
+                # Calculate sigma
+                sigma = Interpolate.inextrp1d(
+                    x=m.get_discretisation(), xp=s.sigma_sea_level, fp=s.sigma[:, ir]
+                )
+                if np.min(sigma) < 0.0:
+                    raise ValueError()
+
+                # Exceedance probability of the wind speed given the sea water level epm_r[Nwind, Nswl]
+                snorm = (u.k_u[:, ir][:, None] - m.epm_exp[:, ir][None, :]) / sigma[
+                    None, :
+                ]
+                epm_r = 1 - norm.cdf(snorm)
+
+                # Per sea level
+                for im in range(len(m)):
+                    pd_u = ProbabilityFunctions.probability_density(
+                        u.get_discretisation(), epm_r[:, im]
+                    )
+                    self.p_mur[:, im, ir] = pd_u.probability * pd_m.probability[im]
+
+            # If there is no correlation (sigma <= 0)
+            else:
+                pd_u = ProbabilityFunctions.probability_density(
+                    u.get_discretisation(), u.get_exceedance_probability()[:, ir]
+                )
+                self.p_mur[:, :, ir] = (
+                    pd_u.probability[:, None] * pd_m.probability[None, :]
+                )

pydra_core/location/model/statistics/water_systems/statistics_eastern_scheldt.py

@@ -0,0 +1,177 @@
+import numpy as np
+
+from scipy.stats import norm
+
+from ..statistics import Statistics
+from ..stochastics.barrier.barrier_easternscheldt import BarrierEasternScheldt
+from ..stochastics.discrete_probability import DiscreteProbability
+from ..stochastics.model_uncertainty import ModelUncertainty
+from ..stochastics.sea_level.sea_level_point import SeaLevelPoint
+from ..stochastics.sigma_function import SigmaFunction
+from ..stochastics.wind_speed import WindSpeed
+from ....settings.settings import Settings
+from .....common.interpolate import Interpolate
+from .....common.probability import ProbabilityFunctions
+
+
+class StatisticsEasternScheldt(Statistics):
+    """
+    Statistics class for the Eastern Scheldt
+    Water systems: Eastern Scheldt
+    """
+
+    def __init__(self, settings: Settings):
+        """
+        Init the Statistics class for the Eastern Scheldt
+
+        Parameters
+        ----------
+        settings : Settings
+            The Settings object
+        """
+        # Inherit initialisation method from parent
+        super().__init__(settings)
+
+        # Sea level
+        self.sea_level = SeaLevelPoint(settings)
+
+        # Storm surge duration
+        self.storm_surge_duration = DiscreteProbability(
+            settings.storm_surge_duration_probability
+        )
+
+        # Fase differences (between surge and tide)
+        self.phase_surge_tide = DiscreteProbability(
+            settings.phase_surge_tide_probability
+        )
+
+        # Sigma function
+        self.sigma_function = SigmaFunction(settings)
+
+        # Wind
+        self.wind_direction = DiscreteProbability(settings.wind_direction_probability)
+        self.wind_speed = WindSpeed(settings)
+        self.wind_speed.correct_with_sigma_function(
+            self.sigma_function, self.wind_direction
+        )
+
+        # Calculate P(u, m, r)
+        self.__calculate_combined_probabilities()
+
+        # Eastern Scheldt Barrier
+        self.barrier = BarrierEasternScheldt(
+            settings, self.wind_direction, self.wind_speed, self.sea_level
+        )
+
+        # Model uncertainty
+        self.model_uncertainties = ModelUncertainty(settings)
+
+        # Discrete, slow, fast stochatics
+        self.stochastics_discrete = {
+            "r": self.wind_direction.get_discretisation(),
+            "k": [1, 2, 3, 4, 5, 6, 7, 8],
+        }
+        self.stochastics_fast = {
+            "u": self.wind_speed.get_discretisation(),
+            "m": self.sea_level.get_discretisation(),
+            "d": self.storm_surge_duration.get_discretisation(),
+            "p": self.phase_surge_tide.get_discretisation(),
+        }
+        self.stochastics_slow = {}
+
+    def calculate_probability(
+        self, wind_direction: float, closing_situation: int = 1, given: list = []
+    ):
+        """
+        Calculate the probability of occurence for the discretisation given the wind direction.
+
+        Parameters
+        ----------
+        wind_direction : float
+            Wind direction
+        closing_situation : int
+            Closing situation, (irrelevant for Coast)
+        given : list
+            Given stochasts
+        """
+        # Probability of wind direction
+        ir = self.wind_direction.get_discretisation().tolist().index(wind_direction)
+        pwr = 1.0 if "r" in given else self.wind_direction.get_probability()[ir]
+
+        # Probability of closing given a wind direction
+        p_k = (
+            1.0
+            if "k" in given
+            else self.barrier.calculate_closing_probability(
+                wind_direction, closing_situation
+            )
+        )
+
+        # Probability of a sea level and wind speed given a wind direction
+        p_um_r = self.p_mur[:, :, ir]
+
+        # If given, calculate the conditional probabilities
+        if "u" in given:
+            p_um_r[:] = ProbabilityFunctions.conditional_probability(p_um_r, axis=0)
+        if "m" in given:
+            p_um_r[:] = ProbabilityFunctions.conditional_probability(p_um_r, axis=1)
+
+        # Combine all probabilities
+        probability = (
+            p_um_r[:, :, None, None]
+            * self.storm_surge_duration.get_probability()[None, None, :, None]
+            * self.phase_surge_tide.get_probability()[None, None, None, :]
+            * p_k
+            * pwr
+        )
+
+        # Return probability
+        return probability
+
+    def __calculate_combined_probabilities(self):
+        # Statistics
+        m = self.sea_level
+        s = self.sigma_function
+        r = self.wind_direction
+        u = self.wind_speed
+
+        # Initialize an empty matrix
+        self.p_mur = np.zeros((len(u), len(m), len(r)))
+
+        # Per wind direction
+        for ir in range(len(r)):
+            # Calculate the probability density of the sea level given the wind direction
+            pd_m = ProbabilityFunctions.probability_density(
+                m.get_discretisation(), m.get_exceedance_probability()[:, ir]
+            )
+
+            # If there is correlation (sigma > 0)
+            if s.correlation[ir]:
+                # Calculate sigma
+                sigma = Interpolate.inextrp1d(
+                    x=m.get_discretisation(), xp=s.sigma_sea_level, fp=s.sigma[:, ir]
+                )
+                if np.min(sigma) < 0.0:
+                    raise ValueError()
+
+                # Exceedance probability of the wind speed given the sea water level epm_r[Nwind, Nswl]
+                snorm = (
+                    self.wind_speed.k_u[:, ir][:, None] - m.epm_exp[:, ir][None, :]
+                ) / sigma[None, :]
+                ovkansen = 1 - norm.cdf(snorm)
+
+                # Per sea level
+                for im in range(len(m)):
+                    pd_u = ProbabilityFunctions.probability_density(
+                        u.get_discretisation(), ovkansen[:, im]
+                    )
+                    self.p_mur[:, im, ir] = pd_u.probability * pd_m.probability[im]
+
+            # If there is no correlation (sigma <= 0)
+            else:
+                pd_u = ProbabilityFunctions.probability_density(
+                    u.get_discretisation(), u.get_exceedance_probability()[:, ir]
+                )
+                self.p_mur[:, :, ir] = (
+                    pd_m.probability[None, :] * pd_u.probability[:, None]
+                )