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

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

@@ -0,0 +1,86 @@
+import numpy as np
+
+from ..statistics import Statistics
+from ..stochastics.discharge import Discharge
+from ..stochastics.discrete_probability import DiscreteProbability
+from ..stochastics.model_uncertainty import ModelUncertainty
+from ..stochastics.wind_speed import WindSpeed
+from ....settings.settings import Settings
+from .....common.probability import ProbabilityFunctions
+
+
+class StatisticsUpperRiver(Statistics):
+    """
+    Statistics class for the Upper Rivers
+    Water systems: Rhine Non Tidal and Meuse (Valley) Non Tidal
+    """
+
+    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)
+
+        # Discharge
+        self.discharge = Discharge(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 = {"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
+        """
+        # 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
+
+        # Discharge
+        if "q" in given:
+            p_discharge = np.ones_like(self.discharge.get_discretisation())
+        else:
+            # If not given, use the instantaneous probability
+            p_discharge = ProbabilityFunctions.probability_density(
+                self.discharge.get_discretisation(),
+                1 - self.discharge.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_discharge[None, :] * p_direction

pydra_core/location/model/water_system.py

@@ -0,0 +1,249 @@
+import numpy as np
+
+from .base_model import BaseModel
+from .loading.loading_factory import LoadingFactory
+from .statistics.statistics_factory import StatisticsFactory
+from ..settings.settings import Settings
+from ...common.probability import ProbabilityFunctions
+
+
+class WaterSystem(BaseModel):
+    def __init__(self, settings: Settings):
+        """
+        Water System model
+        """
+        # Inherit
+        super().__init__(settings)
+
+        # Statistics
+        self.statistics = StatisticsFactory.get_statistics(self.settings)
+
+        # Loading
+        self.loading = LoadingFactory.get_loading(self.settings)
+
+    def process_slow_stochastics(
+        self, exceedance_probability: np.ndarray, axis: int = None
+    ) -> np.ndarray:
+        """
+        Convert probabilities given a discharge to probabilities per duration.
+
+        This function converts probabilities represented by a discharge to
+        probabilities per specified duration based on the given stochastic
+        variable ('stochastic'). The probabilities are computed for each
+        duration (basisduur).
+
+        Parameters
+        ----------
+        exceedance_probability : np.ndarray
+            Numpy array with the discharge on the first dimension.
+
+        Returns
+        -------
+        np.ndarray
+            Probabilities per specified duration (basisduur).
+        """
+        # Input stochastics
+        statistics = self.get_statistics()
+        slow_stochastics = list(statistics.stochastics_slow.keys())
+        _axis = range(1, len(slow_stochastics) + 1) if axis is None else axis
+
+        # Put slow variable on first axis if not already
+        newpos = range(len(np.atleast_1d(_axis)))
+        if newpos != _axis:
+            ep_x = np.moveaxis(exceedance_probability, _axis, newpos)
+        else:
+            ep_x = exceedance_probability
+
+        # Calculate exceedance frequencies per peak discharge / lake level
+        ep_ks = self.process_wave_shape(ep_x)
+
+        # Steps in probability density
+        if len(slow_stochastics) == 1 and slow_stochastics[0] == "q":
+            p_peak = ProbabilityFunctions.probability_density(
+                statistics.discharge.qpeak, statistics.discharge.epqpeak
+            ).probability
+
+        elif len(slow_stochastics) == 1 and slow_stochastics[0] == "a":
+            p_peak = ProbabilityFunctions.probability_density(
+                statistics.lake_level.apeak, statistics.lake_level.epapeak
+            ).probability
+
+        elif len(slow_stochastics) == 2 and slow_stochastics == ["a", "q"]:
+            dq = ProbabilityFunctions.probability_density(
+                statistics.discharge.qblok, statistics.discharge.epqpeak
+            ).delta
+            dm = ProbabilityFunctions.probability_density(
+                statistics.lake_level.ablok, statistics.lake_level.epapeak
+            ).delta
+            p_peak = statistics.density_aq_peak * dm[:, None] * dq[None, :]
+
+        elif len(slow_stochastics) == 2 and slow_stochastics == ["q", "a"]:
+            dq = ProbabilityFunctions.probability_density(
+                statistics.discharge.qblok, statistics.discharge.epqpeak
+            ).delta
+            da = ProbabilityFunctions.probability_density(
+                statistics.lake_level.ablok, statistics.lake_level.epapeak
+            ).delta
+            p_peak = statistics.density_aq_peak.T * dq[:, None] * da[None, :]
+
+        # Reshape steps when multiplying to trapezoidal probs
+        shp = p_peak.shape + (1,) * (ep_ks.ndim - p_peak.ndim)
+
+        # Trapezoidal probability
+        p_trapezoidal = (p_peak.reshape(shp) * ep_ks).sum(
+            axis=tuple(range(p_peak.ndim))
+        )
+
+        return p_trapezoidal
+
+    def process_wave_shape(self, exceedance_probability: np.ndarray) -> np.ndarray:
+        """
+        Process the discharge waveshapes into the exceedance probabilities
+        conditioned on the discharge level. The discharge level is represented
+        on the first axis, which has dimensions equal to the number of
+        discharge steps in the statistics.
+
+        Parameters
+        ----------
+        exceedance_probability : np.ndarray
+            Numpy array containing the exceedance probabilities with the
+            discharge on the first dimension.
+
+        Returns
+        -------
+        blokondkans : np.ndarray
+            Exceedance probabilities of the discharge per duration (basisduur).
+        """
+        # Input variables
+        statistics = self.get_statistics()
+        slow_stochastics = list(statistics.stochastics_slow.keys())
+        fp = exceedance_probability
+
+        # Result variables
+        intidxs = []
+        xs = []
+        xps = []
+
+        # Verzamel de interpolatieindices voor alle trage stochasten
+        for i, _stochastic in enumerate(slow_stochastics):
+            if _stochastic == "q":
+                xp = statistics.discharge.qpeak
+                x = statistics.discharge.get_wave_shape().get_wave_shapes()
+                tijden = statistics.discharge.get_wave_shape().time
+            elif _stochastic == "a":
+                xp = statistics.lake_level.apeak
+                x = statistics.lake_level.get_wave_shape().get_wave_shapes()
+                tijden = statistics.lake_level.get_wave_shape().time
+            else:
+                raise ValueError(
+                    f"Eerste trage stochast is niet 'q' of 'm'/'a' (gegeven eerste trage stochast: {_stochastic})"
+                )
+
+            # Check if the length matches
+            if exceedance_probability.shape[i] != x.shape[1]:
+                raise ValueError(
+                    f"The number of elements in the stochast axis ({i}) should be {x.shape[1]} ({x.shape}), but is {exceedance_probability.shape[i]} ({exceedance_probability.shape})."
+                )
+
+            # Bepaal de interpolatie-indices, de xp-punten rondom x waartussen wordt geïnterpoleerd
+            intidx = np.array(
+                [(xp[None, :] <= ix[:, None]).sum(1) - 1 for ix in x], dtype=np.uint16
+            )
+            intidx = np.minimum(np.maximum(intidx, 0), len(xp) - 2)
+
+            intidxs.append(intidx)
+            xs.append(x)
+            xps.append(xp)
+
+        # Bepaal de tijdsduur van het eerste en het laatste blokje uit de golfvorm
+        block_duration = tijden[1] - tijden[0]
+        eindduur = tijden[-1] - tijden[-2]
+
+        # Alloceer arrays. Het is sneller om in de loop de arrays over te schrijven dan om ze opnieuw aan te maken
+        ondkanstot = np.ones(exceedance_probability.shape)
+        blokondkans = np.zeros(exceedance_probability.shape)
+        ovkansen = np.zeros(exceedance_probability.shape)
+
+        nt = len(tijden)
+
+        for it in range(nt - 1):
+            # Interpoleer de overschrijdingskansen
+            if len(slow_stochastics) == 1:
+                # Bepaal de index van de interpolatiewaarden (afvoeren / meerpeil) voor de betreffende tijdstap
+                iix = intidxs[0][it]
+
+                # Bepaal de fracties van de fp waarden obv xp, die moet worden ingevuld voor f (obv x)
+                fracs = (x[it] - xp[iix]) / (xp[iix + 1] - xp[iix])
+
+                # Bepaal de vorm van de output array, dit is (Ntraag, Ntijd, Nderest1, Nderest2, ...)
+                fracshp = fracs.shape + (1,) * (fp.ndim - 1)
+
+                # Interpoleer alle overschrijdingskansen in één keer door de fracties met de resultaatwaarden (fp) te vermenigvuldigen
+                ovkansen[:] = (1 - fracs.reshape(fracshp)) * fp[iix] + fp[
+                    iix + 1
+                ] * fracs.reshape(fracshp)
+
+            elif len(slow_stochastics) == 2:
+                iix1 = intidxs[0][it]
+                iix2 = intidxs[1][it]
+
+                # Bepaal de fracties van de fp waarden obv xp, die moet worden ingevuld voor f (obv x)
+                fracs1 = (xs[0][it] - xps[0][iix1]) / (xps[0][iix1 + 1] - xps[0][iix1])
+                fracs2 = (xs[1][it] - xps[1][iix2]) / (xps[1][iix2 + 1] - xps[1][iix2])
+
+                # Bepaal de vorm van de output array, dit is (Ntraag, Ntijd, Nderest1, Nderest2, ...)
+                frac2shp = fracs2.shape + (1,) * (fp.ndim - 2)
+
+                # 2D interpolatie
+                # Merk op dat dit via een loop gaat. Dit is sneller dan in enkele array-operaties, omdat
+                # de arrays zo groot zijn dat fancy-indexing traag wordt
+                for i, (ix, ixp1) in enumerate(zip(iix1, iix1 + 1)):
+                    # Interpoleer eerst over de eerste stochast
+                    fy1 = (1 - fracs1[i]) * fp[ix][iix2] + fp[ixp1][iix2] * fracs1[i]
+                    fy2 = (1 - fracs1[i]) * fp[ix][iix2 + 1] + fp[ixp1][
+                        iix2 + 1
+                    ] * fracs1[i]
+
+                    # Interpoleer de tweede stochast
+                    ovkansen[i] = fy1 + (fy2 - fy1) * fracs2.reshape(frac2shp)
+
+                # fy1 = (1 - fracs1.reshape(frac1shp)) * fp[np.ix_(iix1, iix2  )] + fp[np.ix_(iix1+1, iix2  )] * fracs1.reshape(frac1shp)
+                # fy2 = (1 - fracs1.reshape(frac1shp)) * fp[np.ix_(iix1, iix2+1)] + fp[np.ix_(iix1+1, iix2+1)] * fracs1.reshape(frac1shp)
+
+            # Door het interpoleren kunnen overschrijdingskansen gecreëerd worden, die een fractie groter zijn dan 1.0
+            ovkansen[:] = np.minimum(ovkansen, 1.0)
+
+            # De berekende overschrijdingskansen gelden voor een blokje met de duur, die gelijk is
+            # aan de door de gebruiker gekozen block_duration van de wind. Voor het discretiseren van de
+            # golfvormen heeft de gebuiker een andere duur opgegeven. De bovenstaande overschrijdings-
+            # kansen worden hiervoor gecorrigeerd
+            if block_duration != statistics.wind_speed.block_duration_wind:
+                ovkansen[:] = 1.0 - (1.0 - ovkansen) ** (
+                    block_duration / statistics.wind_speed.block_duration_wind
+                )
+
+            # Bereken de onderschrijdingskans voor de basisduur gebruikmakend van de overschrijdingskansen per blokje
+            # Factoren zijn 1
+            blokondkans[:] = 1.0 - ovkansen
+
+            # Eerste blok is half
+            if it == 0:
+                blokondkans[:] **= 0.5
+
+            # Neem het voorlaatste en laatste blok samen
+            if it == (nt - 1):
+                # Als de eindduur kleiner is dan een halve block_duration, dan is de factor kleiner dan 1
+                if eindduur < (0.5 * block_duration):
+                    factor = ((0.5 * block_duration) + eindduur) / block_duration
+                    blokondkans[:] **= factor
+
+                # Als de eindduur groter of even lang is als een halve block_duration
+                else:
+                    # Vermenig de block_duration ook nog met het laatste blokje
+                    factor = (eindduur - (block_duration / 2.0)) / block_duration
+                    blokondkans[:] *= (1.0 - ovkansen[:, :]) ** factor
+
+            ondkanstot *= blokondkans
+
+        # Return
+        return 1 - ondkanstot

pydra_core/location/model/wave_overtopping.py

@@ -0,0 +1,25 @@
+import numpy as np
+
+from .base_model import BaseModel
+from .loading.other_systems.loading_wave_overtopping import LoadingWaveOvertopping
+from .statistics.other_systems.statistics_wave_overtopping import (
+    StatisticsWaveOvertopping,
+)
+from ..location import Location
+
+
+class WaveOvertopping(BaseModel):
+    def __init__(
+        self, location: Location, water_levels: np.ndarray, probability: np.ndarray
+    ):
+        """
+        Wave Overtopping model
+        """
+        # Inherit
+        super().__init__(location.get_settings())
+
+        # Init statistics
+        self.statistics = StatisticsWaveOvertopping(location, water_levels, probability)
+
+        # Init loading
+        self.loading = LoadingWaveOvertopping(location, water_levels)

pydra_core/location/profile/foreland.py

@@ -0,0 +1,246 @@
+import numpy as np
+import os
+
+from ctypes import CDLL, POINTER, c_char_p, c_double, c_int, c_long, byref
+from numpy.ctypeslib import ndpointer
+from typing import Tuple
+
+
+class Foreland:
+    """
+    This module will use the Dam and Foreland module (DaF) to transform wave conditions
+    based on the schematized foreshore. The DaF module can be used to transform wave conditions
+    over a breakwater and/or foreshore.
+    """
+
+    def __init__(self, profile, log: bool = False):
+        # Path to the library
+        lib_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "lib"))
+
+        # Load the DaF library v20.1.1.692 (differ from Hydra-NL, there are some slight changes)
+        self.daf_library = CDLL(os.path.join(lib_path, "DynamicLib-DaF.dll"))
+
+        # Default settings
+        self.alpha_c = c_double(1.0)
+        self.fc_c = c_double(0.021)
+        self.ratiodepth_c = c_double(0.5)
+        self.minstepsize_c = c_double(1.0)
+        self.invalid_c = c_double(-999.99)
+        self.logging_c = c_int(int(log))
+        self.loggingfilename_c = c_char_p("dlldaf_log.txt".encode("utf-8"))
+        self.loggingfilenamelength_c = c_int(len(self.loggingfilename_c.value))
+        self.g_c = c_double(9.81)
+        self.rho_c = c_double(1000.0)
+
+        # Intialize dll entries
+        self.__initialize_dll_entries()
+
+        # Set profile
+        self.profile = profile
+
+    def add_profile(self, profile) -> None:
+        """
+        Set profile
+
+        Parameters
+        ----------
+        Profile : profile
+            A Profile object
+        """
+        self.profile = profile
+
+    def transform_wave_conditions(
+        self,
+        water_level: np.ndarray,
+        significant_wave_height: np.ndarray,
+        peak_wave_period: np.ndarray,
+        wave_direction: np.ndarray,
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Transform the wave conditions for the schematized foreland
+
+        Parameters
+        ----------
+        water_level : np.ndarray
+            Water level
+        significant_wave_height : np.ndarray
+            Significant wave height
+        peak_wave_period : np.ndarray
+            Peak wave period
+        wave_direction : np.ndarray
+            Wave direction
+
+        Returns
+        -------
+        Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]
+            Water level and transformed wave conditions (h, hs, tp, dir)
+        """
+        # Get size and shape
+        shp = significant_wave_height.shape
+
+        # Determine part where wave height is larger than zero
+        mask = (significant_wave_height > 0.0) & (peak_wave_period > 0.0)
+        N = mask.sum()
+
+        # Allocate output arrays as single dimension
+        hm0dike = np.zeros(N, order="F")
+        tpdike = np.zeros(N, order="F")
+        refractedwaveangledike = np.zeros(N, order="F")
+        message = "".ljust(1000).encode("utf-8")
+        messagelength = c_int(1000)
+        n_vl = (
+            len(self.profile.foreland_x_coordinates)
+            if self.profile.foreland_x_coordinates is not None
+            else 1
+        )
+        x_vl = (
+            np.array(self.profile.foreland_x_coordinates).astype(np.float64)
+            if self.profile.foreland_x_coordinates is not None
+            else np.array([0]).astype(np.float64)
+        )
+        y_vl = (
+            np.array(self.profile.foreland_y_coordinates).astype(np.float64)
+            if self.profile.foreland_x_coordinates is not None
+            else np.array([-999]).astype(np.float64)
+        )
+
+        res = self.daf_library.C_FORTRANENTRY_RollerModel5(
+            byref(c_int(self.profile.breakwater_type.value)),
+            byref(c_double(self.profile.breakwater_level)),
+            byref(self.alpha_c),
+            byref(self.fc_c),
+            byref(self.invalid_c),
+            byref(c_int(N)),
+            significant_wave_height[mask].astype(np.float64),
+            peak_wave_period[mask].astype(np.float64),
+            water_level[mask].astype(np.float64),
+            wave_direction[mask].astype(np.float64),
+            byref(c_double(self.profile.dike_orientation)),
+            byref(c_int(n_vl)),
+            x_vl,
+            byref(self.minstepsize_c),
+            y_vl,
+            byref(self.ratiodepth_c),
+            byref(self.logging_c),
+            self.loggingfilename_c,
+            self.loggingfilenamelength_c,
+            byref(self.g_c),
+            byref(self.rho_c),
+            hm0dike,
+            tpdike,
+            refractedwaveangledike,
+            message,
+            messagelength,
+        )
+        message = message.decode("utf-8")
+        message = message.rstrip()
+        messagelength = len(message)
+
+        if res != 0:
+            print(message + " - Using uncorrected wave parameters.")
+            print(self.profile.foreland_x_coordinates)
+            print(self.profile.foreland_y_coordinates)
+            hm0dike[:] = significant_wave_height[mask].ravel()[:]
+            tpdike[:] = peak_wave_period[mask].ravel()[:]
+            refractedwaveangledike[:] = wave_direction[mask].ravel()[:]
+
+        # If not all input conditions were non-zero, put the calculated conditions on the original grid again.
+        if not mask.all():
+            # Copy original values
+            hm0_tmp, tp_tmp, wdir_tmp = (
+                significant_wave_height.copy(),
+                peak_wave_period.copy(),
+                wave_direction.copy(),
+            )
+
+            # Insert calculated values
+            hm0_tmp[mask] = hm0dike
+            tp_tmp[mask] = tpdike
+            wdir_tmp[mask] = refractedwaveangledike
+            conditions = (water_level, hm0_tmp, tp_tmp, wdir_tmp % 360.0)
+
+        # Else, all values, where calculated. Only reshape to input shape
+        else:
+            conditions = (
+                water_level,
+                hm0dike.reshape(shp),
+                tpdike.reshape(shp),
+                refractedwaveangledike.reshape(shp) % 360.0,
+            )
+
+        # Return the transformed conditions
+        return conditions
+
+    def __initialize_dll_entries(self) -> None:
+        """
+        Initializes the arguments types of various functions in the dynamic library.
+        """
+        # get entry point in dll, the function to use
+        arraypointer = ndpointer(dtype="double", ndim=1, flags="F_CONTIGUOUS")
+
+        # Define all the argument types
+        argtypes = {
+            "DamType": POINTER(c_int),
+            "DamHeight": POINTER(c_double),
+            "Alpha": POINTER(c_double),
+            "Fc": POINTER(c_double),
+            "Invalid": POINTER(c_double),
+            "DimHm0": POINTER(c_int),
+            "Hm0": arraypointer,
+            "Tp": arraypointer,
+            "Wlev": arraypointer,
+            "IncomingWaveAngle": arraypointer,
+            "DikeNormal": POINTER(c_double),
+            "DimX": POINTER(c_int),
+            "X": arraypointer,
+            "MinStepSize": POINTER(c_double),
+            "BottomLevel": arraypointer,
+            "RatioDepth": POINTER(c_double),
+            "Logging": POINTER(c_int),
+            "LoggingFileName": c_char_p,
+            "LoggingFileNameLength": c_int,
+            "Ag": POINTER(c_double),
+            "Rho": POINTER(c_double),
+            "Hm0Dike": arraypointer,
+            "TpDike": arraypointer,
+            "RefractedWaveAngleDike": arraypointer,
+            "Message": c_char_p,
+            "MessageLength": c_int,
+        }
+
+        # Note function definition for DAF module ROLLERMODEL5
+        self.daf_library.C_FORTRANENTRY_RollerModel5.restype = c_long
+        self.daf_library.C_FORTRANENTRY_RollerModel5.argtypes = [
+            argtypes[name]
+            for name in [
+                "DamType",
+                "DamHeight",
+                "Alpha",
+                "Fc",
+                "Invalid",
+                "DimHm0",
+                "Hm0",
+                "Tp",
+                "Wlev",
+                "IncomingWaveAngle",
+                "DikeNormal",
+                "DimX",
+                "X",
+                "MinStepSize",
+                "BottomLevel",
+                "RatioDepth",
+                "Logging",
+                "LoggingFileName",
+                "LoggingFileNameLength",
+                "Ag",
+                "Rho",
+                "Hm0Dike",
+                "TpDike",
+                "RefractedWaveAngleDike",
+                "Message",
+                "MessageLength",
+            ]
+        ]
+
+        # Note function definition for DAF function to obtain version number.
+        self.daf_library.GetVersionInfo.argtypes = [c_char_p, c_int]