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

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

@@ -0,0 +1,229 @@
+import numpy as np
+
+from ..statistics import Statistics
+from ..stochastics.barrier.barrier_ramspol import BarrierRamspol
+from ..stochastics.discrete_probability import DiscreteProbability
+from ..stochastics.discharge import Discharge
+from ..stochastics.lake_level import LakeLevel
+from ..stochastics.model_uncertainty import ModelUncertainty
+from ..stochastics.wind_speed import WindSpeed
+from ....settings.settings import Settings
+from .....common.probability import ProbabilityFunctions
+
+
+class StatisticsIJsselVechtdelta(Statistics):
+    """
+    Statistics class for the IJssel-Vechtdelta
+    Water systems: IJssel Delta, Vecht Delta
+    """
+
+    def __init__(self, settings: Settings):
+        """
+        Init the Statistics class
+
+        Parameters
+        ----------
+        settings : Settings
+            The Settings object
+        """
+        # Inherit initialisation method from parent
+        super().__init__(settings)
+
+        # Wind
+        self.wind_direction = DiscreteProbability(settings.wind_direction_probability)
+        self.wind_speed = WindSpeed(settings)
+
+        # Lake level
+        self.lake_level = LakeLevel(settings)
+
+        # Discharge
+        self.discharge = Discharge(settings)
+
+        # Combined probability(density) of lake level and discharge
+        self.density_aq_peak, self.density_aq, self.ovduration_aq = (
+            self.__prob_combined()
+        )
+
+        # Ramspol
+        self.barrier = BarrierRamspol(settings, self.wind_direction)
+
+        # Model uncertainty
+        self.model_uncertainties = ModelUncertainty(settings)
+
+        # Discrete, slow, fast stochatics
+        self.stochastics_discrete = {
+            "r": self.wind_direction.get_discretisation(),
+            "k": self.barrier.k,
+        }
+        self.stochastics_fast = {"u": self.wind_speed.get_discretisation()}
+        self.stochastics_slow = {
+            "a": self.lake_level.get_discretisation(),
+            "q": self.discharge.get_discretisation(),
+        }
+
+    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
+        ----------
+        direction : float
+            Wind direction
+        closing_situation : int
+            Closing situation, (irrelevant for Coast)
+        given : list
+            Given stochasts
+        """
+        # Probility wind speed
+        ir = self.wind_direction.get_discretisation().tolist().index(wind_direction)
+        kanswind = ProbabilityFunctions.probability_density(
+            self.wind_speed.get_discretisation(),
+            self.wind_speed.get_exceedance_probability()[:, ir],
+        ).probability
+        if "u" in given:
+            kanswind[:] = 1.0
+
+        # Lake level and discharge
+        if ("a" in given) and ("q" in given):
+            # If both are conditional, fill the matrix with ones
+            kans_aq = np.ones((len(self.lake_level), len(self.discharge)))
+        else:
+            # If one of two is not conditional, use the momentary probability
+            kans_aq = self.density_aq
+            if "a" not in given:
+                kans_aq[...] = ProbabilityFunctions.conditional_probability(
+                    kans_aq, axis=0
+                )
+            if "q" not in given:
+                kans_aq[...] = ProbabilityFunctions.conditional_probability(
+                    kans_aq, axis=1
+                )
+
+        # Probility for wind direction
+        kanswr = 1.0 if "r" in given else self.wind_direction.get_probability()[ir]
+
+        # Combine all probabilities
+        kansen = kanswind[:, None, None] * kans_aq[None, :, :] * kanswr
+
+        # Ramspol closing probability
+        keringkans = self.barrier.calculate_closing_probability(None, closing_situation)
+        kansen *= keringkans
+
+        # Swap axis
+        kansen = np.swapaxes(kansen, 1, 2)
+
+        # Return probability
+        return kansen
+
+    def __prob_combined(self) -> np.ndarray:
+        """Bereken de gezamelijke kans op afvoer en meerpeil. De functie wordt zowel
+        gebruikt in de VIJD als het VZM, vandaar dat deze niet aan een klasse gekoppeld is.
+
+        Parameters
+        ----------
+        afvoer : afvoer.Afvoer
+            Afvoerstatistiekobject
+        meerpeil : meerpeil.Meerpeil
+            Meerpeilstatistiekobject
+        invoergeg:
+            Invoergegevensobject
+
+        Returns
+        -------
+        np.ndarray
+            Gezamelijke kansdichtheid van meerpeil en afvoer
+        """
+        # Bereken de kansdichtheid van de piekafvoer
+        kansafvoer = ProbabilityFunctions.probability_density(
+            self.discharge.qblok, self.discharge.epqpeak
+        )
+        kansmeerpeil = ProbabilityFunctions.probability_density(
+            self.lake_level.ablok, self.lake_level.k_apeak
+        )
+
+        ovmaxm = self.lake_level.epapeak[-1]
+        sigma = self.settings.sigma_aq
+
+        # Bereken de gezamenlijke kansdichtheid van de piekwaardes van de afvoer en het meerpeil
+        assert self.lake_level.nablok == self.lake_level.napeak
+        nm = self.lake_level.nablok
+        assert self.discharge.nqblok == self.discharge.nqpeak
+        nq = self.discharge.nqblok
+        dichtheid_mqpiek = np.full((nm, nq), 0.0)
+
+        for iq in range(nq):
+            somkans = 0.0
+
+            for im in reversed(range(nm)):
+                deltam = kansmeerpeil.delta[im]
+
+                y = self.lake_level.k_apeak[im] - self.discharge.eqpeak_exp[iq]
+
+                dichtheid_mqpiek[im, iq] = (
+                    kansmeerpeil.density[im]
+                    * np.exp(-(y**2) / (2.0 * sigma**2))
+                    / (sigma * (2.0 * np.pi) ** 0.5)
+                )
+
+                # Als de som over de kansen groter wordt dan 1, dan wordt voor het beschouwde, die kansmassa
+                # aangehouden dat de som over de kansen gelijk wordt aan 1. De verdere blokjes krijgen geen kans.
+                if (somkans <= (1.0 - ovmaxm)) & (
+                    (somkans + dichtheid_mqpiek[im, iq] * deltam) >= (1.0 - ovmaxm)
+                ):
+                    dichtheid_mqpiek[im, iq] = (1.0 - ovmaxm - somkans) / deltam
+                    somkans = 1.0 - ovmaxm
+                    break
+
+                somkans += dichtheid_mqpiek[im, iq] * deltam
+
+            if somkans > (1.0 - ovmaxm):
+                dichtheid_mqpiek[:, iq] /= somkans
+
+            dichtheid_mqpiek[:, iq] *= kansafvoer.density[iq]
+
+        # En de blokstat
+        # Overschrijdingsduren van afvoer- en meerpeilgolf bepalen
+        overschrijdingsduren_mq = (
+            self.discharge.wave_shape.bepaal_gezamenlijke_overschrijding(
+                golfvormen_st1=self.lake_level.wave_shape,
+                niveaus_st1=self.lake_level.ablok,
+                golfvormen_st2=self.discharge.wave_shape,
+                niveaus_st2=self.discharge.qblok,
+            )
+        )
+
+        # Momentane kansen bepalen
+        dq = ProbabilityFunctions.probability_density(
+            self.discharge.qpeak, self.discharge.epqpeak
+        ).delta
+        dm = ProbabilityFunctions.probability_density(
+            self.lake_level.apeak, self.lake_level.epapeak
+        ).delta
+        kans_mqpiek = dichtheid_mqpiek * dm[:, None] * dq[None, :]
+        ovkansmq = (kans_mqpiek[:, :, None, None] * overschrijdingsduren_mq).sum(
+            (0, 1)
+        ) / (self.settings.base_duration)
+
+        # Corrigeer kleine onvolkomenheden
+        ovkansmq = np.maximum.accumulate(ovkansmq[::-1])[::-1]
+
+        tussenkans = np.zeros((nq, nm))
+        for iq in range(nq):
+            tussenkans[iq, :] = ProbabilityFunctions.probability_density(
+                self.lake_level.ablok, ovkansmq[:, iq]
+            ).probability
+
+        # Corrigeer kleine onvolkomenheden
+        tussenkans = np.maximum.accumulate(tussenkans[::-1])[::-1]
+
+        dichtheid_mqblok = np.zeros((nm, nq))
+        for im in range(nm):
+            dichtheid_mqblok[im, :] = ProbabilityFunctions.probability_density(
+                self.discharge.qblok, tussenkans[:, im]
+            ).probability
+
+        dichtheid_mqblok /= dichtheid_mqblok.sum()
+
+        return dichtheid_mqpiek, dichtheid_mqblok, overschrijdingsduren_mq

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

@@ -0,0 +1,86 @@
+import numpy as np
+
+from ..statistics import Statistics
+from ..stochastics.discrete_probability import DiscreteProbability
+from ..stochastics.lake_level import LakeLevel
+from ..stochastics.model_uncertainty import ModelUncertainty
+from ..stochastics.wind_speed import WindSpeed
+from ....settings.settings import Settings
+from .....common.probability import ProbabilityFunctions
+
+
+class StatisticsLake(Statistics):
+    """
+    Statistics class for the Lakes
+    Water systems: IJssel Lake, Marker Lake, Veluwe Lakes and Grevelingen
+    """
+
+    def __init__(self, settings: Settings):
+        """
+        Init the Statistics class
+
+        Parameters
+        ----------
+        settings : Settings
+            The Settings object
+        """
+        # Inherit initialisation method from parent
+        super().__init__(settings)
+
+        # Wind
+        self.wind_direction = DiscreteProbability(settings.wind_direction_probability)
+        self.wind_speed = WindSpeed(settings)
+
+        # Lake level
+        self.lake_level = LakeLevel(settings)
+
+        # Model uncertainty
+        self.model_uncertainties = ModelUncertainty(settings)
+
+        # Discrete, slow, fast stochatics
+        self.stochastics_discrete = {
+            "r": self.wind_direction.get_discretisation(),
+            "k": [1],
+        }
+        self.stochastics_fast = {"u": self.wind_speed.get_discretisation()}
+        self.stochastics_slow = {"a": self.lake_level.get_discretisation()}
+
+    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
+        ----------
+        direction : float
+            Wind direction
+        closing_situation : int
+            Closing situation, (irrelevant for Coast)
+        given : list
+            Given stochasts
+        """
+        # Wind speed
+        ir = self.wind_direction.get_discretisation().tolist().index(wind_direction)
+        p_wind = ProbabilityFunctions.probability_density(
+            self.wind_speed.get_discretisation(),
+            self.wind_speed.get_exceedance_probability()[:, ir],
+        ).probability[:, None]
+        if "u" in given:
+            p_wind[:] = 1.0
+
+        # Lake level
+        if "a" in given:
+            p_lake_level = np.ones_like(self.lake_level.get_discretisation())
+        else:
+            # If not given, use the instantaneous probability
+            p_lake_level = ProbabilityFunctions.probability_density(
+                self.lake_level.get_discretisation(),
+                1 - self.lake_level.get_exceedance_probability(),
+            ).probability
+
+        # Probability of wind direction
+        p_direction = 1.0 if "r" in given else self.wind_direction.get_probability()[ir]
+
+        # Combine probabilities
+        return p_wind * p_lake_level[None, :] * p_direction

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

