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

pydra_core/location/model/statistics/stochastics/barrier/barrier_easternscheldt.py

@@ -0,0 +1,147 @@
+import numpy as np
+
+from .barrier import Barrier
+from ..discrete_probability import DiscreteProbability
+from ..sea_level.sea_level import SeaLevel
+from ..wind_speed import WindSpeed
+from ....loading.loading_model.loading_model import LoadingModel
+from .....settings.settings import Settings
+from ......common.interpolate import InterpStruct, Interpolate
+from ......io.database_hr import DatabaseHR
+from ......io.file_hydranl import FileHydraNL
+
+
+class BarrierEasternScheldt(Barrier):
+    def __init__(
+        self,
+        settings: Settings,
+        wind_direction: DiscreteProbability,
+        wind_speed: WindSpeed,
+        sea_level: SeaLevel,
+    ):
+        # Inherit
+        super().__init__(settings, wind_direction)
+
+        # Lees kansen op sluitscenario's: de kans op bemand of onbemand
+        self.t = np.array([0.0, 1.0])
+
+        # pfk bevat de kans op een aantal falende schuiven (bijv 0, 16, 31, 62) voor
+        # een bemande dan wel onbemande sluiting, gegeven dat de kering faalt dus
+        self.k, self.p_fail_k = FileHydraNL.read_file_ncolumns(
+            settings.barrier_scenario_probability
+        )
+        self.k = self.k.astype(int)
+
+        # Lees kansen op sluitscenario's: de kans op sluiting gegeven de zeewaterstand en aantal falende sluizen
+        self.n_closing = len(self.k)
+        self.nk = len(self.t) * len(self.k)
+
+        # sluitkansenk bevat de kans op een sluitvraag (al dan niet succesvol) gegeven de zeewaterstand
+        # Voor een stategiesluiting, handmatige sluiting, noodsluiting door het systeem, of geen sluiting
+        self.m_closing, self.p_closing_k = FileHydraNL.read_file_ncolumns(
+            settings.barrier_closing_probability
+        )
+
+        # Database connection
+        with DatabaseHR(settings.database_path) as database:
+            # Read closing situations
+            self.closing_situations = database.get_closing_situations_eastern_scheldt()
+
+            # Maak sluitpeilen structure (u, m, r, d, p)
+            self.closing_levels = LoadingModel(
+                None, None, ["u", "m", "r", "d", "p"], ["h_rpb"]
+            )
+            self.closing_levels.initialise(
+                database.get_closing_levels_table_eastern_scheldt()
+            )
+
+        # h_roompot_buiten bevat de waterstand bij RPBU. Het sluitpeil van de oosterscheldekering is 3.0 m+NAP
+        # bij hogere waterstanden zal de kering dus (pogen) te sluiten. Nu is de kans op al dan niet sluiten
+        # ook afhankelijk van deze waterstand. Hoe hoger de waterstand, hoe groter de kans dat het misgaat.
+        # Daarom zit er in de database een tabel met optredende waterstanden bij Roompot Buiten. Wanneer
+        # Deze waterstand < 3.0 is, zit de waarde -9.0 in de database, om aan te geven dat de kering open blijft.
+
+        # Interpoleer sluitpeilen op het grid van de windsnelheid en zeewaterstand
+        # Eerst over de windsnelheid
+        intstr = InterpStruct(
+            x=wind_speed.get_discretisation(), xp=self.closing_levels.u
+        )
+        levels_u = intstr.interp(
+            fp=self.closing_levels.h_rpb,
+            axis=self.closing_levels.input_variables.index("u"),
+        )
+
+        # Dan over de zeewaterstand
+        intstr = InterpStruct(
+            x=sea_level.get_discretisation(), xp=self.closing_levels.m
+        )
+        self.h_rpb = intstr.interp(
+            fp=levels_u, axis=self.closing_levels.input_variables.index("m")
+        )
+
+        # Controleer op waarden van -9 en kleiner.
+        self.not_closing = self.h_rpb <= -9.0
+
+    def calculate_closing_probability(
+        self, wind_direction: float, closing_situation: int
+    ) -> np.ndarray:
+        """
+        Bereken de kans op het al dan niet falen van N sluizen
+        in de Oosterscheldekering en het type sluiting (nood of strategie)
+        De kansen zijn conditioneel op de zeewaterstand.
+        """
+        # Translate to wind direction id
+        ir = self.wind_direction.get_discretisation().tolist().index(wind_direction)
+
+        # Vertaal sluitsituatie (id) naar nood/strategie...
+        sluittype = self.closing_situations[closing_situation][0]
+        if sluittype not in ["Reguliere sluiting", "Noodsluiting"]:
+            raise KeyError(sluittype)
+
+        # ...en aantal schuiven
+        nfaal = self.closing_situations[closing_situation][1]
+        ik = self.k.tolist().index(nfaal)
+
+        # Hernoem voor beter begrip
+        kans_strategie_m = self.p_closing_k[:, 0]
+        kans_handmatig_m = self.p_closing_k[:, 1]
+        kans_noodsluit_m = self.p_closing_k[:, 2]
+        # kans_geensluit_m = self.p_closing_k[:, 3]
+
+        kansfalen_bemand = self.p_fail_k[:, 0]
+        kansfalen_onbemand = self.p_fail_k[:, 1]
+
+        # Kansen op noodsluiting, en N falende schuiven
+        # Noodsluiting door mens (bemand) of systeem (onbemand)
+        if sluittype == "Noodsluiting":
+            kansfalensluiting = (
+                kansfalen_bemand[ik] * kans_handmatig_m
+                + kansfalen_onbemand[ik] * kans_noodsluit_m
+            )
+
+        elif sluittype == "Reguliere sluiting":
+            # Strategiesluiting (bemand)
+            kansfalensluiting = kansfalen_bemand[ik] * kans_strategie_m
+
+            # En dan is er nog de kans dat de kering niet hoeft te sluiten (ongeacht bemand of onbemand)
+            # Deze kans moet ingedeeld worden in een van de sluitscenario's. Neem hiervoor het sluitscenario
+            # met zoveel mogelijk falende sluitingen, en de strategiesluiting
+            # if nfaal == self.k.max():
+            # kansfalensluiting[:] += kans_geensluit_m
+
+        # Bereken de faalkansen aan de hand van de zeewaterstanden die voor de belastingcombinaties
+        # optreden bij Roompot Buiten door te interpoleren op de zeewaterstanden
+        keringsituatiekansen = Interpolate.inextrp1d(
+            x=self.h_rpb[:, :, ir, :, :], xp=self.m_closing, fp=kansfalensluiting
+        )
+
+        # Als laatste is de kans op de keringsituatie nog afhankelijk van het al dan niet halen van het sluitpeil
+        # Als het sluitpeil niet gehaald wordt, is de kans op de keringsituatie met sluiting 0, tenzij het om de
+        # situatie zonder sluiting gaat
+        idx = self.not_closing[:, :, ir, :, :]
+        if (sluittype == "Reguliere sluiting") and (nfaal == self.k.max()):
+            keringsituatiekansen[idx] = 1.0
+        else:
+            keringsituatiekansen[idx] = 0.0
+
+        return keringsituatiekansen

