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

pydra_core/location/model/loading/loading_model/loading_model.py

@@ -0,0 +1,324 @@
+import numpy as np
+import pandas as pd
+
+from typing import Dict, Union
+
+from ....profile.profile import Profile
+from .....common.interpolate import InterpStruct
+
+
+class LoadingModel:
+    """
+    A LoadingModel is a model for one combination of wind direction and closing situation
+
+    The LoadingModel allows to process the data (e.g. extend, refine or repair)
+    """
+
+    def __init__(
+        self,
+        direction: float,
+        closing_situation: int,
+        input_variables: list,
+        result_variables: list,
+    ):
+        """
+        Init the LoadingModel.
+
+        Parameters
+        ----------
+        direction : float
+            Wind direction
+        closing_situation: int
+            Closing situation id
+        input_variables : list
+            The input variable symbols (e.q. [u, q])
+        result_variables : list
+            The result variable symbols (e.q. [h, hs, tp, tspec, dir])
+        """
+        # Save the arguments into the object
+        self.direction = direction
+        self.closing_situation = closing_situation
+        self.input_variables = input_variables
+        self.result_variables = result_variables
+
+    def initialise(self, table: pd.DataFrame) -> None:
+        """
+        Create a LoadingModel from a pandas DataFrame.
+
+        Parameters
+        ----------
+        table : pd.DataFrame
+            DataFrame with all input and output variables.
+        """
+        # Rename columns
+        if any(ivar not in table.columns for ivar in self.input_variables):
+            raise KeyError(
+                f"Not all input variables are present. Expected a column for each of: {', '.join(self.input_variables)}, got: {', '.join(table.columns.tolist())}."
+            )
+
+        # Add the discretisation of each input variable to the object
+        for key in self.input_variables:
+            setattr(self, key, np.sort(table[key].unique()))
+
+        # Init an empty grid for each result variable
+        shape = tuple([len(getattr(self, key)) for key in self.input_variables])
+        for var in self.result_variables:
+            setattr(self, var, np.full(shape, np.nan))
+
+        # Determine per input variabele where to put it into the results array
+        idxs = []
+        for key in self.input_variables:
+            idxlist = getattr(self, key).tolist()
+            idxs.append([idxlist.index(i) for i in table[key].array])
+
+        # Add the results to the result arrays
+        for rvid in self.result_variables:
+            arr = getattr(self, rvid)
+
+            # If the result variable is in the dataframe
+            if rvid in table.columns:
+                arr[tuple(idxs)] = table[rvid].to_numpy()
+
+            # Otherwise, translate tspec to tp, or tp to tspec
+            else:
+                if rvid == "tspec" and ("tp" in table.columns):
+                    arr[tuple(idxs)] = table["tp"] / 1.1
+                elif rvid == "tp" and ("tspec" in table.columns):
+                    arr[tuple(idxs)] = table["tspec"] * 1.1
+                else:
+                    raise KeyError(rvid)
+
+    def extend(
+        self,
+        input_variable: str,
+        grid: Union[list, np.ndarray],
+        include_bounds: bool = False,
+        merge_grid: bool = True,
+    ) -> None:
+        """
+        Extend the grid of the input variable and therefore also the output variables.
+
+        Parameters
+        ----------
+        input_variable : str
+            The name of the input variable.
+        grid : Union[list, np.ndarray]
+            The 1D grid values to which the input variable should be extended.
+        include_bounds : bool, optional
+            Whether or not to include values within the upper and lower bound of the input variable (default is False).
+        merge_grid : bool, optional
+            Whether or not to merge the new grid with the existing grid of the input variable (default is True).
+        """
+        # Haal de huidige discretisatie van de variabele op
+        xp = getattr(self, input_variable)
+        axis = self.input_variables.index(input_variable)
+
+        # If include_bounds = True, add values between the min and max, otherwise add all
+        if not include_bounds:
+            x = np.array(
+                [
+                    val
+                    for val in np.atleast_1d(grid)
+                    if not (xp.min() <= val <= xp.max())
+                ]
+            )
+
+        # If merge_grid, add the grid to the existing values
+        if merge_grid:
+            x = np.array(sorted(set(np.atleast_1d(grid)).union(xp)))
+
+        # If x is empty or the requested values are equal to those already present, continue
+        if not any(x) or np.array_equal(x, xp):
+            return None
+
+        # Extend all result variables
+        intstr = InterpStruct(x=x, xp=xp)
+        for resvar in self.result_variables:
+            # Obtain the result variable
+            arr = getattr(self, resvar)
+            if np.isnan(arr).any():
+                raise ValueError(
+                    f'[ERROR] NaN values ({np.isnan(arr).sum()}) in array "{resvar}" to interpolate.'
+                )
+
+            # Interpolate wave conditions
+            if resvar in ["hs", "tp", "tspec"]:
+                arr = np.maximum(0.0, intstr.interp(fp=arr, axis=axis))
+
+            # Interpoleer wave angle
+            elif resvar == "dir":
+                arr = intstr.interp_angle(fp=arr, axis=axis)
+
+            # Use of VZM, (TODO find out: interpolate between 0 and 1?)
+            elif resvar == "vzm":
+                arr = intstr.interp(fp=arr, axis=axis)
+
+            # Interpolate other values
+            else:
+                arr = intstr.interp(fp=arr, axis=axis)
+
+            # Add the extended result variable array back to the object
+            setattr(self, resvar, arr)
+
+        # Add the extended input variable back to the object
+        setattr(self, input_variable, x)
+
+    def refine(
+        self, result_variable: str, grid: Dict[str, Union[list, np.ndarray]]
+    ) -> np.ndarray:
+        """
+        Extend the grid of the input variable and therefore also the output variables.
+
+        Parameters
+        ----------
+        input_variable : str
+            The name of the input variable.
+        result_variable : str
+            The name of the output variable.
+        grid : Dict[str, Union[list, np.ndarray]]
+            Input variables with their corresponding grid to extend the result_variable to
+
+        Returns
+        -------
+        np.ndarray
+            The adjusted grid.
+        """
+        # Controleer of variabele aanwezig is
+        if result_variable not in self.result_variables:
+            raise KeyError(
+                f"[ERROR] Result variable '{result_variable}' not in loading model."
+            )
+
+        # Obtain the array from the result variable
+        belasting_int = getattr(self, result_variable)
+
+        # Loop over the different grid items
+        for inpvar, x in grid.items():
+            if inpvar not in self.input_variables:
+                raise KeyError(
+                    f"[ERROR] Input variable '{inpvar}' not in loading model ({', '.join(self.input_variables)})"
+                )
+
+            # Obtain the current grid and axis
+            xp = getattr(self, inpvar)
+            axis = self.input_variables.index(inpvar)
+
+            # If x and xp are equal, no interpolation needed
+            if np.array_equal(x, xp):
+                continue
+
+            # If all x in xp, just select the requested values
+            if np.isin(x, xp).all():
+                idx = np.isin(xp, x)
+                belasting_int = np.take(
+                    belasting_int, indices=np.where(idx)[0], axis=axis
+                )
+                continue
+
+            # If xp is just one value, duplicate
+            if len(xp) == 1:
+                belasting_int = np.tile(belasting_int, (1, 1, len(x)))
+                continue
+
+            # Interpolate
+            intstr = InterpStruct(x=x, xp=xp)
+
+            # Interpolate wave conditions
+            if result_variable in ["hs", "tp", "tspec"]:
+                belasting_int = np.maximum(
+                    0.0, intstr.interp(fp=belasting_int, axis=axis)
+                )
+
+            # Interpolate wave direction
+            elif result_variable == "dir":
+                belasting_int = intstr.interp_angle(fp=belasting_int, axis=axis)
+
+            # Use of VZM, (TODO find out: interpolate between 0 and 1?)
+            elif result_variable == "vzm":
+                belasting_int = intstr.interp(fp=belasting_int, axis=axis)
+
+            # Interpolate other values
+            else:
+                belasting_int = intstr.interp(fp=belasting_int, axis=axis)
+
+        # Return the interpolated array for the result variable
+        return belasting_int
+
+    def repair(
+        self,
+        input_variable: str,
+        result_variables: Union[str, list] = None,
+        epsilon: float = 1e-6,
+    ) -> None:
+        """
+        Make the result values of the given output variable monotonically increasing along the axis of a given input variable.
+
+        Parameters
+        ----------
+        input_variable : str
+            The name of the input variable along which the result values should be made monotonically increasing.
+        result_variables : Union[str, list]
+            The name of the output variable to be made monotonically increasing.
+        epsilon : float, optional
+            The minimum difference between the values of the repaired output variable (default is 1e-6).
+        """
+        # Obtain the relevant axis
+        axis = self.input_variables.index(input_variable)
+
+        # If no result variables are given, take all result variables in the model
+        if result_variables is None:
+            result_variables = self.result_variables
+
+        # Loop over the result variables
+        for var in np.atleast_1d(result_variables):
+            # Obtain the result variable grid
+            arr = getattr(self, var)
+            rows = [np.take(arr, indices=0, axis=axis)]
+
+            # Make monotonous increasing over the axis of the input_variable
+            for i in range(1, arr.shape[axis]):
+                last = rows[-1]
+                nxtt = np.take(arr, indices=i, axis=axis)
+                rows.append(np.maximum(last + epsilon, nxtt))
+
+            # Add the adjusted grid to the loadingmodel
+            setattr(self, var, np.stack(rows, axis=axis))
+
+    def calculate_hbn(
+        self, profile: Profile, qcrit: float, factor_hs: float, factor_tspec: float
+    ):
+        """
+        Add hbn result variables to each of the LoadingModels.
+        If 'hbn' is already defined, it will overwrite the old result variable.
+
+        Parameters
+        ----------
+        profile : Profile
+            The profile
+        qcrit : float
+            The critical discharge
+        factor_hs : float
+            Factor for the significant wave height, used for model uncertainty
+        factor_tspec : float
+            Factor for the spectral wave period, used for model uncertainty
+        """
+        # Controleer of de juiste resultaatwaarden aanwezig zijn
+        for resvar in ["h", "hs", "tspec", "dir"]:
+            if not hasattr(self, resvar):
+                raise KeyError(
+                    f"Resultaatvariabele '{resvar}' is nodig voor kruinhoogteberekening, maar niet aanwezig."
+                )
+
+        # Prepare wave conditions
+        _h = self.h.ravel()
+        _hs = np.array(self.hs * factor_hs).ravel()
+        _tspec = np.array(self.tspec * factor_tspec).ravel()
+        _dir = np.array(self.dir).ravel()
+
+        # Calculate HBN
+        self.hbn = np.reshape(
+            [profile.calculate_crest_level(qcrit, _h, _hs, _tspec, _dir)], self.h.shape
+        )
+
+        # Add the result variable
+        self.result_variables.append("hbn")

