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

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

@@ -0,0 +1,158 @@
+import numpy as np
+
+from .wave_shape import WaveShape
+from ....settings.settings import Settings
+from .....common.enum import WaterSystem, WaveShapeType
+from .....common.interpolate import Interpolate
+from .....io.file_hydranl import FileHydraNL
+
+
+class LakeLevel:
+    """
+    Class to describe the lake (water) level statistics.
+    """
+
+    def __init__(self, settings: Settings):
+        """
+        Constructor class for LakeLevel statistics.
+
+        Parameters
+        ----------
+        settings : Settings
+            The Settings object
+        """
+        # Read exceedance probability peak lake level
+        apeak, epapeak = FileHydraNL.read_file_2columns(settings.lake_level_probability)
+
+        # Adjust for lake level rise
+        apeak += settings.lake_level_rise
+
+        # Lowest lake level
+        a_min_piek = max(apeak[0] - settings.lake_level_rise, settings.a_min)
+
+        # Creeer rooster met meerpeilen voor de trapezia
+        self.apeak = np.r_[
+            np.arange(a_min_piek, settings.a_max, settings.a_step), settings.a_max
+        ]
+        self.napeak = len(self.apeak)
+
+        # Als de meerpeilen bekend zijn kunnen de trapezia worden geïnitialiseerd
+        # (Vul de vector met meerpeilen)
+        self.wave_shape = WaveShape(settings, type=WaveShapeType.LAKE_LEVEL)
+        self.wave_shape.initialise_wave_shapes(
+            self.apeak, climate_change=settings.lake_level_rise
+        )
+
+        # Creeer rooster met meerpeilen voor het opdelen van de golfvormen in blokken
+        # TODO self.invoergeg.m_min #= MLAAGST? Moet dit dan kol1.min() zijn?
+        # self.mblok = roosterblokken(self.invoergeg.m_min, self.mpiek)
+        self.ablok = self.apeak.copy()
+        self.nablok = len(self.ablok)
+
+        # Blaas de tabel met overschrijdingskansen voor het meerpeil op
+        # De interpolatie wordt logaritmische uitgevoerd.
+        self.epapeak = np.exp(
+            Interpolate.inextrp1d(x=self.apeak, xp=apeak, fp=np.log(epapeak))
+        )
+        self.epapeak[self.epapeak > 1] = 1.0
+
+        # IJssel-Vechtdelta and VZM related
+        if settings.watersystem in [
+            WaterSystem.IJSSEL_DELTA,
+            WaterSystem.VECHT_DELTA,
+            WaterSystem.VOLKERAK_ZOOMMEER,
+        ]:
+            # Lokale paramters
+            N = 376
+
+            # Geef verwachtingswaarde en standaarddeviatie van de normale verdeling in de getransformeerde ruimte een waarde
+            mu = 0.0
+            sigma = settings.sigma_aq  # invoergeg.sigma_mq(ig)
+
+            # Zet de gegevens voor de verfijnde interpolatietabel (de y-waarden, ofwel de K_sigma(s) uit vgl. 4.7 van [Geerse, 2003.129x]
+            # Bereken voor elke y-waarde de integraal 4.3 [Geerse, 2003]
+            f_y_k = np.linspace(-2 - 4 * sigma, 20 + 4 * sigma, N)
+
+            # Verfijnde tabel klaarzetten van de cumulatieve verdelingsfunctie onder transformatie van s naar y
+            # Zie ook vgl. 4.3 van [Geerse, 2003]
+
+            # Maak de vector met y-waarden:
+            # Bereken voor elke y-waarde de integraal 4.3 [Geerse, 2003]
+            f_y_sigma = self.wave_shape.cum_norm_s_naar_y(f_y_k, mu, sigma)
+
+            # 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
+
+            for i in range(N):
+                if f_y_sigma[i] > 0:
+                    D = i
+                    break
+
+            # Een ONDERschrijdingskans gelijk aan 0.0 mag worden meegenomen.
+            if D > 0:
+                D -= 1
+
+            self.k_apeak = Interpolate.inextrp1d(
+                x=1 - self.epapeak, xp=f_y_sigma[D:], fp=f_y_k[D:]
+            )
+
+        #  Bereken de momentane overschrijdingskansen van het meerpeil
+        self.mom_ovkans_a = self.wave_shape.instantaneous_exceedance_probability(
+            self.epapeak, self.ablok
+        )
+
+        # Transition
+        if (settings.transition_lake_wave_shape is not None) and (
+            settings.transition_lake_wave_shape != 0.0
+        ):
+            self.wave_shape.transition_wave(settings.transition_lake_wave_shape)
+
+        # Filter overschrijdingskansen die kleiner dan 0 of grote dan 1 zijn. Dit kan voorkomen door floating point precision
+        self.upablok = np.clip(1.0 - self.mom_ovkans_a, 0.0, 1.0)
+
+    def __len__(self):
+        """
+        Return the number of discharge discretisations.
+
+        Returns
+        -------
+        int
+            Number of discretisations
+        """
+        return self.nablok
+
+    def get_discretisation(self) -> np.ndarray:
+        """
+        Return the discharge discretisation.
+
+        Returns
+        -------
+        np.ndarray
+            1D array with discretisation
+        """
+        return self.ablok
+
+    def get_exceedance_probability(self) -> np.ndarray:
+        """
+        Return exceedance probility of the discharge
+
+        Returns
+        -------
+        np.ndarray
+            A 1D array with the discharge exceedance probability
+        """
+        return self.upablok
+
+    def get_wave_shape(self) -> WaveShape:
+        """
+        Return the wave form statistics object.
+
+        Returns
+        -------
+        WaveShape
+            The WaveShape statistics
+        """
+        return self.wave_shape

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