pydra_core/location/model/statistics/stochastics/barrier/barrier_europoort.py

@@ -0,0 +1,209 @@
+import numpy as np
+
+from scipy.stats import norm
+
+from .barrier import Barrier
+from ..discharge import Discharge
+from ..discrete_probability import DiscreteProbability
+from ..sea_level.sea_level import SeaLevel
+from ..wind_speed import WindSpeed
+from ....loading.loading_model.loading_model import LoadingModel
+from .....settings.settings import Settings
+from ......common.interpolate import InterpStruct
+from ......io.database_hr import DatabaseHR
+
+
+class BarrierEuropoort(Barrier):
+    def __init__(
+        self,
+        settings: Settings,
+        wind_direction: DiscreteProbability,
+        wind_speed: WindSpeed,
+        sea_level: SeaLevel,
+        discharge: Discharge,
+    ):
+        # Inherit
+        super().__init__(settings, wind_direction)
+
+        # Save statistics
+        self.discharge = discharge
+        self.sea_level = sea_level
+        self.wind_speed = wind_speed
+
+        # Assert barrier == 1
+        if self.settings.europoort_barrier != 1:
+            raise NotImplementedError("[ERROR] Barrier != 1 not implemented.")
+
+        # Init standard variables
+        self.k = [0, 11]
+        self.nk = len(self.k)
+
+        # Database connection
+        with DatabaseHR(settings.database_path) as database:
+            # Closing levels
+            self.closing_levels = LoadingModel(None, None, ["u", "q", "r"], ["m"])
+            self.closing_levels.initialise(
+                database.get_closing_levels_table_europoort()
+            )
+
+        # Extend
+        self.closing_levels.extend("q", [self.settings.q_min, self.settings.q_max])
+        self.closing_levels.extend("u", [self.settings.u_max])
+
+        # Prepare probabilities
+        self.prepare_barrier_probability(sea_level)
+
+    def calculate_closing_probability(
+        self, wind_direction: float, closing_situation: int = None
+    ) -> np.ndarray:
+        # Translate to wind direction id
+        ir = self.wind_direction.get_discretisation().tolist().index(wind_direction)
+        nqblok = len(self.discharge)
+        nmblok = len(self.sea_level)
+
+        # Bepaal de index van de richting in de sluitpeilen
+        if wind_direction not in self.closing_levels.r:
+            raise KeyError(
+                f"[ERROR] Wind direction {wind_direction} not defined in closing levels loading."
+            )
+
+        ir = self.closing_levels.r.tolist().index(wind_direction)
+        if closing_situation == 1:  # Open
+            ik = 0  # 00
+            sluitkans = np.zeros((len(self.wind_speed), nmblok, nqblok))
+        elif closing_situation == 2:  # Closed
+            ik = 1  # 11
+            sluitkans = np.zeros((len(self.wind_speed), nmblok, nqblok))
+        elif closing_situation is None:  # Both
+            ik = slice(None)
+            sluitkans = np.zeros((len(self.wind_speed), nmblok, nqblok, len(self.k)))
+        else:
+            raise KeyError(closing_situation)
+
+        # De sluitpeilen (een zeewaterstand) zijn bekend per windsnelheid, windrichting en afvoer
+        # Eerste worden de sluitpeilen uitgebreid voor alle windsnelheden en afvoerniveaus in de statistiek
+
+        # Interpoleer over de windsnelheden, de eerste as van peilen
+        sluitpeil = InterpStruct(
+            x=self.wind_speed.get_discretisation(), xp=self.closing_levels.u
+        ).interp(fp=self.closing_levels.m[:, :, ir], axis=0)
+
+        # Interpoleer dit resultaat over de afvoeren, de tweede as van de peilen
+        sluitpeil = InterpStruct(
+            x=self.discharge.get_discretisation(), xp=self.closing_levels.q
+        ).interp(fp=sluitpeil, axis=1)
+
+        # Daarna wordt de sluitkans bepaald, door de zeewaterstanden bij deze windsnelheid, zeewaterstand en keringsituatie
+        # te interpoleren in de berekende sluitkansen per cm.
+
+        # De sluitkansen zijn afhankelijk van het sluitpeil, de zeewaterstand en (uiteraard) de sluitsituatie,
+        # de afmetingen van self.kansen is daarmee ncmsp, nmblok, nk
+
+        # De sluitkans moet bepaald worden per windsnelheid, zeewaterstand, afvoer en keringsituatie
+
+        # berekend voor de in de database aanwezig windsnelheden, windrichting, en elke centimeter zeewaterstand
+
+        # Voor elke afvoer, interpoleer de kansen
+        for iq in range(nqblok):
+            # bepaal de sluitkansen voor de combinatie van afvoer, kering en zeewaterstand
+            if isinstance(ik, int):
+                sluitkans[:, :, iq] = InterpStruct(
+                    x=sluitpeil[:, iq], xp=self.cmsp
+                ).interp(self.kansen[:, :, ik], axis=0)
+            else:
+                sluitkans[:, :, iq, :] = InterpStruct(
+                    x=sluitpeil[:, iq], xp=self.cmsp
+                ).interp(self.kansen[:, :, :], axis=0)
+
+        return sluitkans
+
+    def prepare_barrier_probability(self, sea_level: SeaLevel):
+        """
+        bereken het minimale sluitpeil, op cm's naar beneden afgerond
+
+        bepaal het aantal cm's van het minimale tot het maximale sluitpeil
+        alloceer geheugen
+
+        voor elke cm tussen het minimum en maximum
+            bepaal de hoogte van het sluitpeil
+
+        voor elke keringsituatie
+            bereken de keringskans per zeewaterstand en sluitpeil
+
+        Parameters
+        ----------
+        belasting : type (tprand2001)
+            structure met alle sluitpeilen
+        statistiek : type (tpstatistiek)
+            structure met waterstanden, golfparameters en hydraulische belastingen als gevolg daarvan
+        """
+        # bereken het minimale sluitpeil, op cm's naar beneden afgerond
+        step_size = 0.01
+        min_cl = np.floor(self.closing_levels.m.min() / step_size) * step_size
+        max_cl = np.ceil(self.closing_levels.m.max() / step_size) * step_size
+
+        # bepaal het aantal cm's van het minimale tot en met het maximale sluitpeil
+        self.nsp = int((max_cl - min_cl) / step_size) + 1
+
+        # alloceer geheugen
+        self.kansen = np.zeros((self.nsp, len(sea_level), len(self.k)))
+
+        # vul de vector met sluitpeilen voor elke cm
+        self.cmsp = min_cl + np.arange(self.nsp) * step_size
+
+        # Settings
+        barrier = int(self.settings.europoort_barrier)
+        distribution = self.settings.europoort_barrier_distribution
+        mu = self.settings.europoort_barrier_mu
+        sigma = self.settings.europoort_barrier_sigma
+        alfa = self.settings.europoort_barrier_alfa
+
+        # bereken de keringskans voor elke keringtoestand, zeewaterstand en sluitpeilcentimeter
+        for ik in range(self.nk):
+            #  bepaal kans op commando keringen dicht
+            if barrier != 2:
+                #  Normal distribution
+                if distribution == 0:
+                    s = (
+                        self.cmsp[:, None]
+                        - sea_level.get_discretisation()[None, :]
+                        - mu
+                    ) / sigma
+                    kansdicht = 1.0 - norm(loc=0.0, scale=1.0).cdf(x=s)
+
+                # Cosinus-squared distribution
+                elif distribution == 1:
+                    s = np.pi * sigma * (3.0 / (np.pi * np.pi - 6.0)) ** 0.5
+                    kansdicht = 0.5 * (
+                        1.0
+                        + (
+                            self.cmsp[:, None]
+                            - sea_level.get_discretisation()[None, :]
+                            - mu
+                        )
+                        / s
+                        + np.sin(
+                            np.pi
+                            * (
+                                self.cmsp[:, None]
+                                - sea_level.get_discretisation()[None, :]
+                                - mu
+                            )
+                            / s
+                        )
+                        / np.pi
+                    )
+
+                # Undefined distribution
+                else:
+                    raise ValueError("Fout type kansverdeling voorspelde zeewaterstand")
+
+            if barrier == 1:
+                if int(round(self.k[ik])) == 0:
+                    self.kansen[:, :, ik] = 1.0 - (1.0 - alfa) * kansdicht
+                elif int(round(self.k[ik])) == 11:
+                    self.kansen[:, :, ik] = (1.0 - alfa) * kansdicht
+
+            # Assert barrier == 1 (for now)
+            else:
+                raise NotImplementedError("[ERROR] Barrier != 1 not implemented.")