pydra_core/location/model/loading/other_systems/loading_wave_overtopping.py

@@ -0,0 +1,122 @@
+import numpy as np
+import pandas as pd
+
+from itertools import product
+
+from ..loading import Loading
+from ..loading_model.loading_model import LoadingModel
+from ....location import Location
+from ....profile.profile import Profile
+
+
+class LoadingWaveOvertopping(Loading):
+    """
+    This Loading is used to calculate HBNs
+    """
+
+    def __init__(self, location: Location, ws_range: np.ndarray):
+        """
+        Init the Loading object for the Waves Overtopping
+
+        Parameters
+        ----------
+        settings : Settings
+            The Settings object
+        """
+        # Inherit the from parent
+        super().__init__(location.get_settings())
+
+        # Init
+        self.ws_loading = location.get_model().get_loading()
+        self.ws_range = ws_range
+        self.read_loading()
+
+    def read_loading(self) -> None:
+        """
+        Read the HR and create Loading Models
+        """
+        # Bepaal bij welke waterstanden de golfcondities afgeleid moeten worden
+        # Wanneer het aantal unieke waterstanden kleiner is dan het aantal waterstanden
+        # in het opgegeven bereik, worden de unieke waterstanden gebruikt
+        ws_per_r = self.bepaal_kh_waterstanden(self.ws_loading, self.ws_range)
+
+        # Bepaal de golfcondities bij deze waterstanden
+        for richting, waterstanden in ws_per_r.items():
+            # Leidt golfcondities af voor een bepaalde richting
+            golfcond_r, windsnelheden = self.ws_loading.get_wave_conditions(
+                richting, waterstanden, extrapolate=True
+            )
+
+            # Create a DataFrame
+            df = pd.DataFrame(columns=["wlev", "u"] + list(golfcond_r.keys()))
+
+            # Iterate over the windspeed and waterlevel arrays
+            ws_u = np.array(list(product(waterstanden, windsnelheden)))
+            golf = np.array(
+                [golfcond_r[key].ravel() for key in list(golfcond_r.keys())]
+            ).T
+            df = pd.DataFrame(
+                np.concatenate((ws_u, golf), axis=1),
+                columns=["wlev", "u"] + list(golfcond_r.keys()),
+            )
+
+            # Create a Loading Model
+            model = LoadingModel(richting, None, ["wlev", "u"], list(golfcond_r.keys()))
+            model.initialise(df)
+
+            # Save the model
+            self.model[(richting, model.closing_situation)] = model
+
+        # Extend the loading models
+        self._extend_loadingmodels()
+
+    def calculate_hbn(
+        self,
+        profile: Profile,
+        qcrit: float = 10,
+        factor_hs: float = 1.0,
+        factor_tspec: float = 1.0,
+    ) -> None:
+        """
+        Add hbn result variables to each of the LoadingModels.
+        If 'hbn' is already defined, it will overwrite the old result variable.
+
+        Parameters
+        ----------
+        profile : Profile
+            The profile
+        qcrit : float
+            The critical discharge
+        factor_hs : float
+            Factor for the significant wave height, used for model uncertainty
+        factor_tspec : float
+            Factor for the spectral wave period, used for model uncertainty
+        """
+        for _, model in self.iter_models():
+            model.calculate_hbn(profile, qcrit, factor_hs, factor_tspec)
+
+    def bepaal_kh_waterstanden(self, ws_belasting, ws_range):
+        """
+        Bepaal waterstanden waarvoor kruinhoogtes berekend moeten worden.
+
+        Per richting wordt bepaald of het aantal unieke waterstanden
+        kleiner is dan het aantal waterstanden in een gediscretiseerde range.
+
+        Als dit het geval is, kies de unieke waterstanden. Zo niet, gebruik de range.
+        """
+        ws_per_r = {r: [] for r in ws_belasting.r}
+        for (richting, _), model in ws_belasting.iter_models():
+            ws_per_r[richting] += np.unique(model.h).tolist()
+
+        for richting, waterstanden in ws_per_r.items():
+            h_all = np.array(waterstanden)[
+                np.unique(np.round(waterstanden, 3), return_index=True)[1]
+            ]
+            # Als er minder waterstanden voorkomen bij deze richting, dan de voorgenomen
+            # range, kies dan deze waterstanden
+            if len(h_all) <= len(ws_range):
+                ws_per_r[richting] = h_all
+            else:
+                ws_per_r[richting] = ws_range
+
+        return ws_per_r

