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

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

@@ -1,68 +1,68 @@
-from ..loading import Loading
-from ..loading_model.loading_model import LoadingModel
-from ....settings.settings import Settings
-from .....io.database_hr import DatabaseHR
-
-
-class LoadingLowerRiver(Loading):
-    """
-    Loading class for Lower Rivers
-    Water systems: Tidal River Rhine, Tidal River Meuse
-    """
-
-    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)
-            rvids = database.get_result_variables()
-            ivids_west = database.get_input_variables()
-
-        # For lower tidal rivers, there is a different loading model for sector east and west
-        ivids_east = ivids_west.copy()
-        ivids_east.remove("m")
-
-        # Init LoadingModels for each combination of wind direction (r) and closing situation (k)
-        for comb, deeltabel in table.groupby(["r", "k"]):
-            wind_direction, closing_situation = comb
-
-            # Sector west
-            if ((wind_direction >= 0.0) and (wind_direction <= 11.25)) or (
-                (wind_direction > 212.75) and (wind_direction <= 360.0)
-            ):
-                model = LoadingModel(
-                    wind_direction, closing_situation, ivids_west, rvids
-                )
-
-            # Sector east
-            else:
-                model = LoadingModel(
-                    wind_direction, closing_situation, ivids_east, rvids
-                )
-
-            # Init loading model
-            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)
+from ..loading import Loading
+from ..loading_model.loading_model import LoadingModel
+from ....settings.settings import Settings
+from .....io.database_hr import DatabaseHR
+
+
+class LoadingLowerRiver(Loading):
+    """
+    Loading class for Lower Rivers
+    Water systems: Tidal River Rhine, Tidal River Meuse
+    """
+
+    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)
+            rvids = database.get_result_variables()
+            ivids_west = database.get_input_variables()
+
+        # For lower tidal rivers, there is a different loading model for sector east and west
+        ivids_east = ivids_west.copy()
+        ivids_east.remove("m")
+
+        # Init LoadingModels for each combination of wind direction (r) and closing situation (k)
+        for comb, deeltabel in table.groupby(["r", "k"]):
+            wind_direction, closing_situation = comb
+
+            # Sector west
+            if ((wind_direction >= 0.0) and (wind_direction <= 11.25)) or (
+                (wind_direction > 212.75) and (wind_direction <= 360.0)
+            ):
+                model = LoadingModel(
+                    wind_direction, closing_situation, ivids_west, rvids
+                )
+
+            # Sector east
+            else:
+                model = LoadingModel(
+                    wind_direction, closing_situation, ivids_east, rvids
+                )
+
+            # Init loading model
+            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_upper_river.py

@@ -1,55 +1,55 @@
-from ..loading import Loading
-from ..loading_model.loading_model import LoadingModel
-from ....settings.settings import Settings
-from .....io.database_hr import DatabaseHR
-
-
-class LoadingUpperRiver(Loading):
-    """
-    Loading class for the Upper Rivers
-    Water systems: Rhine Non Tidal and Meuse (Valley) Non Tidal
-    """
-
-    def __init__(self, settings: Settings):
-        """
-        Init the Loading object for the Upper Rivers
-
-        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()
-
-        # Check if there are wave conditions present or whether they should be derived with Bretschneider
-        if "hs" not in table.columns:
-            raise NotImplementedError("[ERROR] Bretschneider")
-
-        # 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)
+from ..loading import Loading
+from ..loading_model.loading_model import LoadingModel
+from ....settings.settings import Settings
+from .....io.database_hr import DatabaseHR
+
+
+class LoadingUpperRiver(Loading):
+    """
+    Loading class for the Upper Rivers
+    Water systems: Rhine Non Tidal and Meuse (Valley) Non Tidal
+    """
+
+    def __init__(self, settings: Settings):
+        """
+        Init the Loading object for the Upper Rivers
+
+        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()
+
+        # Check if there are wave conditions present or whether they should be derived with Bretschneider
+        if "hs" not in table.columns:
+            raise NotImplementedError("[ERROR] Bretschneider")
+
+        # 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/statistics/other_systems/statistics_wave_overtopping.py