pydra_core/location/model/statistics/stochastics/barrier/barrier_ramspol.py

@@ -0,0 +1,41 @@
+import numpy as np
+
+# from scipy.stats import norm
+
+from .barrier import Barrier
+
+# from ..discharge import Discharge
+from ..discrete_probability import DiscreteProbability
+
+# from ..sea_level.sea_level import SeaLevel
+# from ..wind_speed import WindSpeed
+# from ....loading.loading_model.loading_model import LoadingModel
+from .....settings.settings import Settings
+
+
+class BarrierRamspol(Barrier):
+    def __init__(self, settings: Settings, wind_direction: DiscreteProbability):
+        # Inherit
+        super().__init__(settings, wind_direction)
+
+        # Init standard variables
+        self.k = [1, 2]
+        self.nk = len(self.k)
+
+        # Save failure probability of the Ramspol
+        self.failure_probability_ramspol = settings.failure_probability_ramspol
+
+    def calculate_closing_probability(
+        self, wind_direction: float, closing_situation: int
+    ) -> np.ndarray:
+        """
+        Calculate the failure probability of the Ramspol
+        """
+        if closing_situation == 1:
+            return self.failure_probability_ramspol
+        elif closing_situation == 2:
+            return 1 - self.failure_probability_ramspol
+        else:
+            raise KeyError(
+                f"[ERROR] Unknown closing situation: {closing_situation}, expecting 1 or 2."
+            )

