epyt-flow 0.10.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

epyt_flow/simulation/sensor_config.py

@@ -1992,8 +1992,24 @@ class SensorConfig(JsonSerializable):
                          bulk_species_link_concentrations: np.ndarray,
                          surface_species_concentrations: np.ndarray) -> np.ndarray:
         """
-        Applies the sensor configuration to a set of raw simulation results --
-         i.e. computes the sensor readings as an array.
+        Applies the sensor configuration to a set of raw simulation results -- i.e. computes
+        the sensor readings as an array.
+
+        Columns (i.e. sensor readings) are ordered as follows:
+
+            1. Pressures
+            2. Flows
+            3. Demands
+            4. Nodes quality
+            5. Links quality
+            6. Valve state
+            7. Pumps state
+            8. Pumps efficiency
+            9. Pumps energy consumption
+            10. Tanks volume
+            11. Surface species concentrations
+            12. Bulk species nodes concentrations
+            13. Bulk species links concentrations
 
         Parameters
         ----------

epyt_flow/topology.py

@@ -653,6 +653,22 @@ class NetworkTopology(nx.Graph, JsonSerializable):
 
         return bsr_array((np.ones(len(row)), (row, col)), shape=(n_nodes, n_nodes))
 
+    def get_adj_list(self) -> dict[str, list[str]]:
+        """
+        Returns the connectivity of the nodes (node IDs) as an adjacency list.
+
+        Returns
+        -------
+        `dict[str, list[str]]`
+            Adjacency list as a dictionary.
+        """
+        adj_list = {}
+
+        for node_id in self.get_all_nodes():
+            adj_list[node_id] = self.get_neighbors(node_id)
+
+        return adj_list
+
     def get_neighbors(self, node_id: str) -> list[str]:
         """
         Gets all neighboring nodes of a given node.

epyt_flow/uncertainty/model_uncertainty.py

@@ -1,6 +1,7 @@
 """
 Module provides a class for implementing model uncertainty.
 """
+from typing import Optional
 from copy import deepcopy
 import warnings
 import epyt
@@ -114,67 +115,31 @@ class ModelUncertainty(JsonSerializable):
         None, in the case of no uncertainty.
 
         The default is None.