@@ -1,72 +1,72 @@
-import numpy as np
-
-from ..statistics import Statistics
-from ....location import Location
-
-
-class StatisticsWaveOvertopping(Statistics):
-    def __init__(
-        self, location: Location, water_levels: np.ndarray, probability: np.ndarray
-    ):
-        """
-        Init the Statistics class for the Eastern Scheldt
-
-        Parameters
-        ----------
-        settings : Settings
-            The Settings object
-        """
-        # Inherit initialisation method from parent
-        super().__init__(location.get_settings())
-
-        # Init [wlev, u, xtr1, xtr2, ..., r]
-        self.probability = probability
-
-        #  Discrete, slow, fast stochatics
-        self.stochastics_discrete = {
-            "r": location.get_model().get_statistics().stochastics_discrete["r"]
-        }
-        self.stochastics_fast = {
-            "wlev": water_levels,
-            "u": location.get_model().get_statistics().stochastics_fast["u"],
-        }
-        self.stochastics_slow = location.get_model().get_statistics().stochastics_slow
-
-        # Discretisation
-        discretisation = {
-            **self.stochastics_fast,
-            **self.stochastics_slow,
-            **self.stochastics_discrete,
-        }
-        self.dimensions = list(discretisation.keys())
-
-        # Check dimensions
-        for i, dim in enumerate(self.dimensions):
-            if probability.shape[i] != len(discretisation[dim]):
-                raise ValueError(
-                    f"kansen.shape[i] {probability.shape[i]} != len(discretisatie[{dim}]) ({len(discretisation[dim])})."
-                )
-            setattr(self, f"n{dim}", len(discretisation[dim]))
-
-    def calculate_probability(
-        self, wind_direction: float, closing_situation: int = 1, given: list = []
-    ) -> np.ndarray:
-        """
-        Return the probability of wlev, u, xtr1, xtr2 given the wind direction.
-
-        Parameters
-        ----------
-        wind_direction : float
-            The wind direction.
-        closing_situation : int, optional
-            The closing situation. Does not have any effect for
-            StatisticsWaveOvertopping (default is 0)
-        given : list, optional
-            Given variables. Does not have any effect for
-            StatisticsWaveOvertopping (default is 0)
-        """
-        # Obtain the wind direction id
-        ir = list(self.stochastics_discrete["r"]).index(wind_direction)
-
-        # Return the probability for this wind direction
-        return np.take(self.probability, indices=ir, axis=self.dimensions.index("r"))
+import numpy as np
+
+from ..statistics import Statistics
+from ....location import Location
+
+
+class StatisticsWaveOvertopping(Statistics):
+    def __init__(
+        self, location: Location, water_levels: np.ndarray, probability: np.ndarray
+    ):
+        """
+        Init the Statistics class for the Eastern Scheldt
+
+        Parameters
+        ----------
+        settings : Settings
+            The Settings object
+        """
+        # Inherit initialisation method from parent
+        super().__init__(location.get_settings())
+
+        # Init [wlev, u, xtr1, xtr2, ..., r]
+        self.probability = probability
+
+        #  Discrete, slow, fast stochatics
+        self.stochastics_discrete = {
+            "r": location.get_model().get_statistics().stochastics_discrete["r"]
+        }
+        self.stochastics_fast = {
+            "wlev": water_levels,
+            "u": location.get_model().get_statistics().stochastics_fast["u"],
+        }
+        self.stochastics_slow = location.get_model().get_statistics().stochastics_slow
+
+        # Discretisation
+        discretisation = {
+            **self.stochastics_fast,
+            **self.stochastics_slow,
+            **self.stochastics_discrete,
+        }
+        self.dimensions = list(discretisation.keys())
+
+        # Check dimensions
+        for i, dim in enumerate(self.dimensions):
+            if probability.shape[i] != len(discretisation[dim]):
+                raise ValueError(
+                    f"kansen.shape[i] {probability.shape[i]} != len(discretisatie[{dim}]) ({len(discretisation[dim])})."
+                )
+            setattr(self, f"n{dim}", len(discretisation[dim]))
+
+    def calculate_probability(
+        self, wind_direction: float, closing_situation: int = 1, given: list = []
+    ) -> np.ndarray:
+        """
+        Return the probability of wlev, u, xtr1, xtr2 given the wind direction.
+
+        Parameters
+        ----------
+        wind_direction : float
+            The wind direction.
+        closing_situation : int, optional
+            The closing situation. Does not have any effect for
+            StatisticsWaveOvertopping (default is 0)
+        given : list, optional
+            Given variables. Does not have any effect for
+            StatisticsWaveOvertopping (default is 0)
+        """
+        # Obtain the wind direction id
+        ir = list(self.stochastics_discrete["r"]).index(wind_direction)
+
+        # Return the probability for this wind direction
+        return np.take(self.probability, indices=ir, axis=self.dimensions.index("r"))