pydra_core/location/model/statistics/stochastics/barrier/no_barrier.py

@@ -0,0 +1,21 @@
+import numpy as np
+
+from .barrier import Barrier
+
+
+class NoBarrier(Barrier):
+    def __init__(self):
+        # Inherit
+        super().__init__(None, None)
+
+        # Only 1 barrier state (= open)
+        self.k = [1]
+        self.nk = len(self.k)
+
+    def calculate_closing_probability(
+        self, wind_direction: float, closing_situation: int
+    ) -> np.ndarray:
+        """
+        Irrelevant for no barrier
+        """
+        return None

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

@@ -0,0 +1,108 @@
+import numpy as np
+
+from .wave_shape import WaveShape
+from ....settings.settings import Settings
+from .....common.enum import WaveShapeType
+from .....common.interpolate import Interpolate
+from .....io.file_hydranl import FileHydraNL
+
+
+class Discharge:
+    """
+    Class to describe the discharge statistics.
+    """
+
+    def __init__(self, settings: Settings):
+        """
+        Constructor for discharge statistics
+
+        Parameters
+        ----------
+        settings : Settings
+            The Settings object
+        """
+        # Read exceedance probability peak discharge
+        qpeak, epqeak = FileHydraNL.read_file_2columns(settings.discharge_probability)
+
+        # Create grid for peak discharges
+        self.qpeak = np.r_[
+            np.arange(settings.q_min, settings.q_max, settings.q_step), settings.q_max
+        ]
+        self.nqpeak = len(self.qpeak)
+
+        # Inter/extrapolate the exceedance probability of the discharge
+        self.epqpeak = np.exp(
+            Interpolate.inextrp1d(x=self.qpeak, xp=qpeak, fp=np.log(epqeak))
+        )
+
+        #  Transformatie van de tabel met OVERschrijdingskansen naar exponentiële ruimte
+        #  Zie ook vgl. 4.5 van [Geerse, 2003], merk op dat het daar ONDERschrijdingskansen betreft#
+        self.eqpeak_exp = -np.log(self.epqpeak)
+
+        # Init the wave forms
+        self.wave_shape = WaveShape(settings, type=WaveShapeType.DISCHARGE)
+        self.wave_shape.initialise_wave_shapes(self.qpeak)
+
+        # Create grid with blok discharges
+        if settings.q_min < np.min(self.qpeak):
+            step = self.qpeak[1] - self.qpeak[0]
+            self.qblok = np.r_[
+                np.arange(settings.q_min, np.min(self.qpeak), step), self.qpiek
+            ]
+        elif settings.q_min > np.min(self.qpeak):
+            raise ValueError("[ERROR] Q_min is larger than the lowest Q_peak.")
+        else:
+            self.qblok = self.qpeak
+        self.nqblok = len(self.qblok)
+
+        # Calculate the instantaneous exceedance probability
+        inst_epq = self.wave_shape.instantaneous_exceedance_probability(
+            self.epqpeak, self.qblok
+        )
+
+        # Make sure the exceedance probability is not larger than 1 or smaller than 0
+        self.upqblok = np.clip(1.0 - inst_epq, 0.0, 1.0)
+
+    def __len__(self):
+        """
+        Return the number of discharge discretisations.
+
+        Returns
+        -------
+        int
+            Number of discretisations
+        """
+        return self.nqblok
+
+    def get_discretisation(self) -> np.ndarray:
+        """
+        Return the discharge discretisation.
+
+        Returns
+        -------
+        np.ndarray
+            1D array with discretisation
+        """
+        return self.qblok
+
+    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.upqblok
+
+    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/discrete_probability.py

@@ -0,0 +1,55 @@
+import numpy as np
+
+from .....io.file_hydranl import FileHydraNL
+
+
+class DiscreteProbability:
+    """
+    Class to describe the discrete statistics.
+    """
+
+    def __init__(self, statistics_file_path: str):
+        """
+        Constructor class for the discrete statistics.
+
+        Parameters
+        ----------
+        statistics_file_path : str
+            Path to the statistics file
+        """
+        self.discretisation, self.probability = FileHydraNL.read_file_2columns(
+            statistics_file_path
+        )
+
+    def __len__(self):
+        """
+        Return the number discretisations.
+
+        Returns
+        -------
+        int
+            Number of discretisations
+        """
+        return len(self.discretisation)
+
+    def get_discretisation(self) -> np.ndarray:
+        """
+        Return the discretisation.
+
+        Returns
+        -------
+        np.ndarray
+            1D array with discretisation
+        """
+        return self.discretisation
+
+    def get_probability(self) -> np.ndarray:
+        """
+        Return the probability of each discretisation.
+
+        Returns
+        -------
+        np.ndarray
+            1D array with probabilities
+        """
+        return self.probability