+    seed : `int`, optional
+        Seed for the random number generator.
+
+        Thed default is None.
     """
-    def __init__(self, pipe_length_uncertainty: Uncertainty = None,
-                 pipe_roughness_uncertainty: Uncertainty = None,
-                 pipe_diameter_uncertainty: Uncertainty = None,
-                 base_demand_uncertainty: Uncertainty = None,
-                 demand_pattern_uncertainty: Uncertainty = None,
-                 elevation_uncertainty: Uncertainty = None,
-                 constants_uncertainty: Uncertainty = None,
-                 parameters_uncertainty: Uncertainty = None,
-                 global_pipe_length_uncertainty: Uncertainty = None,
-                 global_pipe_roughness_uncertainty: Uncertainty = None,
-                 global_pipe_diameter_uncertainty: Uncertainty = None,
-                 global_base_demand_uncertainty: Uncertainty = None,
-                 global_demand_pattern_uncertainty: Uncertainty = None,
-                 global_elevation_uncertainty: Uncertainty = None,
-                 global_constants_uncertainty: Uncertainty = None,
-                 global_parameters_uncertainty: Uncertainty = None,
-                 local_pipe_length_uncertainty: dict[str, Uncertainty] = None,
-                 local_pipe_roughness_uncertainty: dict[str, Uncertainty] = None,
-                 local_pipe_diameter_uncertainty: dict[str, Uncertainty] = None,
-                 local_base_demand_uncertainty: dict[str, Uncertainty] = None,
-                 local_demand_pattern_uncertainty: dict[str, Uncertainty] = None,
-                 local_elevation_uncertainty: dict[str, Uncertainty] = None,
-                 local_constants_uncertainty: dict[str, Uncertainty] = None,
-                 local_parameters_uncertainty: dict[str, int, Uncertainty] = None,
-                 local_patterns_uncertainty: dict[str, Uncertainty] = None,
-                 local_msx_patterns_uncertainty: dict[str, Uncertainty] = None,
+    def __init__(self, global_pipe_length_uncertainty: Optional[Uncertainty] = None,
+                 global_pipe_roughness_uncertainty: Optional[Uncertainty] = None,
+                 global_pipe_diameter_uncertainty: Optional[Uncertainty] = None,
+                 global_base_demand_uncertainty: Optional[Uncertainty] = None,
+                 global_demand_pattern_uncertainty: Optional[Uncertainty] = None,
+                 global_elevation_uncertainty: Optional[Uncertainty] = None,
+                 global_constants_uncertainty: Optional[Uncertainty] = None,
+                 global_parameters_uncertainty: Optional[Uncertainty] = None,
+                 local_pipe_length_uncertainty: Optional[dict[str, Uncertainty]] = None,
+                 local_pipe_roughness_uncertainty: Optional[dict[str, Uncertainty]] = None,
+                 local_pipe_diameter_uncertainty: Optional[dict[str, Uncertainty]] = None,
+                 local_base_demand_uncertainty: Optional[dict[str, Uncertainty]] = None,
+                 local_demand_pattern_uncertainty: Optional[dict[str, Uncertainty]] = None,
+                 local_elevation_uncertainty: Optional[dict[str, Uncertainty]] = None,
+                 local_constants_uncertainty: Optional[dict[str, Uncertainty]] = None,
+                 local_parameters_uncertainty: Optional[dict[str, int, Uncertainty]] = None,
+                 local_patterns_uncertainty: Optional[dict[str, Uncertainty]] = None,
+                 local_msx_patterns_uncertainty: Optional[dict[str, Uncertainty]] = None,
+                 seed: Optional[int] = None,
                  **kwds):
-        if pipe_length_uncertainty is not None:
-            global_pipe_diameter_uncertainty = pipe_length_uncertainty
-            warnings.warn("'pipe_length_uncertainty' is deprecated and " +
-                          "will be removed in future releases")
-        if pipe_roughness_uncertainty is not None:
-            global_pipe_roughness_uncertainty = pipe_roughness_uncertainty
-            warnings.warn("'pipe_roughness_uncertainty' is deprecated and " +
-                          "will be removed in future releases")
-        if pipe_diameter_uncertainty is not None:
-            global_pipe_diameter_uncertainty = pipe_diameter_uncertainty
-            warnings.warn("'pipe_diameter_uncertainty' is deprecated and " +
-                          "will be removed in future releases")
-        if base_demand_uncertainty is not None:
-            global_base_demand_uncertainty = base_demand_uncertainty
-            warnings.warn("'base_demand_uncertainty' is deprecated and " +
-                          "will be removed in future releases")
-        if demand_pattern_uncertainty is not None:
-            global_demand_pattern_uncertainty = demand_pattern_uncertainty
-            warnings.warn("'demand_pattern_uncertainty' is deprecated and " +
-                          "will be removed in future releases")
-        if elevation_uncertainty is not None:
-            global_elevation_uncertainty = elevation_uncertainty
-            warnings.warn("'elevation_uncertainty' is deprecated and " +
-                          "will be removed in future releases")
-        if constants_uncertainty is not None:
-            global_constants_uncertainty = constants_uncertainty
-            warnings.warn("'constants_uncertainty' is deprecated and " +
-                          "will be removed in future releases")
-        if parameters_uncertainty is not None:
-            global_parameters_uncertainty = parameters_uncertainty
-            warnings.warn("'parameters_uncertainty' is deprecated and " +
-                          "will be removed in future releases")
-
         if global_pipe_length_uncertainty is not None:
             if not isinstance(global_pipe_length_uncertainty, Uncertainty):
                 raise TypeError("'global_pipe_length_uncertainty' must be an instance of " +
@@ -337,9 +302,22 @@ class ModelUncertainty(JsonSerializable):
         self.__local_parameters = local_parameters_uncertainty
         self.__local_patterns = local_patterns_uncertainty
         self.__local_msx_patterns = local_msx_patterns_uncertainty
+        self.__seed = seed
 
         super().__init__(**kwds)
 
+    @property
+    def seed(self) -> int:
+        """
+        Returns the seed used for the random number generator.
+
+        Returns
+        -------
+        `int`
+            Seed for the random number generator.
+        """
+        return self.__seed
+
     @property
     def global_pipe_length(self) -> Uncertainty:
         """