pydra_core/location/model/loading/water_systems/loading_coast.py

@@ -0,0 +1,54 @@
+from ..loading import Loading
+from ..loading_model.loading_model import LoadingModel
+from ....settings.settings import Settings
+from .....io.database_hr import DatabaseHR
+
+
+class LoadingCoast(Loading):
+    """
+    Loading class for the Coast
+    Water systems: Coast (North, Central, South), Waddensea (West, East) and Western scheldt
+    """
+
+    def __init__(self, settings: Settings):
+        """
+        Init the Loading object for the Coast
+
+        Parameters
+        ----------
+        settings : Settings
+            The Settings object
+        """
+        # Inherit the from parent
+        super().__init__(settings)
+
+        # Read and process the loading
+        self.read_loading()
+
+    def read_loading(self) -> None:
+        """
+        Read the HR result table and create LoadingModels
+        """
+        # Read table
+        with DatabaseHR(self.settings.database_path) as database:
+            table = database.get_result_table(self.settings)
+            ivids = database.get_input_variables()
+            rvids = database.get_result_variables()
+
+        # For the coast, the sea level (m) is equal to the local water level (h)
+        table["h"] = table["m"]
+
+        # Init LoadingModels for each combination of wind direction (r) and closing situation (k)
+        for comb, deeltabel in table.groupby(["r", "k"]):
+            direction, closing_situation = comb
+
+            # Create a LoadingModel
+            model = LoadingModel(direction, closing_situation, ivids, rvids)
+            model.initialise(deeltabel.copy())
+
+            # Add model to the models dictionary
+            self.model[comb] = model
+
+        # Extend and repair loadingmodels
+        self._extend_loadingmodels()
+        self.repair_loadingmodels(rvids)

