epyt-flow 0.13.1__py3-none-any.whl → 0.14.1__py3-none-any.whl

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,9 +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.warn("Loading a file that was created with an outdated version of EPyT-Flow" +
-                          " -- support of such old files will be removed in the next release!",
-                          DeprecationWarning)
+            warnings_code = [0] * len(sensor_readings_time)
         else:
             if not isinstance(warnings_code, np.ndarray):
                 raise TypeError("'warnings_code' must be an instance of 'numpy.ndarray' " +
@@ -376,6 +374,8 @@ class ScadaData(Serializable):
         self.__sensor_readings = None
         self.__frozen_sensor_config = frozen_sensor_config
         self.__sensor_readings_time = sensor_readings_time
+        self.__sensor_readings_time_to_idx = {time: idx for idx, time in
+                                              enumerate(self.__sensor_readings_time)}
 
         if self.__frozen_sensor_config is False:
             self.__pressure_data_raw = pressure_data_raw
@@ -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
@@ -1748,8 +1748,8 @@ class ScadaData(Serializable):
         else:
             end_time = self.__sensor_readings_time[-1]
 
-        start_idx = self.__sensor_readings_time.tolist().index(start_time)
-        end_idx = self.__sensor_readings_time.tolist().index(end_time) + 1
+        start_idx = self.__sensor_readings_time_to_idx[start_time]
+        end_idx = self.__sensor_readings_time_to_idx[end_time] + 1
 
         pressure_data_raw = None
         if self.__pressure_data_raw is not None:
@@ -2375,11 +2375,10 @@ class ScadaData(Serializable):
         mask = np.zeros(len(self.__sensor_config.nodes))
         node_features = np.array([[default_missing_value] * len(self.__sensor_config.nodes)
                                   for _ in range(len(self.__sensor_readings_time))])
-        nodes_id = self.__network_topo.get_all_nodes()
 
         pressure_readings = self.get_data_pressures()
         for pressures_idx, node_id in enumerate(self.__sensor_config.pressure_sensors):
-            idx = nodes_id.index(node_id)
+            idx = self.__sensor_config.map_node_id_to_idx(node_id)
             node_features[:, idx] = pressure_readings[:, pressures_idx]
             mask[idx] = 1
 
@@ -2617,11 +2616,10 @@ class ScadaData(Serializable):
         mask = np.zeros(len(self.__sensor_config.nodes))
         node_features = np.array([[default_missing_value] * len(self.__sensor_config.nodes)
                                   for _ in range(len(self.__sensor_readings_time))])
-        nodes_id = self.__network_topo.get_all_nodes()
 
         demand_readings = self.get_data_demands()
         for demands_idx, node_id in enumerate(self.__sensor_config.demand_sensors):
-            idx = nodes_id.index(node_id)
+            idx = self.__sensor_config.map_node_id_to_idx(node_id)
             node_features[:, idx] = demand_readings[:, demands_idx]
             mask[idx] = 1
 
@@ -2737,11 +2735,10 @@ class ScadaData(Serializable):
         mask = np.zeros(len(self.__sensor_config.nodes))
         node_features = np.array([[default_missing_value] * len(self.__sensor_config.nodes)
                                   for _ in range(len(self.__sensor_readings_time))])
-        nodes_id = self.__network_topo.get_all_nodes()
 
         node_quality_readings = self.get_data_nodes_quality()
         for quality_idx, node_id in enumerate(self.__sensor_config.quality_node_sensors):
-            idx = nodes_id.index(node_id)
+            idx = self.__sensor_config.map_node_id_to_idx(node_id)
             node_features[:, idx] = node_quality_readings[:, quality_idx]
             mask[idx] = 1
 
@@ -3752,7 +3749,6 @@ class ScadaData(Serializable):
         masks = []
         results = []
 
-        all_nodes_id = self.__network_topo.get_all_nodes()
         bulk_species_sensor_locations = self.__sensor_config.bulk_species_node_sensors
 
         for species_id, nodes_id in bulk_species_sensor_locations.items():
@@ -3762,7 +3758,7 @@ class ScadaData(Serializable):
             
             sensor_readings = self.get_data_bulk_species_node_concentration({species_id: nodes_id})
             for sensor_readings_idx, node_id in enumerate(nodes_id):
-                idx = all_nodes_id.index(node_id) 
+                idx = self.__sensor_config.map_node_id_to_idx(node_id) 
                 node_features[:, idx] = sensor_readings[:, sensor_readings_idx]
                 mask[idx] = 1