@@ -574,7 +552,8 @@ class ModelUncertainty(JsonSerializable):
                    "local_constants_uncertainty": self.__local_constants,
                    "local_parameters_uncertainty": self.__local_parameters,
                    "local_patterns_uncertainty": self.__local_patterns,
-                   "local_msx_patterns_uncertainty": self.__local_msx_patterns}
+                   "local_msx_patterns_uncertainty": self.__local_msx_patterns,
+                   "seed": self.__seed}
 
         return super().get_attributes() | attribs
 
@@ -600,7 +579,8 @@ class ModelUncertainty(JsonSerializable):
             and self.__local_parameters == other.local_parameters \
             and self.__local_constants == other.local_constants \
             and self.__local_patterns == other.local_patterns \
-            and self.__local_msx_patterns == other.local_msx_patterns
+            and self.__local_msx_patterns == other.local_msx_patterns \
+            and self.__seed == other.seed
 
     def __str__(self) -> str:
         return f"global_pipe_length: {self.__global_pipe_length} " +\
@@ -620,7 +600,7 @@ class ModelUncertainty(JsonSerializable):
             f"local_constants: {self.__local_constants} " + \
             f"local_parameters: {self.__local_parameters} " + \
             f"local_patterns: {self.__local_patterns} " + \
-            f"local_msx_patterns: {self.__local_msx_patterns}"
+            f"local_msx_patterns: {self.__local_msx_patterns} + seed: {self.__seed}"
 
     def apply(self, epanet_api: epyt.epanet) -> None:
         """
@@ -631,12 +611,18 @@ class ModelUncertainty(JsonSerializable):
         epanet_api : `epyt.epanet <https://epanet-python-toolkit-epyt.readthedocs.io/en/stable/api.html#epyt.epanet.epanet>`_
             Interface to EPANET and EPANET-MSX.
         """
+        np_rand_gen = np.random.default_rng(seed=self.__seed)
+
         if self.__global_pipe_length is not None:
+            self.__global_pipe_length.set_random_generator(np_rand_gen)
+
             link_length = epanet_api.getLinkLength()
             link_length = self.__global_pipe_length.apply_batch(link_length)
             epanet_api.setLinkLength(link_length)
 
         if self.__local_pipe_length is not None:
+            self.__local_pipe_length.set_random_generator(np_rand_gen)
+
             for pipe_id, uncertainty in self.__local_pipe_length.items():
                 link_idx = epanet_api.getLinkIndex(pipe_id)
                 link_length = epanet_api.getLinkLength(link_idx)
@@ -644,11 +630,15 @@ class ModelUncertainty(JsonSerializable):
                 epanet_api.setLinkLength(link_idx, link_length)
 
         if self.__global_pipe_diameter is not None:
+            self.__global_pipe_diameter.set_random_generator(np_rand_gen)
+
             link_diameters = epanet_api.getLinkDiameter()
             link_diameters = self.__global_pipe_diameter.apply_batch(link_diameters)
             epanet_api.setLinkDiameter(link_diameters)
 
         if self.__local_pipe_diameter is not None:
+            self.__local_pipe_diameter.set_random_generator(np_rand_gen)
+
             for pipe_id, uncertainty in self.__local_pipe_diameter.items():
                 link_idx = epanet_api.getLinkIndex(pipe_id)
                 link_diameter = epanet_api.getLinkDiameter(link_idx)
@@ -656,11 +646,15 @@ class ModelUncertainty(JsonSerializable):
                 epanet_api.setLinkDiameter(link_idx, link_diameter)
 
         if self.__global_pipe_roughness is not None:
+            self.__global_pipe_roughness.set_random_generator(np_rand_gen)
+
             coeffs = epanet_api.getLinkRoughnessCoeff()
             coeffs = self.__global_pipe_roughness.apply_batch(coeffs)
             epanet_api.setLinkRoughnessCoeff(coeffs)
 
         if self.__local_pipe_roughness is not None:
+            self.__local_pipe_roughness.set_random_generator(np_rand_gen)
+
             for pipe_id, uncertainty in self.__local_pipe_roughness.items():
                 link_idx = epanet_api.getLinkIndex(pipe_id)
                 link_roughness_coeff = epanet_api.getLinkRoughnessCoeff(link_idx)