pydra_core/location/model/loading/water_systems/loading_eastern_scheldt.py

@@ -0,0 +1,169 @@
+import numpy as np
+import pandas as pd
+
+from itertools import product
+from scipy.interpolate import interp1d
+
+from ..loading import Loading
+from ..loading_model.loading_model import LoadingModel
+from ....settings.settings import Settings
+from .....common.interpolate import InterpStruct
+from .....io.database_hr import DatabaseHR
+
+
+class LoadingEasternScheldt(Loading):
+    """
+    Loading class for the EasternScheldt
+    Water systems: Eastern Scheldt
+    """
+
+    def __init__(self, settings: Settings):
+        """
+        Init the Loading object for the Eastern Scheldt
+
+        Parameters
+        ----------
+        settings : Settings
+            The Settings object
+        """
+        # Inherit the from parent
+        super().__init__(settings)
+
+        # Read and process the loading
+        self.read_loading()
+
+    def read_loading(self) -> None:
+        """
+        Read the HR result table and create LoadingModels
+        """
+        # Read table
+        with DatabaseHR(self.settings.database_path) as database:
+            waterlevels, waveconditions = database.get_result_table_eastern_scheldt(
+                self.settings
+            )
+            ivids = database.get_input_variables()
+            rvids = database.get_result_variables()
+
+        # Remove the 'm_os' from the ivids (two times m/m_os because m is used in the wave conditions)
+        ivids.remove("m_os")
+
+        # The water level and wave conditions are based on different grids
+        # Repair water level
+        for richting, snelheid in product(
+            np.unique(waveconditions["r"]), np.unique(waveconditions["u"])
+        ):
+            # Kijk of deze combi bestaat
+            if (
+                waterlevels["r"].eq(richting) & waterlevels["u"].eq(snelheid)
+            ).sum() == 0:
+                _format = waterlevels[
+                    waterlevels["r"].eq(richting) & waterlevels["u"].eq(0)
+                ].copy()
+                _format.loc[:, "u"] = snelheid
+                _format.loc[:, "h"] = np.NaN
+                waterlevels = pd.concat([waterlevels, _format], ignore_index=True)
+
+        # Repareer Hs
+        for richting, snelheid in product(
+            np.unique(waterlevels["r"]), np.unique(waterlevels["u"])
+        ):
+            # Kijk of deze combi bestaat
+            if (
+                waveconditions["r"].eq(richting) & waveconditions["u"].eq(snelheid)
+            ).sum() == 0:
+                _format = waveconditions[
+                    waveconditions["r"].eq(richting) & waveconditions["u"].eq(0)
+                ].copy()
+                _format.loc[:, "u"] = snelheid
+                _format.loc[:, "hs"] = np.NaN
+                _format.loc[:, "tp"] = np.NaN
+                _format.loc[:, "tspec"] = np.NaN
+                _format.loc[:, "dir"] = np.NaN
+                waveconditions = pd.concat([waveconditions, _format], ignore_index=True)
+
+        # Sorteer
+        waterlevels = waterlevels.sort_values(by=["k", "r", "m", "d", "p", "u"])
+        waterlevels = waterlevels.reset_index(drop=True)
+        waveconditions = waveconditions.sort_values(by=["r", "h", "u"])
+        waveconditions = waveconditions.reset_index(drop=True)
+
+        # Fix water levels
+        missing_h_index = waterlevels[waterlevels["h"].isna()].index
+        waterlevels.loc[missing_h_index, "h"] = np.around(
+            waterlevels.loc[missing_h_index - 1, "h"].to_numpy()
+            + (
+                waterlevels.loc[missing_h_index, "u"].to_numpy()
+                - waterlevels.loc[missing_h_index - 1, "u"].to_numpy()
+            )
+            * (
+                (
+                    waterlevels.loc[missing_h_index + 1, "h"].to_numpy()
+                    - waterlevels.loc[missing_h_index - 1, "h"].to_numpy()
+                )
+                / (
+                    waterlevels.loc[missing_h_index + 1, "u"].to_numpy()
+                    - waterlevels.loc[missing_h_index - 1, "u"].to_numpy()
+                )
+            ),
+            4,
+        )
+
+        # Vul de NaNs golfcondities
+        for n, row in waveconditions[waveconditions["hs"].isna()].iterrows():
+            wd = row["r"]
+            wl = row["h"]
+            ws = row["u"]
+            grid = waveconditions[
+                waveconditions["r"].eq(wd) & waveconditions["h"].eq(wl)
+            ].dropna()
+            waveconditions.loc[n, "hs"] = round(
+                float(interp1d(grid["u"], grid["hs"], fill_value="extrapolate")(ws)), 4
+            )
+            waveconditions.loc[n, "tp"] = round(
+                float(interp1d(grid["u"], grid["tp"], fill_value="extrapolate")(ws)), 4
+            )
+            waveconditions.loc[n, "tspec"] = round(
+                float(interp1d(grid["u"], grid["tspec"], fill_value="extrapolate")(ws)),
+                4,
+            )
+
+            # Niet de wave direction extrapoleren
+            if np.min(grid["u"]) <= ws and ws <= np.max(grid["u"]):
+                waveconditions.loc[n, "dir"] = round(
+                    float(interp1d(grid["u"], grid["dir"])(ws)), 4
+                )
+            elif ws > np.max(grid["u"]):
+                waveconditions.loc[n, "dir"] = grid["dir"].to_numpy()[-1]
+            elif ws < np.min(grid["u"]):
+                waveconditions.loc[n, "dir"] = grid["dir"].to_numpy()[0]
+
+        # Interpoleer de golfcondities op de waterstanden, alvorens ze aan de belastingmodellen toe te voegen
+        for (richting, snelheid), wavecond_ur in waveconditions.groupby(["r", "u"]):
+            # Maak een index voor de selectie van windrichting en windsnelheid
+            idx = waterlevels["r"].eq(richting) & waterlevels["u"].eq(snelheid)
+
+            # Maak een interpolatiestructuur voor de windrichting en windsnelheid
+            intstr = InterpStruct(
+                x=waterlevels.loc[idx, "h"].to_numpy(), xp=wavecond_ur["h"].to_numpy()
+            )
+
+            # Interpoleer voor elk van de golfparameters
+            for param in ["hs", "tp", "tspec", "dir"]:
+                waterlevels.loc[idx, param] = intstr.interp(
+                    fp=wavecond_ur[param].to_numpy()
+                )
+
+        # Init LoadingModels for each combination of wind direction (r) and closing situation (k)
+        for comb, deeltabel in waterlevels.groupby(["r", "k"]):
+            direction, closing_situation = comb
+
+            # Create a LoadingModel
+            model = LoadingModel(direction, closing_situation, ivids, rvids)
+            model.initialise(deeltabel.copy())
+
+            # Add model to the models dictionary
+            self.model[comb] = model
+
+        # Breidt het belastingmodel uit op basis van de invoergegevens
+        self._extend_loadingmodels()
+        self.repair_loadingmodels(rvids)