@@ -0,0 +1,358 @@
+import numpy as np
+
+from dataclasses import dataclass
+from scipy.stats import multivariate_normal, norm
+
+from ....settings.settings import Settings
+from .....io.database_hr import DatabaseHR
+
+
+class ModelUncertainty:
+    """
+    Model uncertainties class. Containing all model uncertainties for each closing situation.
+
+    Attributes
+    ----------
+    model_uncertainties : dict
+        A dictionary with
+    """
+
+    # Init attributes
+    model_uncertainties = {}
+    correlations = {}
+
+    def __init__(self, settings: Settings):
+        """
+        Read the model uncertainties from the database and add them to this class
+
+        Parameters
+        ----------
+        settings : Settings
+            The Settings object
+        """
+        # Save the discretisation step size
+        self.step_size = {
+            "h": settings.model_uncertainty_water_level_steps,
+            "hs": settings.model_uncertainty_wave_height_steps,
+            "tspec": settings.model_uncertainty_wave_period_steps,
+        }
+
+        # Obtain the model uncertainties and correlation between model uncertainties
+        with DatabaseHR(settings.database_path) as database:
+            mu = database.get_model_uncertainties(settings)
+            cu = database.get_correlation_uncertainties(settings)
+
+        # Iterate over the model uncertainties and add them to the class
+        for comb, uncertainty in mu.groupby(["k", "rvid"]):
+            self.model_uncertainties[comb] = DistributionUncertainty(
+                uncertainty.to_numpy()[0]
+            )
+
+        # Iterate over the correlation between model uncertainties and add them to the class
+        for comb, correlation in cu.groupby(["k", "rvid", "rvid2"]):
+            self.correlations[comb] = CorrelationUncertainty(correlation.to_numpy()[0])
+
+    def iterate_model_uncertainty_wave_conditions(
+        self, closing_situation: int = 1, wave_period: str = "tspec"
+    ):
+        """
+        Iterate over all model uncertainty combinations for the significant wave height and wave period
+
+        Parameters
+        ----------
+        closing_situation : int, optional
+            The closing situation id (default : 1)
+        wave_period : str, optional
+            Whether to iterate over peak period (tp) or spectral wave period (tspec) (default : 'tspec')
+
+        Returns
+        -------
+        iterator
+            (hs, t, probability of (hs, t))
+        """
+        # Check if tp or tspec
+        wave_period = wave_period.lower()
+        if wave_period not in ["tp", "tspec"]:
+            raise KeyError(f"[ERROR] Wave period '{wave_period}' unknown.")
+
+        # Distributions
+        mu_hs = self.get_model_uncertainty("hs", closing_situation)
+        mu_t = self.get_model_uncertainty(wave_period, closing_situation)
+
+        # Significant wave height
+        if mu_hs is not None:
+            hs, hsedges = mu_hs.discretise(self.step_size["hs"])
+            tmp = norm.cdf(hsedges)
+            p_hs = tmp[1:] - tmp[:-1]
+        else:
+            hs, p_hs = [1.0], np.array([1.0])
+
+        # Wave period
+        if mu_t is not None:
+            t, tedges = mu_t.discretise(self.step_size["tspec"])
+            tmp = norm.cdf(tedges)
+            p_t = tmp[1:] - tmp[:-1]
+        else:
+            t, p_t = [1.0], np.array([1.0])
+
+        # Multiply the probabilities (assuming independence)
+        combined_probability = p_hs[:, None] * p_t[None, :]
+
+        # Obtain the correlation between wave height and period (optional, otherwise None)
+        corr_hs_t = self.get_correlation("hs", wave_period)
+
+        # If rho is defined, apply correlation
+        if corr_hs_t is not None:
+            # Correlation can only be applied when both the wave height and period are defined
+            if (mu_hs is not None) and (mu_t is not None):
+                # Apply correlation
+                exc_probs = np.zeros((len(hsedges), len(tedges)))
+                for i, x in enumerate(hsedges):
+                    for j, y in enumerate(tedges):
+                        exc_probs[i, j] = multivariate_normal.cdf(
+                            [x, y],
+                            mean=(0, 0),
+                            cov=[[1, corr_hs_t.rho], [corr_hs_t.rho, 1]],
+                        )
+
+                # Take the difference in both directions
+                combined_probability = exc_probs[1:] - exc_probs[:-1]
+                combined_probability = (
+                    combined_probability[:, 1:] - combined_probability[:, :-1]
+                )
+
+            # Otherwise give a warning
+            else:
+                print(
+                    "[WARNING] Correlation between wave height and period defined. However can not be applied because no model uncertainty is defined for either the wave height, period or both."
+                )
+
+        # Check
+        assert abs(combined_probability.sum() - 1) < 1e-6
+
+        # Iterator
+        for i, fh in enumerate(hs):
+            for j, ft in enumerate(t):
+                yield fh, ft, combined_probability[i, j]
+
+    def get_model_uncertainty(self, result_variable: str, closing_situation: int = 1):
+        """
+        Return the model uncertainty object for a result variable and closing situation id
+
+        Parameters
+        ----------
+        result_variable : str
+            Result variable (e.g. h, hs)
+        closing_situation : int
+            Closing situation ID (default: 1)
+
+        Returns
+        -------
+        DistributionUncertainty or None
+            The DistributionUncertainty object if it exists, otherwise None
+        """
+        # To lower
+        rv = result_variable.lower()
+
+        # Try to return the model uncertainty, otherwise return None
+        return self.model_uncertainties.get((closing_situation, rv))
+
+    def get_correlation(
+        self, result_variable1: str, result_variable2: str, closing_situation: int = 1
+    ):
+        """
+        Return the correlation object between two result variables given a closing situation id
+
+        Parameters
+        ----------
+        result_variable1 : str
+            Result variable (e.g. h, hs)
+        result_variable2 : str
+            Result variable (e.g. h, hs)
+        closing_situation : int
+            Closing situation ID (default: 1)
+
+        Returns
+        -------
+        Correlation or None
+            The Correlation object if it exists, otherwise None
+        """
+        # To lower
+        rv1 = result_variable1.lower()
+        rv2 = result_variable2.lower()
+
+        # Check both orders [ccid, rvid1, rvid2]
+        return self.correlations.get(
+            (closing_situation, rv1, rv2),
+            self.correlations.get((closing_situation, rv2, rv1)),
+        )
+
+    def process_model_uncertainty(
+        self,
+        closing_situation: int,
+        result_variable: str,
+        levels: np.ndarray,
+        exceedance_probability: np.ndarray,
+        haxis: int,
+    ):
+        """
+        Verwerk modelonzekerheid in gegeven stochast. Afhankelijk van de stochast wordt de onzekerheid
+        opgeteld (additief) of vermenigvuldigd (multiplicatief).
+
+        Args:
+            stochast (str): Stochastnaam. h, hs, tp of tspec
+            niveaus (np.ndarray): Niveaus waarin de onzekerheden worden ingedeeld.
+            ovkansen (np.ndarray): Overschrijdingskansen van de stochast, met eventueel meerdere dimensies
+            die meegeïntegreerd
+            haxis (int): as waarop de te integreren stochast zit
+            sluitsituatie (str): Keringsituatie, in sommige gevallen is de onzekerheid hiervan afhankelijk
+
+        Returns:
+            np.ndarray: Overschrijdingskansen met geïntegreerde onzekerheid
+        """
+        # Obtain distribution
+        dis = self.get_model_uncertainty(result_variable, closing_situation)
+
+        # Is the model uncertainty defined?
+        if dis is None:
+            return exceedance_probability
+
+        # Additive (h) or Multiplicative (hs, tspec, tp)
+        if result_variable in ["h"]:
+            klassekansen = self.bepaal_klassekansen_additief(levels, dis.mu, dis.sigma)
+
+        elif result_variable in ["hs", "tp", "tspec"]:
+            klassekansen = self.bepaal_klassekansen_multiplicatief(
+                levels, dis.mu, dis.sigma
+            )
+
+        else:
+            raise KeyError(result_variable)
+
+        # Calculate the exceedance probability
+        exceedance_probability = np.tensordot(
+            klassekansen, exceedance_probability, axes=([0], [haxis])
+        )
+
+        return exceedance_probability
+
+    def bepaal_klassekansen_additief(self, niveaus, mu, sigma):
+        # Bepaal klassegrenzen en klassekansen
+        hgrens = np.concatenate(
+            [[-np.inf], (niveaus[1:] + niveaus[:-1]) / 2.0, [np.inf]]
+        )
+        klassekansen = []
+
+        # Bereken per niveau (waterstand) de kans dat de waterstand door onzekerheid in een andere klasse valt
+        for niveau in niveaus:
+            grenskansen = norm.cdf(x=hgrens - mu, loc=niveau, scale=sigma)
+            klassekansen.append(grenskansen[1:] - grenskansen[:-1])
+        klassekansen = np.array(klassekansen)
+
+        return klassekansen
+
+    def bepaal_klassekansen_multiplicatief(self, niveaus, mu, sigma):
+        # Bepaal klassegrenzen en klassekansen
+        hgrens = np.concatenate(
+            [[-np.inf], (niveaus[1:] + niveaus[:-1]) / 2.0, [np.inf]]
+        )
+        klassekansen = []
+
+        # Bereken per niveau (waterstand) de kans dat de waterstand door onzekerheid in een andere klasse valt
+        for niveau in niveaus:
+            grenskansen = norm.cdf(hgrens / niveau, loc=mu, scale=sigma)
+            klassekansen.append(grenskansen[1:] - grenskansen[:-1])
+        klassekansen = np.array(klassekansen)
+
+        return klassekansen
+
+
+class DistributionUncertainty:
+    """
+    Model uncertainty class for a closing situation.
+    """
+
+    def __init__(self, uncertainty: list):
+        """
+        Initialise the model uncertainty (Normal Distribution)
+        """
+        # Save information
+        self.k, self.rvid, self.mu, self.sigma = uncertainty
+        self.k = int(self.k)
+        self.mu = float(self.mu)
+        self.sigma = float(self.sigma)
+
+    def discretise(self, nsteps: int):
+        """
+        Discretise the model uncertainty
+
+        Parameters
+        ----------
+        nsteps : int
+            Number of steps
+
+        Returns
+        -------
+        probabilities : list
+            List of the probabilities for each bin
+        edges : list
+            List with the edges of each bin
+        """
+        # If nsteps is 1, there is no need to discretise
+        if nsteps == 1:
+            return self.mu, [self.mu - 100 * self.sigma, self.mu + 100 * self.sigma]
+
+        # Determine the residual probabilities
+        keuzerestkans = 0.05
+        restkans = keuzerestkans / (nsteps**1.5)
+        afstand = -norm.ppf(q=0.5 * restkans, loc=0.0, scale=1.0) * self.sigma
+        ondergrens = self.mu - afstand
+        bovengrens = self.mu + afstand
+
+        # Calculate the probability at the center of the bin
+        probabilities = (
+            ondergrens + np.arange(0.5, nsteps, 1) * (bovengrens - ondergrens) / nsteps
+        )
+
+        # Determine the edges of the bins
+        edges = (
+            np.concatenate(
+                [
+                    [self.mu - 100 * self.sigma],
+                    (probabilities[1:] + probabilities[:-1]) / 2,
+                    [self.mu + 100 * self.sigma],
+                ]
+            )
+            - self.mu
+        ) / self.sigma
+
+        # Return probabilities and edges
+        return probabilities, edges
+
+
+@dataclass
+class CorrelationUncertainty:
+    """
+    Class om de correlaties tussen uitvoervariabelen op te slaan.
+    Bijv. de correlatie tussen Hs en Tspec
+    """
+
+    def __init__(self, correlation: list):
+        """
+        Initialise the correlation between two result variables
+        """
+        # Save information
+        self.k, self.rvid, self.rvid2, self.rho = correlation
+        self.k = int(self.k)
+        self.rho = float(self.rho)
+
+        # Only allow correlation between Hs and Tp and Hs and Tspec
+        if [self.rvid, self.rvid2] not in [
+            ["hs", "tp"],
+            ["tp", "hs"],
+            ["hs", "tspec"],
+            ["tspec", "hs"],
+        ]:
+            raise ValueError(
+                f"Not Implemented: Correlation between ({self.rvid}) and ({self.rvid2})"
+            )

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