@@ -668,6 +662,8 @@ class ModelUncertainty(JsonSerializable):
                 epanet_api.setLinkRoughnessCoeff(link_idx, link_roughness_coeff)
 
         if self.__global_base_demand is not None:
+            self.__global_base_demand.set_random_generator(np_rand_gen)
+
             all_nodes_idx = epanet_api.getNodeIndex()
             for node_idx in all_nodes_idx:
                 n_demand_categories = epanet_api.getNodeDemandCategoriesNumber(node_idx)
@@ -677,6 +673,8 @@ class ModelUncertainty(JsonSerializable):
                     epanet_api.setNodeBaseDemands(node_idx, demand_category + 1, base_demand)
 
         if self.__local_base_demand is not None:
+            self.__local_base_demand.set_random_generator(np_rand_gen)
+
             for node_id, uncertainty in self.__local_base_demand.items():
                 node_idx = epanet_api.getNodeIndex(node_id)
                 n_demand_categories = epanet_api.getNodeDemandCategoriesNumber(node_idx)
@@ -686,6 +684,8 @@ class ModelUncertainty(JsonSerializable):
                     epanet_api.setNodeBaseDemands(node_idx, demand_category + 1, base_demand)
 
         if self.__global_demand_pattern is not None:
+            self.__global_demand_pattern.set_random_generator(np_rand_gen)
+
             demand_patterns_idx = epanet_api.getNodeDemandPatternIndex()
             demand_patterns_id = np.unique([demand_patterns_idx[k]
                                             for k in demand_patterns_idx.keys()])
@@ -699,6 +699,8 @@ class ModelUncertainty(JsonSerializable):
                     epanet_api.setPatternValue(pattern_id, t+1, v_)
 
         if self.__local_demand_pattern is not None:
+            self.__local_demand_pattern.set_random_generator(np_rand_gen)
+
             patterns_id = epanet_api.getPatternNameID()
             paterns_idx = epanet_api.getPatternIndex()
 
@@ -711,11 +713,15 @@ class ModelUncertainty(JsonSerializable):
                     epanet_api.setPatternValue(pattern_idx, t+1, v_)
 
         if self.__global_elevation is not None:
+            self.__global_elevation.set_random_generator(np_rand_gen)
+
             elevations = epanet_api.getNodeElevations()
             elevations = self.__global_elevation.apply_batch(elevations)
             epanet_api.setNodeElevations(elevations)
 
         if self.__local_elevation is not None:
+            self.__local_elevation.set_random_generator(np_rand_gen)
+
             for node_id, uncertainty in self.__local_elevation.items():
                 node_idx = epanet_api.getNodeIndex(node_id)
                 elevation = epanet_api.getNodeElevations(node_idx)
@@ -723,6 +729,8 @@ class ModelUncertainty(JsonSerializable):
                 epanet_api.setNodeElevations(node_idx, elevation)
 
         if self.__local_patterns is not None:
+            self.__local_patterns.set_random_generator(np_rand_gen)
+
             for pattern_id, uncertainty in self.__local_patterns.items():
                 pattern_idx = epanet_api.getPatternIndex(pattern_id)
                 pattern_length = epanet_api.getPatternLengths(pattern_idx)
@@ -733,11 +741,15 @@ class ModelUncertainty(JsonSerializable):
 
         if epanet_api.MSXFile is not None:
             if self.__global_constants is not None:
+                self.__global_constants.set_random_generator(np_rand_gen)
+
                 constants = np.array(epanet_api.getMSXConstantsValue())
                 constants = self.__global_constants.apply_batch(constants)
                 epanet_api.setMSXConstantsValue(constants)
 
             if self.__local_constants:
+                self.__local_constants.set_random_generator(np_rand_gen)
+
                 for constant_id, uncertainty in self.__local_constants.items():
                     idx = epanet_api.MSXgetindex(ToolkitConstants.MSX_CONSTANT, constant_id)
                     constant = epanet_api.msx.MSXgetconstant(idx)
@@ -745,6 +757,8 @@ class ModelUncertainty(JsonSerializable):
                     epanet_api.msx.MSXsetconstant(idx, constant)
 
             if self.__global_parameters is not None:
+                self.__global_parameters.set_random_generator(np_rand_gen)
+
                 parameters_pipes = epanet_api.getMSXParametersPipesValue()
                 for i, pipe_idx in enumerate(epanet_api.getLinkPipeIndex()):
                     if len(parameters_pipes[i]) == 0:
