epyt-flow 0.14.0__py3-none-any.whl → 0.14.2__py3-none-any.whl

epyt_flow/VERSION

@@ -1 +1 @@
-0.14.0
+0.14.2

epyt_flow/gym/scenario_control_env.py

@@ -23,6 +23,10 @@ class ScenarioControlEnv(ABC):
     autoreset : `bool`, optional
         If True, environment is automatically reset if terminated.
 
+        The default is False.
+    reapply_uncertainties_at_reset : `bool`, optional
+        If True, the uncertainties are re-applied to the original properties at each reset.
+
         The default is False.
 
     Attributes
@@ -36,7 +40,9 @@ class ScenarioControlEnv(ABC):
     _hydraulic_scada_data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData`, protected
         SCADA data from the hydraulic simulation -- only used if EPANET-MSX is used in the control scenario.
     """
-    def __init__(self, scenario_config: ScenarioConfig, autoreset: bool = False, **kwds):
+    def __init__(self, scenario_config: ScenarioConfig, autoreset: bool = False,
+                 reapply_uncertainties_at_reset: bool = False,
+                 **kwds):
         if not isinstance(scenario_config, ScenarioConfig):
             raise TypeError("'scenario_config' must be an instance of " +
                             "'epyt_flow.simulation.ScenarioConfig' " +
@@ -44,12 +50,15 @@ class ScenarioControlEnv(ABC):
         if not isinstance(autoreset, bool):
             raise TypeError("'autoreset' must be an instance of 'bool' " +
                             f"but not of '{type(autoreset)}'")
+        if not isinstance(reapply_uncertainties_at_reset, bool):
+            raise TypeError("")
 
         self._scenario_config = scenario_config
         self._scenario_sim = None
         self._sim_generator = None
         self.__autoreset = autoreset
         self._hydraulic_scada_data = None
+        self.__reapply_uncertainties_at_reset = reapply_uncertainties_at_reset
 
         super().__init__(**kwds)
 
@@ -65,6 +74,18 @@ class ScenarioControlEnv(ABC):
         """
         return self.__autoreset
 
+    @property
+    def reapply_uncertainties_at_reset(self) -> bool:
+        """
+        True, if the uncertainties are re-applied to the original properties at each reset.
+
+        Returns
+        -------
+        `bool`
+            True, if the uncertainties are re-applied to the original properties at each reset.
+        """
+        return self.__reapply_uncertainties_at_reset
+
     def __enter__(self):
         return self
 
@@ -117,14 +138,16 @@ class ScenarioControlEnv(ABC):
             # Run hydraulic simulation first
             hyd_export = os.path.join(get_temp_folder(), f"epytflow_env_MSX_{uuid.uuid4()}.hyd")
             sim = self._scenario_sim.run_hydraulic_simulation
-            self._hydraulic_scada_data = sim(hyd_export=hyd_export)
+            self._hydraulic_scada_data = sim(hyd_export=hyd_export,
+                                             reapply_uncertainties=self.__reapply_uncertainties_at_reset)
 
             # Run advanced quality analysis (EPANET-MSX) on top of the computed hydraulics
             gen = self._scenario_sim.run_advanced_quality_simulation_as_generator
             self._sim_generator = gen(hyd_export, support_abort=True)
         else:
             gen = self._scenario_sim.run_hydraulic_simulation_as_generator
-            self._sim_generator = gen(support_abort=True)
+            self._sim_generator = gen(support_abort=True,
+                                      reapply_uncertainties=self.__reapply_uncertainties_at_reset)
 
         return self._next_sim_itr()
 

epyt_flow/simulation/events/quality_events.py

@@ -64,7 +64,7 @@ class SpeciesInjectionEvent(SystemEvent, JsonSerializable):
 
         self.__species_id = species_id
         self.__node_id = node_id
-        self.__profile = profile
+        self._profile = profile
         self.__source_type = source_type
 
         super().__init__(**kwds)
@@ -103,7 +103,7 @@ class SpeciesInjectionEvent(SystemEvent, JsonSerializable):
         `numpy.ndarray`
             Pattern of the injection.
         """
-        return deepcopy(self.__profile)
+        return deepcopy(self._profile)
 
     @property
     def source_type(self) -> int:
@@ -125,17 +125,17 @@ class SpeciesInjectionEvent(SystemEvent, JsonSerializable):
 
     def get_attributes(self) -> dict:
         return super().get_attributes() | {"species_id": self.__species_id,
-                                           "node_id": self.__node_id, "profile": self.__profile,
+                                           "node_id": self.__node_id, "profile": self._profile,
                                            "source_type": self.__source_type}
 
     def __eq__(self, other) -> bool:
         return super().__eq__(other) and self.__species_id == other.species_id and \
-            self.__node_id == other.node_id and np.all(self.__profile == other.profile) and \
+            self.__node_id == other.node_id and np.all(self._profile == other.profile) and \
             self.__source_type == other.source_type
 
     def __str__(self) -> str:
         return f"{super().__str__()} species_id: {self.__species_id} " +\
-            f"node_id: {self.__node_id} profile: {self.__profile} source_type: {self.__source_type}"
+            f"node_id: {self.__node_id} profile: {self._profile} source_type: {self.__source_type}"
 
     def _get_pattern_id(self) -> str:
         return f"{self.__species_id}_{self.__node_id}"
@@ -160,7 +160,7 @@ class SpeciesInjectionEvent(SystemEvent, JsonSerializable):
         injection_time_start_idx = int(self.start_time / time_step)
 
         injection_pattern = None
-        if len(self.__profile) == injection_pattern_length:
+        if len(self._profile) == injection_pattern_length:
             injection_pattern = self.profile
         else:
             injection_pattern = np.tile(self.profile,

epyt_flow/simulation/events/sensor_faults.py

@@ -93,7 +93,7 @@ class SensorFaultConstant(SensorFault, JsonSerializable):
             raise TypeError("'constant_shift' must be an instance of 'float' but no of " +
                             f"'{type(constant_shift)}'")
 
-        self.__constant_shift = constant_shift
+        self._constant_shift = constant_shift
 
         super().__init__(**kwds)
 
@@ -107,20 +107,20 @@ class SensorFaultConstant(SensorFault, JsonSerializable):
         `float`
             Constant that is added to the sensor reading.
         """
-        return self.__constant_shift
+        return self._constant_shift
 
     def get_attributes(self) -> dict:
-        return super().get_attributes() | {"constant_shift": self.__constant_shift}
+        return super().get_attributes() | {"constant_shift": self._constant_shift}
 
     def __eq__(self, other) -> bool:
-        return super().__eq__(other) and self.__constant_shift == other.constant_shift
+        return super().__eq__(other) and self._constant_shift == other.constant_shift
 
     def __str__(self) -> str:
-        return f"{type(self).__name__} {super().__str__()} constant: {self.__constant_shift}"
+        return f"{type(self).__name__} {super().__str__()} constant: {self._constant_shift}"
 
     def apply_sensor_fault(self, cur_multiplier: float, sensor_reading: float,
                            cur_time: int) -> float:
-        return sensor_reading + cur_multiplier * self.__constant_shift
+        return sensor_reading + cur_multiplier * self._constant_shift
 
 
 @serializable(SENSOR_FAULT_DRIFT_ID, ".epytflow_sensorfault_drift")
@@ -134,7 +134,7 @@ class SensorFaultDrift(SensorFault, JsonSerializable):
         Coefficient of the drift.
     """
     def __init__(self, coef: float, **kwds):
-        self.__coef = coef
+        self._coef = coef
 
         super().__init__(**kwds)
 
@@ -148,20 +148,20 @@ class SensorFaultDrift(SensorFault, JsonSerializable):
         `float`
             Coefficient of the drift.
         """
-        return self.__coef
+        return self._coef
 
     def get_attributes(self) -> dict:
-        return super().get_attributes() | {"coef": self.__coef}
+        return super().get_attributes() | {"coef": self._coef}
 
     def __eq__(self, other) -> bool:
-        return super().__eq__(other) and self.__coef == other.coef
+        return super().__eq__(other) and self._coef == other.coef
 
     def __str__(self) -> str:
-        return f"{type(self).__name__} {super().__str__()} coef: {self.__coef}"
+        return f"{type(self).__name__} {super().__str__()} coef: {self._coef}"
 
     def apply_sensor_fault(self, cur_multiplier: float, sensor_reading: float,
                            cur_time: int) -> float:
-        return sensor_reading + cur_multiplier * (self.__coef * (cur_time - self.start_time))
+        return sensor_reading + cur_multiplier * (self._coef * (cur_time - self.start_time))
 
 
 @serializable(SENSOR_FAULT_GAUSSIAN_ID, ".epytflow_sensorfault_gaussian")
@@ -179,7 +179,7 @@ class SensorFaultGaussian(SensorFault, JsonSerializable):
         if not isinstance(std, float) or not std > 0:
             raise ValueError("'std' must be an instance of 'float' and be greater than 0")
 
-        self.__std = std
+        self._std = std
 
         super().__init__(**kwds)
 
@@ -193,20 +193,20 @@ class SensorFaultGaussian(SensorFault, JsonSerializable):
         `float`
             Standard deviation of the Gaussian noise.
         """
-        return self.__std
+        return self._std
 
     def get_attributes(self) -> dict:
-        return super().get_attributes() | {"std": self.__std}
+        return super().get_attributes() | {"std": self._std}
 
     def __eq__(self, other) -> bool:
-        return super().__eq__(other) and self.__std == other.std
+        return super().__eq__(other) and self._std == other.std
 
     def __str__(self) -> str:
-        return f"{type(self).__name__} {super().__str__()} std: {self.__std}"
+        return f"{type(self).__name__} {super().__str__()} std: {self._std}"
 
     def apply_sensor_fault(self, cur_multiplier: float, sensor_reading: float,
                            cur_time: int) -> float:
-        return sensor_reading + cur_multiplier * np.random.normal(loc=0, scale=self.__std)
+        return sensor_reading + cur_multiplier * np.random.normal(loc=0, scale=self._std)
 
 
 @serializable(SENSOR_FAULT_PERCENTAGE_ID, ".epytflow_sensorfault_percentage",)
@@ -223,7 +223,7 @@ class SensorFaultPercentage(SensorFault, JsonSerializable):
         if not isinstance(coef, float) or not coef > 0:
             raise ValueError("'coef' must be an instance of 'float' and be greater than zero.")
 
-        self.__coef = coef
+        self._coef = coef
 
         super().__init__(**kwds)
 
@@ -237,20 +237,20 @@ class SensorFaultPercentage(SensorFault, JsonSerializable):
         `float`
             Coefficient (percentage) of the shift.
         """
-        return self.__coef
+        return self._coef
 
     def get_attributes(self) -> dict:
-        return super().get_attributes() | {"coef": self.__coef}
+        return super().get_attributes() | {"coef": self._coef}
 
     def __eq__(self, other) -> bool:
-        return super().__eq__(other) and self.__coef == other.coef
+        return super().__eq__(other) and self._coef == other.coef
 
     def __str__(self) -> str:
-        return f"{type(self).__name__} {super().__str__()} coef: {self.__coef}"
+        return f"{type(self).__name__} {super().__str__()} coef: {self._coef}"
 
     def apply_sensor_fault(self, cur_multiplier: float, sensor_reading: float,
                            cur_time: int) -> float:
-        return sensor_reading + cur_multiplier * self.__coef * sensor_reading
+        return sensor_reading + cur_multiplier * self._coef * sensor_reading
 
 
 @serializable(SENSOR_FAULT_STUCKATZERO_ID, ".epytflow_sensorfault_zero")

epyt_flow/simulation/events/system_event.py

@@ -13,7 +13,7 @@ class SystemEvent(Event):
     """
     def __init__(self, **kwds):
         self._epanet_api = None
-        self.__exit_called = False
+        self._exit_called = False
 
         super().__init__(**kwds)
 
@@ -52,9 +52,9 @@ class SystemEvent(Event):
         if self.start_time <= cur_time < self.end_time:
             self.apply(cur_time)
         elif cur_time > self.end_time:
-            if self.__exit_called is False:
+            if self._exit_called is False:
                 self.exit(cur_time)
-                self.__exit_called = True
+                self._exit_called = True
 
     def reset(self) -> None:
         """

epyt_flow/simulation/scada/scada_data.py

@@ -167,7 +167,7 @@ class ScadaData(Serializable):
             raise TypeError("'sensor_readings_time' must be an instance of 'numpy.ndarray' " +
                             f"but not of '{type(sensor_readings_time)}'")
         if warnings_code is None:
-            warnings_code = [0] * len(sensor_readings_time)
+            warnings_code = np.array([0] * len(sensor_readings_time))
         else:
             if not isinstance(warnings_code, np.ndarray):
                 raise TypeError("'warnings_code' must be an instance of 'numpy.ndarray' " +
@@ -1713,7 +1713,7 @@ class ScadaData(Serializable):
         self.__sensor_reading_events = sensor_reading_events
         self.__init()
 
-    def extract_time_window(self, start_time: int, end_time: int):
+    def extract_time_window(self, start_time: int, end_time: int = None):
         """
         Extracts a time window of SCADA data from this SCADA data instance --
         i.e. creating a new SCADA data instance containing data from the requested

epyt_flow/simulation/scenario_simulator.py

@@ -1966,9 +1966,12 @@ class ScenarioSimulator():
         self._adapt_to_network_changes()
 
         if self._model_uncertainty is not None:
-            if self.__uncertainties_applied is True and reapply_uncertainties is True:
+            if self.__uncertainties_applied is False:
                 self._model_uncertainty.apply(self.epanet_api)
                 self.__uncertainties_applied = True
+            elif self.__uncertainties_applied is True and reapply_uncertainties is True:
+                self._model_uncertainty.undo(self.epanet_api)
+                self._model_uncertainty.apply(self.epanet_api)
 
         for event in self._system_events:
             event.reset()
@@ -2006,8 +2009,8 @@ class ScenarioSimulator():
             with the hydraulic simulation.
 
             The default is False.
-        reapply_uncertainties: bool = False : `bool`, optional
-            If True, the uncertainties are re-applied.
+        reapply_uncertainties: `bool`, optional
+            If True, the uncertainties are re-applied on the original properties.
 
             The default is False.
 
@@ -2089,8 +2092,8 @@ class ScenarioSimulator():
             with the hydraulic simulation.
 
             The default is False.
-        reapply_uncertainties: bool = False : `bool`, optional
-            If True, the uncertainties are re-applied.
+        reapply_uncertainties : `bool`, optional
+            If True, the uncertainties are re-applied on the original properties.
 
             The default is False.
 
@@ -2511,8 +2514,8 @@ class ScenarioSimulator():
             will be stored -- this usually leads to a significant reduction in memory consumption.
 
             The default is False.
-        reapply_uncertainties: bool = False : `bool`, optional
-            If True, the uncertainties are re-applied.
+        reapply_uncertainties : `bool`, optional
+            If True, the uncertainties are re-applied on the original properties.
 
             The default is False.
 
@@ -2596,8 +2599,8 @@ class ScenarioSimulator():
             will be stored -- this usually leads to a significant reduction in memory consumption.
 
             The default is False.
-        reapply_uncertainties: bool = False : `bool`, optional
-            If True, the uncertainties are re-applied.
+        reapply_uncertainties : `bool`, optional
+            If True, the uncertainties are re-applied on the original properties.
 
             The default is False.
 
@@ -2778,8 +2781,8 @@ class ScenarioSimulator():
             will be stored -- this usually leads to a significant reduction in memory consumption.
 
             The default is False.
-        reapply_uncertainties: bool = False : `bool`, optional
-            If True, the uncertainties are re-applied.
+        reapply_uncertainties: `bool`, optional
+            If True, the uncertainties are re-applied on the original properties.
 
             The default is False.
 

epyt_flow/topology.py

@@ -500,8 +500,15 @@ class NetworkTopology(nx.Graph, JsonSerializable):
             raise TypeError("Can not compare 'NetworkTopology' instance to " +
                             f"'{type(other)}' instance")
 
+        adj_matrix = self.get_adj_matrix()
+        other_adj_matrix = other.get_adj_matrix()
+
         return super().__eq__(other) and \
-            self.get_all_nodes() == other.get_all_nodes() \
+            self.name == other.name \
+            and not np.any(adj_matrix.data != other_adj_matrix.data) \
+            and not np.any(adj_matrix.indices != other_adj_matrix.indices) \
+            and not np.any(adj_matrix.indptr != other_adj_matrix.indptr) \
+            and self.get_all_nodes() == other.get_all_nodes() \
             and all(link_a[0] == link_b[0] and link_a[1] == link_b[1]
                     for link_a, link_b in zip(self.get_all_links(), other.get_all_links())) \
             and self.__units == other.units \