@@ -0,0 +1,53 @@
+import numpy as np
+
+from abc import ABC
+
+
+class SeaLevel(ABC):
+    """
+    Class to describe the sea (water) level statistics.
+    Sea level statistics are conditional on the wind direction.
+    """
+
+    def __init__(self):
+        """
+        Constructor class for the SeaLevel statistics.
+        """
+        self.nm = 0
+        self.m = None
+        self.epm = None
+
+    def __len__(self):
+        """
+        Return the number of sea level discretisations.
+
+        Returns
+        -------
+        int
+            Number of discretisations
+        """
+        return self.nm
+
+    def get_discretisation(self) -> np.ndarray:
+        """
+        Return the sea level discretisation.
+
+        Returns
+        -------
+        np.ndarray
+            1D array with discretisation
+        """
+        return self.m
+
+    def get_exceedance_probability(self) -> np.ndarray:
+        """
+        Return exceedance probility of the sea level, conditional on the wind
+        direction.
+
+        Returns
+        -------
+        np.ndarray
+            A 2D array with the sea level exceedance probability conditional on
+            the wind direction (r x m)
+        """
+        return self.epm

pydra_core/location/model/statistics/stochastics/sea_level/sea_level_lower_river.py

@@ -0,0 +1,93 @@
+import numpy as np
+
+from .sea_level import SeaLevel
+from .....settings.settings import Settings
+from ......common.interpolate import Interpolate
+from ......common.probability import ProbabilityFunctions
+from ......io.file_hydranl import FileHydraNL
+
+
+class SeaLevelLowerRiver(SeaLevel):
+    """
+    Class to describe the sea (water) level statistics.
+    Sea level statistics are conditional on the wind direction.
+    """
+
+    def __init__(self, settings: Settings):
+        """
+        Initialise the sea level statistics for Rhine Tidal, Meuse Tidal,
+        EuroPoort, Volkerak-Zoommeer and Hollandsche IJssel.
+
+        Parameters
+        ----------
+        settings : Settings
+            The Settings object
+        """
+        # Inherit
+        super().__init__()
+
+        # Read the exceedance probability of the sea level conditional to the wind direction
+        m, epm = FileHydraNL.read_file_ncolumns(settings.sea_level_probability)
+        m += settings.sea_level_rise
+        nr = epm.shape[1]
+
+        # Correct for the distance between Hoek van Holland and Maasmond
+        self.translation_m = 0.02 - settings.sea_level_rise
+
+        # Equidistant filling vector with seawater levels
+        self.m = ProbabilityFunctions.get_hnl_disc_array(
+            settings.m_min, settings.m_max, settings.m_step
+        )
+
+        # Alloceer matrices
+        self.nm = len(self.m)
+        self.epm = np.zeros([self.nm, nr])
+
+        # Interpolate the conditional exceedance probability of the sea level onto the given grid
+        for ir in range(nr):
+            iszero = epm[:, ir] == 0.0
+            if iszero.any():
+                zeroidx = np.where(iszero)[0][-1]
+
+                # Interpoleer of extrapoleer logaritmisch tot de 0
+                self.epm[:zeroidx, ir] = np.exp(
+                    Interpolate.inextrp1d(
+                        x=self.m[:zeroidx], xp=m[~iszero], fp=np.log(epm[~iszero, ir])
+                    )
+                )
+
+                # Interpoleer of extrapoleer lineair vanaf 0
+                self.epm[zeroidx:, ir] = np.maximum(
+                    0.0, Interpolate.inextrp1d(self.m[zeroidx:], m, epm[:, ir])
+                )
+
+            else:
+                self.epm[:, ir] = np.exp(
+                    Interpolate.inextrp1d(x=self.m, xp=m, fp=np.log(epm[:, ir]))
+                )
+
+        # Limit the upper limit of the excedaance probability to 1.0
+        self.epm = np.minimum(1.0, self.epm)
+
+        # Scaling of the conditional exceedance probability to the used time period
+        if (settings.block_duration != 12.0) and (settings.block_duration is not None):
+            self.epm = 1.0 - (1.0 - self.epm) ** (settings.block_duration / 12.0)
+
+        #  Allocate matrix
+        self.pm = np.zeros((self.nm, nr))
+
+        #  Berekenen kansdichtheid zeewaterstand gegeven de windrichting
+        for ir in range(nr):
+            self.pm[:, ir] = ProbabilityFunctions.probability_density(
+                self.m, self.epm[:, ir]
+            ).density
+
+        #  Inlezen parameters kansverdeling gezamenlijke kansdichtheid zeewaterstand, windsnelheid
+        #  en windrichting
+        _, self.pwinds = FileHydraNL.read_file_ncolumns(
+            settings.wind_sea_level_probability
+        )
+        self.pwinds = self.pwinds.T
+
+        #  Geef twee instellingen van het gegevensblok mee in de structure self
+        self.transitional_wind = settings.transitional_wind