@@ -764,6 +778,8 @@ class ModelUncertainty(JsonSerializable):
                     epanet_api.setMSXParametersTanksValue(tank_idx, parameters_tanks_val)
 
             if self.__local_parameters is not None:
+                self.__local_parameters.set_random_generator(np_rand_gen)
+
                 for (param_id, item_type, item_id), uncertainty in self.__local_parameters.items():
                     idx, = epanet_api.getMSXParametersIndex([param_id])
 
@@ -780,6 +796,8 @@ class ModelUncertainty(JsonSerializable):
                     epanet_api.msx.MSXsetparameter(item_type, item_idx, idx, parameter)
 
             if self.__local_msx_patterns is not None:
+                self.__local_msx_patterns.set_random_generator(np_rand_gen)
+
                 for pattern_id, uncertainty in self.__local_msx_patterns.items():
                     pattern_idx, = epanet_api.getMSXPatternsIndex([pattern_id])
                     pattern = epanet_api.getMSXConstantsValue([pattern_idx])

epyt_flow/uncertainty/sensor_noise.py

@@ -1,10 +1,11 @@
 """
 Module provides a class for implementing sensor noise (e.g. uncertainty in sensor readings).
 """
+from typing import Optional, Callable
 from copy import deepcopy
 import warnings
-from typing import Callable
 import numpy
+from numpy.random import default_rng
 
 from .uncertainties import Uncertainty
 from ..serialization import serializable, JsonSerializable, SENSOR_NOISE_ID
@@ -25,11 +26,16 @@ class SensorNoise(JsonSerializable):
         Local (i.e. sensor specific) uncertainties.
         If None, no local sensor uncertainties are applied.
 
+        The default is None.
+    seed : `int`, optional
+        Seed for the random number generator.
+
         The default is None.
     """
-    def __init__(self, uncertainty: Uncertainty = None,
-                 global_uncertainty: Uncertainty = None,
-                 local_uncertainties: dict[int, str, Uncertainty] = None,
+    def __init__(self, uncertainty: Optional[Uncertainty] = None,
+                 global_uncertainty: Optional[Uncertainty] = None,
+                 local_uncertainties: Optional[dict[int, str, Uncertainty]] = None,
+                 seed: Optional[int] = None,
                  **kwds):
         if uncertainty is not None:
             global_uncertainty = uncertainty
@@ -53,6 +59,7 @@ class SensorNoise(JsonSerializable):
 
         self.__global_uncertainty = global_uncertainty
         self.__local_uncertainties = local_uncertainties
+        self.__np_rand_gen = default_rng(seed)
 
         super().__init__(**kwds)
 
@@ -118,6 +125,8 @@ class SensorNoise(JsonSerializable):
         if self.__local_uncertainties is None:
             return sensor_readings
         else:
+            self.__local_uncertainties.set_random_generator(self.__np_rand_gen)
+
             for (sensor_type, sensor_id), uncertainty in map_sensor_to_idx.items():
                 idx = map_sensor_to_idx(sensor_type, sensor_id)
                 sensor_readings[:, idx] = uncertainty.apply_batch(sensor_readings[:, idx])
@@ -145,4 +154,6 @@ class SensorNoise(JsonSerializable):
         if self.__global_uncertainty is None:
             return sensor_readings
         else:
+            self.__global_uncertainty.set_random_generator(self.__np_rand_gen)
+
             return self.__global_uncertainty.apply_batch(sensor_readings)

epyt_flow/uncertainty/uncertainties.py

@@ -2,7 +2,9 @@
 Module provides classes for implementing different types of uncertainties.
 """
 from abc import ABC, abstractmethod
+from copy import deepcopy
 import numpy as np
+from numpy.random import Generator, default_rng
 
 from .utils import generate_deep_random_gaussian_noise, create_deep_random_pattern
 from ..serialization import serializable, JsonSerializable, ABSOLUTE_GAUSSIAN_UNCERTAINTY_ID, \
@@ -34,6 +36,8 @@ class Uncertainty(ABC):
         self.__min_value = min_value
         self.__max_value = max_value
 
+        self._random_generator = default_rng()
+
     @property
     def min_value(self) -> float:
         """
@@ -58,6 +62,32 @@ class Uncertainty(ABC):
         """
         return self.__max_value
 