@@ -0,0 +1,321 @@
+import numpy as np
+
+from ..statistics import Statistics
+from ..stochastics.barrier.barrier_europoort import BarrierEuropoort
+from ..stochastics.discharge import Discharge
+from ..stochastics.discrete_probability import DiscreteProbability
+from ..stochastics.model_uncertainty import ModelUncertainty
+from ..stochastics.sea_level.sea_level_lower_river import SeaLevelLowerRiver
+from ..stochastics.wind_speed import WindSpeed
+from ....settings.settings import Settings
+from .....common.interpolate import Interpolate
+from .....common.probability import ProbabilityFunctions
+
+
+class StatisticsLowerRiver(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
+        self.sea_level = SeaLevelLowerRiver(settings)
+
+        # Wind
+        self.wind_direction = DiscreteProbability(settings.wind_direction_probability)
+        self.wind_speed = WindSpeed(settings)
+
+        # Discharge
+        self.discharge = Discharge(settings)
+
+        # Europoort Barrier
+        self.barrier = BarrierEuropoort(
+            settings,
+            self.wind_direction,
+            self.wind_speed,
+            self.sea_level,
+            self.discharge,
+        )
+
+        # Model uncertainty
+        self.model_uncertainties = ModelUncertainty(settings)
+
+        # Discrete, slow, fast stochatics
+        self.stochastics_discrete = {
+            "r": self.wind_direction.get_discretisation(),
+            "k": self.barrier.k,
+        }
+        self.stochastics_fast = {
+            "u": self.wind_speed.get_discretisation(),
+            "m": self.sea_level.get_discretisation(),
+        }
+        self.stochastics_slow = {"q": self.discharge.get_discretisation()}
+
+    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
+        ----------
+        direction : float
+            Wind direction
+        closing_situation : int
+            Closing situation, (irrelevant for Coast)
+        given : list
+            Given stochasts
+        """
+        # Sector West: Discharge, sea level and Europoort barrier
+        if ((wind_direction >= 0.0) and (wind_direction <= 11.25)) or (
+            (wind_direction > 212.75) and (wind_direction <= 360.0)
+        ):
+            if "q" in given:
+                kansafvoer = np.ones_like(self.discharge.get_discretisation())
+            else:
+                # Note: use the momentary probability of the discharge
+                kansafvoer = ProbabilityFunctions.probability_density(
+                    self.discharge.get_discretisation(),
+                    1 - self.discharge.get_exceedance_probability(),
+                ).probability
+
+            # Kans op windrichting
+            ir = self.wind_direction.get_discretisation().tolist().index(wind_direction)
+            kanswr = 1.0 if "r" in given else self.wind_direction.get_probability()[ir]
+
+            # Bepaal sluitkansen voor de windrichting
+            sluitkans = self.barrier.calculate_closing_probability(
+                wind_direction, closing_situation
+            )
+            if "k" in given:
+                sluitkans[:] = 1.0
+
+            # Overschrijdingskans windsnelheid
+            ovkansu_m = self.ovkansu_m(wind_direction)
+            kanswind = np.array(
+                [
+                    ProbabilityFunctions.probability_density(
+                        self.wind_speed.get_discretisation(), ovkansu_m[:, im]
+                    ).probability
+                    for im in range(len(self.sea_level))
+                ]
+            ).T[:, :, None]
+            if "u" in given:
+                kanswind[:] = 1.0
+
+            # Kans zeewaterstand
+            kanszws = ProbabilityFunctions.probability_density(
+                self.sea_level.get_discretisation(),
+                self.sea_level.get_exceedance_probability()[:, ir],
+            ).probability[None, :, None]
+            if "m" in given:
+                kanszws[:] = 1.0
+
+            # Combineer alle kansen
+            comb = kanswind * kanszws * kansafvoer[None, None, :] * sluitkans * kanswr
+            return np.swapaxes(comb, 1, 2)
+
+        # Otherwise, sector east (without sea level and Europoort)
+        else:
+            # Kans windsnelheid
+            ir = self.wind_direction.get_discretisation().tolist().index(wind_direction)
+            kanswind = ProbabilityFunctions.probability_density(
+                self.wind_speed.get_discretisation(),
+                self.wind_speed.get_exceedance_probability()[:, ir],
+            ).probability[:, None]
+            if "u" in given:
+                kanswind[:] = 1.0
+
+            # Afvoer
+            if "q" in given:
+                kansafvoer = np.ones_like(self.discharge.get_discretisation())
+            else:
+                # Let op! gebruikt de MOMENTANE kans van een afvoer
+                kansafvoer = ProbabilityFunctions.probability_density(
+                    self.discharge.get_discretisation(),
+                    1 - self.discharge.get_exceedance_probability(),
+                ).probability
+
+            # Kans op windrichting
+            kanswr = 1.0 if "r" in given else self.wind_direction.get_probability()[ir]
+
+            # Combineer alle kansen
+            return kanswind * kansafvoer[None, :] * kanswr
+
+    def ovkansu_m(self, wind_direction: float):
+        """
+        Bereken de overschrijdingskans van de windsnelheid volgens het
+        correlatiemodel met de
+
+        Parameters
+        ----------
+        richting : float
+            Windrichting
+
+        Returns
+        -------
+        ondkans : np.ndarray
+            2D-array per windsnelheid en zeewaterstand
+        """
+        #  Bepaal transformatiewaarde van de windsnelheid voor het juiste rooster van windsnelheden
+        if self.settings.transitional_wind == 0:
+            kru = self.bereken_kru_polynoom(wind_direction)
+        elif self.settings.transitional_wind == 1:
+            kru = self.bereken_kru_tabel(wind_direction)
+        else:
+            raise ValueError(self.settings.transitional_wind)
+
+        #  Bereken de windsnelheidkansen per richting en zeewaterstand voor de windsnelheid in de statistiek
+        return 1.0 - self.ondkanswindsnelheid(
+            wind_direction, kru, self.sea_level.get_discretisation()
+        )
+
+    def ondkanswindsnelheid(self, wind_direction, kru, m):
+        """
+        Bepaling van de onderschrijdingskans van de windsnelheid gegeven de
+        zeewaterstand en de windrichting
+
+        Parameters
+        ----------
+        wind_direction : float
+            Windrichting
+        kru : np.ndarray
+            Transformatiewaarde van de windsnelheid
+
+        Returns
+        -------
+        kans : np.array [len(kru), len(m)]
+            Onderschrijdingskans van de windsnelheid gegeven de zeewaterstand en de windrichting
+        """
+        ir = self.wind_direction.get_discretisation().tolist().index(wind_direction)
+        windparams = self.sea_level.pwinds[:, ir]
+
+        # Bepaal de onderschrijdingskans van de windsnelheid uit de
+        # Gumbelverdeelde getransformeerde waarde van de windsnelheid
+        alpha = (
+            windparams[5]
+            * (m + self.sea_level.translation_m - windparams[0])
+            / windparams[1]
+        )
+        ondkans = np.exp(-np.exp((-kru[:, None] + alpha[None, :]) / windparams[6]))
+
+        # Afknotten van de Gumbelverdeling
+        ondkans = np.minimum(1.0, (1.0 / (1.0 - self.settings.fu)) * ondkans)
+
+        return ondkans
+
+    def bereken_kru_tabel(self, wind_direction: float):
+        """
+        Berekenen van de transformatietabel van de windsnelheid
+
+                Creeer eerst een vector met waarden voor het hele bereik van K_r(u)
+        Ken vectorafmetingen toe aan parameters
+        Alloceer geheugen voor het hele bereik van K_r(u)
+        Maak lokaal een vector met zeewaterstanden
+        Alloceer geheugen voor de zeewaterstanden
+        Voor alle windsnelheden
+        {
+        Voor alle zeewaterstanden
+        {
+            Bepaal de onderschrijdingskans van K_r(u) gegeven de zeewaterstand
+                en de windrichting
+        }
+        Bereken de integraal over de zeewaterstanden
+        Verwijder de K_r(u)'s met onderschijdingskansen, die bij lagere waardes
+            ook al voorkomen
+        Voor kleine onder- en overschrijdingskansen de K_r(u) berekenen met
+            extrapolatie
+        }
+        Geef het gealloceerde geheugen weer vrij
+        """
+        ir = self.wind_direction.get_discretisation().tolist().index(wind_direction)
+
+        #  Creeer eerst een vector met waarden voor het hele bereik van K_r(u)
+        kru = np.arange(-3.0, 20.001, 0.2)
+
+        #  Maak lokaal een vector met zeewaterstanden
+        m_max = max(7.0, self.sea_level.get_discretisation()[-1])
+        m = np.linspace(0.75, m_max, int(round((m_max - 0.75) / 0.05)) + 1)
+
+        # Bepaal de onderschrijdingskans van K_r(u) gegeven de zeewaterstand en de windrichting
+
+        # Bepaal de overschrijdingskansen van de zeewaterstand gegeven de windrichting op het
+        # juiste rooster (N.B. kansdichtheden worden niet geenterpoleerd##)
+        # TODO: logaritmisch?
+        ovkanszws = Interpolate.inextrp1d(
+            x=m,
+            xp=self.sea_level.get_discretisation(),
+            fp=self.sea_level.get_exceedance_probability()[:, ir],
+        )
+        ovkanszws[ovkanszws > 1.0] = 1.0
+        ovkanszws = np.maximum.accumulate(ovkanszws[::-1])[::-1]
+
+        # Bereken de kansdichtheid uit de overschrijdingskansen
+        kanszws = ProbabilityFunctions.probability_density(m, ovkanszws).probability
+
+        # Bereken de integraal over de zeewaterstanden
+        ondkans_y_r = (
+            self.ondkanswindsnelheid(wind_direction, kru, m) * kanszws[None, :]
+        ).sum(1)
+
+        # Verwijder de K_r(u)'s met onderschijdingskansen, die bij lagere waardes ook al voorkomen
+        ondkans_uniek, idx = np.unique(ondkans_y_r, return_index=True)
+        kru_uniek = kru[idx]
+
+        # Voor kleine onder- en overschrijdingskansen de K_r(u) berekenen met extrapolatie
+        # Bepaal eerste het gebied dat BINNEN deze grenzen valt
+        ovkans_u = self.wind_speed.get_exceedance_probability()[:, ir]
+        idx = (ovkans_u >= 1.0e-7) & (ovkans_u <= 1 - 1.0e-8)
+
+        # Alloceer nieuwe array voor kru
+        kru = np.zeros_like(ovkans_u)
+
+        # Interpoleer dit gebied
+        kru[idx] = Interpolate.inextrp1d(
+            x=1.0 - ovkans_u[idx], xp=ondkans_uniek, fp=kru_uniek
+        )
+
+        # Extrapoleer de andere waarden hier omheen
+        kru[~idx] = Interpolate.inextrp1d(
+            x=self.wind_speed.get_discretisation()[~idx],
+            xp=self.wind_speed.get_discretisation()[idx],
+            fp=kru[idx],
+        )
+
+        return kru
+
+    def bereken_kru_polynoom(self, wind_direction: float):
+        """
+        Bepaal transformatiewaarden van de windsnelheden
+
+        Parameters
+        ---------
+
+        Returns
+        -------
+        kru
+            Vector met transformatiewaarden voor de windsnelheid op het gewenste rooster van de windsnelheden
+        """
+        ir = self.wind_direction.get_discretisation().tolist().index(wind_direction)
+        windparams = self.sea_level.pwinds[:, ir]
+
+        #  Bepaal transformatiewaarden van de windsnelheden
+        kru = (
+            windparams[2] * self.wind_speed.get_discretisation() ** 2
+            + windparams[3] * self.wind_speed.get_discretisation()
+            + windparams[4]
+        )
+
+        return kru