+    @property
+    def random_generator(self) -> Generator:
+        """
+        Returns the random number generator that is used for generating the uncertainties.
+
+        Returns
+        -------
+        `numpy.random.Generator <https://numpy.org/doc/stable/reference/random/generator.html#numpy.random.Generator>`_
+            The random number generator.
+        """
+        return deepcopy(self._random_generator)
+
+    def set_random_generator(self, np_rand_generator: Generator) -> None:
+        """
+        Sets the random number generator that is going to be used for generating the uncertainties.
+
+        Parameters
+        ----------
+        np_rand_generator : `numpy.random.Generator <https://numpy.org/doc/stable/reference/random/generator.html#numpy.random.Generator>`_, optional
+            The random number generator.
+
+            The default is the default BitGenerator (PCG64) as constructed by
+            `numpy.random.default_rng() <https://numpy.org/doc/stable/reference/random/generator.html#numpy.random.default_rng>`_.
+        """
+        self._random_generator = np_rand_generator
+
     def get_attributes(self) -> dict:
         """
         Gets all attributes to be serialized -- these attributes are passed to the
@@ -75,7 +105,8 @@ class Uncertainty(ABC):
             raise TypeError("Can not compare 'Uncertainty' instance " +
                             f"with '{type(other)}' instance")
 
-        return self.__min_value == other.min_value and self.__max_value == other.max_value
+        return self.__min_value == other.min_value and self.__max_value == other.max_value and \
+            self._random_generator == other.random_generator
 
     def __str__(self) -> str:
         return f"min_value: {self.__min_value} max_value: {self.__max_value}"
@@ -159,8 +190,8 @@ class GaussianUncertainty(Uncertainty):
     def __init__(self, mean: float = None, scale: float = None, **kwds):
         super().__init__(**kwds)
 
-        self.__mean = np.random.rand() if mean is None else mean
-        self.__scale = np.random.rand() if scale is None else scale
+        self._mean = mean
+        self._scale = scale
 
     @property
     def mean(self) -> float:
@@ -172,7 +203,7 @@ class GaussianUncertainty(Uncertainty):
         `float`
             Mean of the Gaussian noise.
         """
-        return self.__mean
+        return self._mean
 
     @property
     def scale(self) -> float:
@@ -184,20 +215,20 @@ class GaussianUncertainty(Uncertainty):
         `float`
             Scale (i.e. standard deviation) of the Gaussian noise.
         """
-        return self.__scale
+        return self._scale
 
     def get_attributes(self) -> dict:
-        return super().get_attributes() | {"mean": self.__mean, "scale": self.__scale}
+        return super().get_attributes() | {"mean": self._mean, "scale": self._scale}
 
     def __eq__(self, other) -> bool:
         if not isinstance(other, GaussianUncertainty):
             raise TypeError("Can not compare 'GaussianUncertainty' instance " +
                             f"with '{type(other)}' instance")
 
-        return super().__eq__(other) and self.__mean == other.mean and self.__scale == other.scale
+        return super().__eq__(other) and self._mean == other.mean and self._scale == other.scale
 
     def __str__(self) -> str:
-        return super().__str__() + f" mean: {self.__mean} scale: {self.__scale}"
+        return super().__str__() + f" mean: {self._mean} scale: {self._scale}"
 
 
 @serializable(ABSOLUTE_GAUSSIAN_UNCERTAINTY_ID, ".epytflow_uncertainty_absolute_gaussian")
@@ -206,7 +237,10 @@ class AbsoluteGaussianUncertainty(GaussianUncertainty, JsonSerializable):
     Class implementing absolute Gaussian uncertainty -- i.e. Gaussian noise is added to the data.
     """
     def apply(self, data: float) -> float:
-        data += np.random.normal(loc=self.mean, scale=self.scale)
+        self._mean = self._random_generator.rand() if self._mean is None else self._mean
+        self._scale = self._random_generator.rand() if self._scale is None else self._scale
+
+        data += self._random_generator.normal(loc=self._mean, scale=self._scale)
 
         return self.clip(data)
 
@@ -230,7 +264,9 @@ class RelativeGaussianUncertainty(GaussianUncertainty, JsonSerializable):
         super().__init__(mean=0., scale=scale, **kwds)
 
     def apply(self, data: float) -> float:
-        data += np.random.normal(loc=0, scale=self.scale)
+        self._scale = self._random_generator.rand() if self._scale is None else self._scale
+
+        data += self._random_generator.normal(loc=0, scale=self._scale)
 
         return self.clip(data)
 
@@ -300,7 +336,7 @@ class AbsoluteUniformUncertainty(UniformUncertainty, JsonSerializable):
     Class implementing absolute uniform uncertainty -- i.e. uniform noise is added to the data.
     """
     def apply(self, data: float) -> float:
-        data += np.random.uniform(low=self.low, high=self.high)
+        data += self._random_generator.uniform(low=self.low, high=self.high)
 
         return self.clip(data)
 
@@ -311,7 +347,7 @@ class RelativeUniformUncertainty(UniformUncertainty, JsonSerializable):
     Class implementing relative uniform uncertainty -- i.e. data is multiplied by uniform noise.
     """
     def apply(self, data: float) -> float:
-        data *= np.random.uniform(low=self.low, high=self.high)
+        data *= self._random_generator.uniform(low=self.low, high=self.high)
 
         return self.clip(data)
 
@@ -345,7 +381,7 @@ class PercentageDeviationUncertainty(UniformUncertainty, JsonSerializable):
         return super().get_attributes() | {"deviation_percentage": self.high - 1.}
 
     def apply(self, data: float) -> float:
-        data *= np.random.uniform(low=self.low, high=self.high)
+        data *= self._random_generator.uniform(low=self.low, high=self.high)
 
         return self.clip(data)
 
@@ -361,13 +397,18 @@ class DeepUniformUncertainty(Uncertainty):
 
     def __create_uncertainties(self, n_samples: int = 500):
         self._uncertainties_idx = 0
-        rand_low = create_deep_random_pattern(n_samples)
-        rand_high = create_deep_random_pattern(n_samples)
+        rand_low = create_deep_random_pattern(n_samples, np_rand_gen=self._random_generator)
+        rand_high = create_deep_random_pattern(n_samples, np_rand_gen=self._random_generator)
         rand_low = np.minimum(rand_low, rand_high)
         rand_high = np.maximum(rand_low, rand_high)
-        self._uncertainties = [np.random.uniform(low, high)
+        self._uncertainties = [self._random_generator.uniform(low, high)
                                for low, high in zip(rand_low, rand_high)]
 
+    def set_random_generator(self, np_rand_generator) -> None:
+        super().set_random_generator(np_rand_generator)
+
+        self.__create_uncertainties()
+
     @abstractmethod
     def apply(self, data: float) -> float:
         self._uncertainties_idx += 1
@@ -422,7 +463,13 @@ class DeepGaussianUncertainty(Uncertainty, JsonSerializable):
 
     def __create_uncertainties(self, n_samples: int = 500) -> None:
         self._uncertainties_idx = 0
-        self._uncertainties = generate_deep_random_gaussian_noise(n_samples, self.__mean)
+        self._uncertainties = generate_deep_random_gaussian_noise(n_samples, self.__mean,
+                                                                  np_rand_gen=self._random_generator)
+
+    def set_random_generator(self, np_rand_generator) -> None:
+        super().set_random_generator(np_rand_generator)
+
+        self.__create_uncertainties()
 
     @abstractmethod
     def apply(self, data: float) -> float:
@@ -505,6 +552,11 @@ class DeepUncertainty(Uncertainty):
         """
         return self.__max_noise_value
 
+    def set_random_generator(self, np_rand_generator) -> None:
+        super().set_random_generator(np_rand_generator)
+
+        self.__create_uncertainties()
+
     def get_attributes(self) -> dict:
         return super().get_attributes() | {"min_noise_value": self.__min_noise_value,
                                            "max_noise_value": self.__max_noise_value}
@@ -528,7 +580,8 @@ class DeepUncertainty(Uncertainty):
 
         self._uncertainties_idx = 0
         self._uncertainties = create_deep_random_pattern(n_samples, self.__min_noise_value,
-                                                         self.__max_noise_value, init_value)
+                                                         self.__max_noise_value, init_value,
+                                                         np_rand_gen=self._random_generator)
 
     @abstractmethod
     def apply(self, data: float) -> float: