epyt-flow 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

epyt_flow/VERSION

@@ -1 +1 @@
-0.5.0
+0.6.0

epyt_flow/data/benchmarks/battledim.py

@@ -458,10 +458,14 @@ def load_scenario(return_test_scenario: bool, download_dir: str = None,
         ltown_config = load_ltown(use_realistic_demands=True, include_default_sensor_placement=True,
                                   verbose=verbose)
 
-    # Set simulation duration
+    # Set simulation duration and other general parameters such as the demand model
     general_params = {"simulation_duration": to_seconds(days=365),    # One year
                       "hydraulic_time_step": to_seconds(minutes=5),   # 5min time steps
-                      "reporting_time_step": to_seconds(minutes=5)} | ltown_config.general_params
+                      "reporting_time_step": to_seconds(minutes=5),
+                      "demand_model": {"type": "PDA", "pressure_min": 0,
+                                       "pressure_required": 0.1,
+                                       "pressure_exponent": 0.5}
+                      } | ltown_config.general_params
 
     # Add events
     start_time = START_TIME_TEST if return_test_scenario is True else START_TIME_TRAIN

epyt_flow/data/benchmarks/leakdb.py

@@ -30,7 +30,7 @@ from .leakdb_data import NET1_LEAKAGES, HANOI_LEAKAGES
 from ...utils import get_temp_folder, to_seconds, unpack_zip_archive, create_path_if_not_exist, \
     download_if_necessary
 from ...metrics import f1_score, true_positive_rate, true_negative_rate
-from ...simulation import ScenarioSimulator
+from ...simulation import ScenarioSimulator, ToolkitConstants
 from ...simulation.events import AbruptLeakage, IncipientLeakage
 from ...simulation import ScenarioConfig
 from ...simulation.scada import ScadaData
@@ -424,14 +424,19 @@ def load_scenarios(scenarios_id: list[int], use_net1: bool = True,
     download_dir = download_dir if download_dir is not None else get_temp_folder()
     network_config = load_network(download_dir)
 
-    # Set simulation duration
+    # Set simulation duration and other general parameters such as the demand model and flow units
     hydraulic_time_step = to_seconds(minutes=30)    # 30min time steps
     general_params = {"simulation_duration": to_seconds(days=365),   # One year
                       "hydraulic_time_step": hydraulic_time_step,
-                      "reporting_time_step": hydraulic_time_step} | network_config.general_params
+                      "reporting_time_step": hydraulic_time_step,
+                      "flow_units_id": ToolkitConstants.EN_CMH,
+                      "demand_model": {"type": "PDA", "pressure_min": 0,
+                                       "pressure_required": 0.1,
+                                       "pressure_exponent": 0.5}
+                      } | network_config.general_params
 
     # Add demand patterns
-    def gen_dem(download_dir, use_net1):
+    def gen_dem(download_dir):
         # Taken from https://github.com/KIOS-Research/LeakDB/blob/master/CCWI-WDSA2018/Dataset_Generator_Py3/demandGenerator.py
         week_pat = scipy.io.loadmat(os.path.join(download_dir, "weekPat_30min.mat"))
         a_w = week_pat['Aw']
@@ -503,10 +508,7 @@ def load_scenarios(scenarios_id: list[int], use_net1: bool = True,
 
         if not os.path.exists(f_inp_in):
             with ScenarioSimulator(f_inp_in=network_config.f_inp_in) as wdn:
-                wdn.epanet_api.setTimeHydraulicStep(general_params["hydraulic_time_step"])
-                wdn.epanet_api.setTimeSimulationDuration(general_params["simulation_duration"])
-                wdn.epanet_api.setTimePatternStep(general_params["hydraulic_time_step"])
-                wdn.epanet_api.setFlowUnitsCMH()
+                wdn.set_general_parameters(**general_params)
 
                 wdn.epanet_api.deletePatternsAll()
 
@@ -519,7 +521,7 @@ def load_scenarios(scenarios_id: list[int], use_net1: bool = True,
                     node_idx = wdn.epanet_api.getNodeIndex(node_id)
                     base_demand = wdn.epanet_api.getNodeBaseDemands(node_idx)[1][0]
 
-                    my_demand_pattern = np.array(gen_dem(download_dir, use_net1))
+                    my_demand_pattern = np.array(gen_dem(download_dir))
 
                     wdn.set_node_demand_pattern(node_id=node_id, base_demand=base_demand,
                                                 demand_pattern_id=f"demand_{node_id}",

epyt_flow/data/networks.py

@@ -56,8 +56,7 @@ def get_default_hydraulic_options(flow_units_id: int = None) -> dict:
         Dictionary with default hydraulics options that can be passed to
         :func:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator.set_general_parameters`.
     """
-    params = {"demand_model": {"type": "PDA", "pressure_min": 0, "pressure_required": 0.1,
-                               "pressure_exponent": 0.5}}
+    params = {}
     if flow_units_id is not None:
         params |= {"flow_units_id": flow_units_id}
 

epyt_flow/gym/scenario_control_env.py

@@ -2,7 +2,9 @@
 Module provides a base class for control environments.
 """
 from abc import abstractmethod, ABC
-from copy import deepcopy
+from typing import Union
+import warnings
+import numpy as np
 
 from ..simulation import ScenarioSimulator, ScenarioConfig, ScadaData
 
@@ -32,8 +34,13 @@ class ScenarioControlEnv(ABC):
     def autoreset(self) -> bool:
         """
         True, if environment automatically resets after it terminated.
+
+        Returns
+        -------
+        `bool`
+            True, if environment automatically resets after it terminated.
         """
-        return deepcopy(self.__autoreset)
+        return self.__autoreset
 
     def __enter__(self):
         return self
@@ -58,6 +65,11 @@ class ScenarioControlEnv(ABC):
     def reset(self) -> ScadaData:
         """
         Resets the environment (i.e. simulation).
+
+        Returns
+        -------
+        :class:`~epyt_flow.simulation.scada.scada_data.ScadaData`
+            Current SCADA data (i.e. sensor readings).
         """
         if self._scenario_sim is not None:
             self._scenario_sim.close()
@@ -83,19 +95,102 @@ class ScenarioControlEnv(ABC):
             else:
                 return None, True
 
+    def set_pump_status(self, pump_id: str, status: int) -> None:
+        """
+        Sets the status of a pump.
+
+        Parameters
+        ----------
+        pump_id : `str`
+            ID of the pump for which the status is set.
+        status : `int`
+            New status of the pump -- either active (i.e. open) or inactive (i.e. closed).
+
+            Must be one of the following constants defined in
+            :class:`~epyt_flow.simulation.events.actuator_events.ActuatorConstants`:
+
+                - EN_CLOSED  = 0
+                - EN_OPEN    = 1
+        """
+        pump_idx = self._scenario_sim.epanet_api.getLinkPumpNameID().index(pump_id)
+        pump_link_idx = self._scenario_sim.epanet_api.getLinkPumpIndex(pump_idx + 1)
+        self._scenario_sim.epanet_api.setLinkStatus(pump_link_idx, status)
+
+    def set_pump_speed(self, pump_id: str, speed: float) -> None:
+        """
+        Sets the speed of a pump.
+
+        Parameters
+        ----------
+        pump_id : `str`
+            ID of the pump for which the pump speed is set.
+        speed : `float`
+            New pump speed.
+        """
+        pump_idx = self._scenario_sim.epanet_api.getLinkPumpNameID().index(pump_id)
+        pattern_idx = self._scenario_sim.epanet_api.getLinkPumpPatternIndex(pump_idx + 1)
+
+        if pattern_idx == 0:
+            warnings.warn(f"No pattern for pump '{pump_id}' found -- a new pattern is created")
+            pattern_idx = self._scenario_sim.epanet_api.addPattern(f"pump_speed_{pump_id}")
+            self._scenario_sim.epanet_api.setLinkPumpPatternIndex(pattern_idx)
+
+        self._scenario_sim.epanet_api.setPattern(pattern_idx, np.array([speed]))
+
+    def set_valve_status(self, valve_id: str, status: int) -> None:
+        """
+        Sets the status of a valve.
+
+        Parameters
+        ----------
+        valve_id : `str`
+            ID of the valve for which the status is set.
+        status : `int`
+            New status of the valve -- either open or closed.
+
+            Must be one of the following constants defined in
+            :class:`~epyt_flow.simulation.events.actuator_events.ActuatorConstants`:
+
+                - EN_CLOSED  = 0
+                - EN_OPEN    = 1
+        """
+        valve_idx = self._scenario_sim.epanet_api.getLinkValveNameID().index(valve_id)
+        valve_link_idx = self._scenario_sim.epanet_api.getLinkValveIndex()[valve_idx]
+        self._scenario_sim.epanet_api.setLinkStatus(valve_link_idx, status)
+
+    def set_node_quality_source_value(self, node_id: str, pattern_id: str,
+                                      qual_value: float) -> None:
+        """
+        Sets the quality source at a particular node to a specific value -- e.g.
+        setting the chlorine concentration injection to a specified value.
+
+        Parameters
+        ----------
+        node_id : `str`
+            ID of the node.
+        pattern_id : `str`
+            ID of the quality pattern at the specific node.
+        qual_value : `float`
+            New quality source value.
+        """
+        node_idx = self._scenario_sim.epanet_api.getNodeIndex(node_id)
+        pattern_idx = self._scenario_sim.epanet_api.getPatternIndex(pattern_id)
+        self._scenario_sim.epanet_api.setNodeSourceQuality(node_idx, 1)
+        self._scenario_sim.epanet_api.setPattern(pattern_idx, np.array([qual_value]))
+
     @abstractmethod
-    def step(self) -> tuple[ScadaData, float, bool]:
+    def step(self, *actions) -> Union[tuple[ScadaData, float, bool], tuple[ScadaData, float]]:
         """
         Performs the next step by applying an action and observing
         the consequences (SCADA data, reward, terminated).
 
         Note that `terminated` is only returned if `autoreset=False` otherwise
-        only SCADA data and reward are returned.
+        only the current SCADA data and reward are returned.
 
         Returns
         -------
-        `(ScadaData, float, bool)`
-            Triple of observations (:class:`~epyt_flow.simuation.scada.scada_data.ScadaData`),
+        `(` :class:`~epyt_flow.simulation.scada.scada_data.ScadaData` `, float, bool)` or `(` :class:`~epyt_flow.simulation.scada.scada_data.ScadaData` `, float)`
+            Triple or tuple of observations (:class:`~epyt_flow.simulation.scada.scada_data.ScadaData`),
             reward (`float`), and terminated (`bool`).
         """
         raise NotImplementedError()

epyt_flow/serialization.py

@@ -4,6 +4,7 @@ Module provides functions and classes for serialization.
 from typing import Any, Union
 from abc import abstractmethod, ABC
 from io import BufferedIOBase
+import pathlib
 import importlib
 import json
 import gzip
@@ -97,7 +98,9 @@ class Serializable(ABC):
     Base class for a serializable class -- must be used in conjunction with the
     :func:`~epyt_flow.serialization.serializable` decorator.
     """
-    def __init__(self, **kwds):
+    def __init__(self, _parent_path: str = "", **kwds):
+        self._parent_path = _parent_path
+
         super().__init__(**kwds)
 
     @abstractmethod
@@ -376,12 +379,19 @@ def load_from_file(f_in: str, use_compression: bool = True) -> Any:
     `Any`
         Deserialized data.
     """
+    inst = None
+
     if use_compression is False:
         with open(f_in, "rb") as f:
-            return umsgpack.unpack(f, ext_handlers=ext_handler_unpack)
+            inst = load(f.read())
     else:
         with gzip.open(f_in, "rb") as f:
-            return load(f.read())
+            inst = load(f.read())
+
+    if isinstance(inst, Serializable):
+        inst._parent_path = pathlib.Path(f_in).parent.resolve()
+
+    return inst
 
 
 def save_to_file(f_out: str, data: Any, use_compression: bool = True) -> None:

epyt_flow/simulation/scada/advanced_control.py

@@ -98,7 +98,7 @@ class AdvancedControlModule(ABC):
                 - EN_OPEN    = 1
         """
         valve_idx = self._epanet_api.getLinkValveNameID().index(valve_id)
-        valve_link_idx = self._epanet_api.getLinkValveIndex(valve_idx + 1)
+        valve_link_idx = self._epanet_api.getLinkValveIndex()[valve_idx]
         self._epanet_api.setLinkStatus(valve_link_idx, status)
 
     def set_node_quality_source_value(self, node_id: str, pattern_id: str,

epyt_flow/simulation/scada/scada_data.py

@@ -12,6 +12,7 @@ from ..sensor_config import SensorConfig, is_flowunit_simetric, massunit_to_str,
     AREA_UNIT_CM2, AREA_UNIT_FT2, AREA_UNIT_M2, \
     SENSOR_TYPE_LINK_FLOW, SENSOR_TYPE_LINK_QUALITY,  SENSOR_TYPE_NODE_DEMAND, \
     SENSOR_TYPE_NODE_PRESSURE, SENSOR_TYPE_NODE_QUALITY, SENSOR_TYPE_PUMP_STATE, \
+    SENSOR_TYPE_PUMP_EFFICIENCY, SENSOR_TYPE_PUMP_ENERGYCONSUMPTION, \
     SENSOR_TYPE_TANK_VOLUME, SENSOR_TYPE_VALVE_STATE, SENSOR_TYPE_NODE_BULK_SPECIES, \
     SENSOR_TYPE_LINK_BULK_SPECIES, SENSOR_TYPE_SURFACE_SPECIES
 from ..events import SensorFault, SensorReadingAttack, SensorReadingEvent
@@ -92,11 +93,11 @@ class ScadaData(Serializable):
         third dimension denotes species concentrations at nodes.
 
         The default is None.
-    pump_energy_usage_data : `numpy.ndarray`, optional
+    pumps_energy_usage_data_raw : `numpy.ndarray`, optional
         Energy usage data of each pump.
 
         The default is None.
-    pump_efficiency_data : `numpy.ndarray`, optional
+    pumps_efficiency_data_raw : `numpy.ndarray`, optional
         Pump efficiency data of each pump.
 
         The default is None.
@@ -130,8 +131,10 @@ class ScadaData(Serializable):
                  surface_species_concentration_raw: np.ndarray = None,
                  bulk_species_node_concentration_raw: np.ndarray = None,
                  bulk_species_link_concentration_raw: np.ndarray = None,
-                 pump_energy_usage_data: np.ndarray = None,
-                 pump_efficiency_data: np.ndarray = None,
+                 pump_energy_usage_data = None,
+                 pump_efficiency_data = None,
+                 pumps_energy_usage_data_raw: np.ndarray = None,
+                 pumps_efficiency_data_raw: np.ndarray = None,
                  sensor_faults: list[SensorFault] = [],
                  sensor_reading_attacks: list[SensorReadingAttack] = [],
                  sensor_reading_events: list[SensorReadingEvent] = [],
@@ -195,14 +198,14 @@ class ScadaData(Serializable):
                 raise TypeError("'bulk_species_link_concentration_raw' must be an instance of " +
                                 "'numpy.ndarray' but not of " +
                                 f"'{type(bulk_species_link_concentration_raw)}'")
-        if pump_energy_usage_data is not None:
-            if not isinstance(pump_energy_usage_data, np.ndarray):
-                raise TypeError("'pump_energy_usage_data' must be an instance of 'numpy.ndarray' " +
-                                f"but not of '{type(pump_energy_usage_data)}'")
-        if pump_efficiency_data is not None:
-            if not isinstance(pump_efficiency_data, np.ndarray):
-                raise TypeError("'pump_efficiency_data' must be an instance of 'numpy.ndarray' " +
-                                f"but not of '{type(pump_efficiency_data)}'")
+        if pumps_energy_usage_data_raw is not None:
+            if not isinstance(pumps_energy_usage_data_raw, np.ndarray):
+                raise TypeError("'pumps_energy_usage_data_raw' must be an instance of 'numpy.ndarray' " +
+                                f"but not of '{type(pumps_energy_usage_data_raw)}'")
+        if pumps_efficiency_data_raw is not None:
+            if not isinstance(pumps_efficiency_data_raw, np.ndarray):
+                raise TypeError("'pumps_efficiency_data_raw' must be an instance of 'numpy.ndarray' " +
+                                f"but not of '{type(pumps_efficiency_data_raw)}'")
         if len(sensor_faults) != 0:
             if any(not isinstance(f, SensorFault) for f in sensor_faults):
                 raise TypeError("'sensor_faults' must be a list of " +
@@ -223,6 +226,11 @@ class ScadaData(Serializable):
             raise TypeError("'frozen_sensor_config' must be an instance of 'bool' " +
                             f"but not of '{type(frozen_sensor_config)}'")
 
+        if pump_efficiency_data is not None or pump_energy_usage_data is not 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)
+
         def __raise_shape_mismatch(var_name: str) -> None:
             raise ValueError(f"Shape mismatch in '{var_name}' -- " +
                              "i.e number of time steps in 'sensor_readings_time' " +
@@ -271,12 +279,12 @@ class ScadaData(Serializable):
         if surface_species_concentration_raw is not None:
             if surface_species_concentration_raw.shape[0] != n_time_steps:
                 __raise_shape_mismatch("surface_species_concentration_raw")
-        if pump_energy_usage_data is not None:
-            if pump_energy_usage_data.shape[0] != n_time_steps:
-                __raise_shape_mismatch("pump_energy_usage_data")
-        if pump_efficiency_data is not None:
-            if pump_efficiency_data.shape[0] != n_time_steps:
-                __raise_shape_mismatch("pump_efficiency_data")
+        if pumps_energy_usage_data_raw is not None:
+            if pumps_energy_usage_data_raw.shape[0] != n_time_steps:
+                __raise_shape_mismatch("pumps_energy_usage_data_raw")
+        if pumps_efficiency_data_raw is not None:
+            if pumps_efficiency_data_raw.shape[0] != n_time_steps:
+                __raise_shape_mismatch("pumps_efficiency_data_raw")
 
         self.__sensor_config = sensor_config
         self.__sensor_noise = sensor_noise
@@ -286,8 +294,6 @@ class ScadaData(Serializable):
         self.__sensor_readings = None
         self.__frozen_sensor_config = frozen_sensor_config
         self.__sensor_readings_time = sensor_readings_time
-        self.__pump_energy_usage_data = pump_energy_usage_data
-        self.__pump_efficiency_data = pump_efficiency_data
 
         if self.__frozen_sensor_config is False:
             self.__pressure_data_raw = pressure_data_raw
@@ -301,6 +307,8 @@ class ScadaData(Serializable):
             self.__surface_species_concentration_raw = surface_species_concentration_raw
             self.__bulk_species_node_concentration_raw = bulk_species_node_concentration_raw
             self.__bulk_species_link_concentration_raw = bulk_species_link_concentration_raw
+            self.__pumps_energy_usage_data_raw = pumps_energy_usage_data_raw
+            self.__pumps_efficiency_data_raw = pumps_efficiency_data_raw
         else:
             sensor_config = self.__sensor_config
 
@@ -338,6 +346,14 @@ class ScadaData(Serializable):
             self.__pumps_state_data_raw = __reduce_data(data=pumps_state_data_raw,
                                                         item_to_idx=pump_to_idx,
                                                         sensors=sensor_config.pump_state_sensors)
+            self.__pumps_energy_usage_data_raw = \
+                __reduce_data(data=pumps_energy_usage_data_raw,
+                              item_to_idx=pump_to_idx,
+                              sensors=sensor_config.pump_enegeryconsumption_sensors)
+            self.__pumps_efficiency_data_raw = \
+                __reduce_data(data=pumps_efficiency_data_raw,
+                              item_to_idx=pump_to_idx,
+                              sensors=sensor_config.pump_efficiency_sensors)
             self.__valves_state_data_raw = __reduce_data(data=valves_state_data_raw,
                                                          item_to_idx=valve_to_idx,
                                                          sensors=sensor_config.valve_state_sensors)
@@ -881,6 +897,10 @@ class ScadaData(Serializable):
                                      quality_link_sensors=self.__sensor_config.quality_link_sensors,
                                      valve_state_sensors=self.__sensor_config.valve_state_sensors,
                                      pump_state_sensors=self.__sensor_config.pump_state_sensors,
+                                     pump_efficiency_sensors=
+                                     self.__sensor_config.pump_efficiency_sensors,
+                                     pump_energyconsumption_sensors=
+                                     self.__sensor_config.pump_energyconsumption_sensors,
                                      tank_volume_sensors=self.__sensor_config.tank_volume_sensors,
                                      bulk_species_node_sensors=
                                      self.__sensor_config.bulk_species_node_sensors,
@@ -906,8 +926,8 @@ class ScadaData(Serializable):
                          pumps_state_data_raw=self.pumps_state_data_raw,
                          valves_state_data_raw=self.valves_state_data_raw,
                          tanks_volume_data_raw=tanks_volume_data,
-                         pump_energy_usage_data=self.pump_energy_usage_data,
-                         pump_efficiency_data=self.pump_efficiency_data,
+                         pumps_energy_usage_data_raw=self.pumps_energyconsumption_data_raw,
+                         pumps_efficiency_data_raw=self.pumps_efficiency_data_raw,
                          bulk_species_node_concentration_raw=bulk_species_node_concentrations,
                          bulk_species_link_concentration_raw=bulk_species_link_concentrations,
                          surface_species_concentration_raw=surface_species_concentrations)
@@ -1154,44 +1174,28 @@ class ScadaData(Serializable):
         return deepcopy(self.__bulk_species_link_concentration_raw)
 
     @property
-    def pump_energy_usage_data(self) -> np.ndarray:
+    def pumps_energyconsumption_data_raw(self) -> np.ndarray:
         """
-        Gets the energy usage of each pump.
-
-        .. note::
-            This attribute is NOT included in
-            :func:`~epyt_flow.simulation.scada.scada_data.ScadaData.get_data` --
-            calling this function is the only way of accessing the energy usage of each pump.
-
-            The odering in the returned NumPy array corresponds to the ordering
-            of the pumps in EPANET.
+        Gets the raw energy consumption of each pump.
 
         Returns
         -------
         `numpy.ndarray`
-            Energy usage of each pump.
+            Energy consumption of each pump.
         """
-        return deepcopy(self.__pump_energy_usage_data)
+        return deepcopy(self.__pumps_energy_usage_data_raw)
 
     @property
-    def pump_efficiency_data(self) -> np.ndarray:
+    def pumps_efficiency_data_raw(self) -> np.ndarray:
         """
-        Gets the pumps' efficiency.
-
-        .. note::
-            This attribute is NOT included in
-            :func:`~epyt_flow.simulation.scada.scada_data.ScadaData.get_data` --
-            calling this function is the only way of accessing the pumps' efficiency.
-
-            The odering in the returned NumPy array corresponds to the ordering
-            of the pumps in EPANET.
+        Gets the raw efficiency of each pump.
 
         Returns
         -------
         `numpy.ndarray`
             Pumps' efficiency.
         """
-        return deepcopy(self.__pump_efficiency_data)
+        return deepcopy(self.__pumps_efficiency_data_raw)
 
     def __init(self):
         self.__apply_sensor_noise = lambda x: x
@@ -1222,6 +1226,12 @@ class ScadaData(Serializable):
             elif sensor_event.sensor_type == SENSOR_TYPE_PUMP_STATE:
                 idx = self.__sensor_config.get_index_of_reading(
                     pump_state_sensor=sensor_event.sensor_id)
+            elif sensor_event.sensor_type == SENSOR_TYPE_PUMP_EFFICIENCY:
+                idx = self.__sensor_config.get_index_of_reading(
+                    pump_efficiency_sensor=sensor_event.sensor_id)
+            elif sensor_event.sensor_type == SENSOR_TYPE_PUMP_ENERGYCONSUMPTION:
+                idx = self.__sensor_config.get_index_of_reading(
+                    pump_energyconsumption_sensor=sensor_event.sensor_id)
             elif sensor_event.sensor_type == SENSOR_TYPE_TANK_VOLUME:
                 idx = self.__sensor_config.get_index_of_reading(
                     tank_volume_sensor=sensor_event.sensor_id)
@@ -1256,8 +1266,8 @@ class ScadaData(Serializable):
                 "surface_species_concentration_raw": self.__surface_species_concentration_raw,
                 "bulk_species_node_concentration_raw": self.__bulk_species_node_concentration_raw,
                 "bulk_species_link_concentration_raw": self.__bulk_species_link_concentration_raw,
-                "pump_energy_usage_data": self.__pump_energy_usage_data,
-                "pump_efficiency_data": self.__pump_efficiency_data}
+                "pumps_energy_usage_data_raw": self.__pumps_energy_usage_data_raw,
+                "pumps_efficiency_data_raw": self.__pumps_efficiency_data_raw}
 
         return super().get_attributes() | attr
 
@@ -1286,8 +1296,9 @@ class ScadaData(Serializable):
                            other.bulk_species_node_concentration_raw) \
                 and np.all(self.__bulk_species_link_concentration_raw ==
                            other.bulk_species_link_concentration_raw) \
-                and np.all(self.__pump_energy_usage_data == other.pump_energy_usage_data) \
-                and np.all(self.__pump_efficiency_data == other.pump_efficiency_data)
+                and np.all(self.__pumps_energy_usage_data_raw ==
+                           other.pumps_energyconsumption_data_raw) \
+                and np.all(self.__pumps_efficiency_data_raw == other.pumps_efficiency_data_raw)
         except Exception as ex:
             warnings.warn(ex.__str__())
             return False
@@ -1308,8 +1319,8 @@ class ScadaData(Serializable):
             f"surface_species_concentration_raw: {self.__surface_species_concentration_raw} " + \
             f"bulk_species_node_concentration_raw: {self.__bulk_species_node_concentration_raw}" +\
             f" bulk_species_link_concentration_raw: {self.__bulk_species_link_concentration_raw}" +\
-            f" pump_efficiency_data: {self.__pump_efficiency_data} " + \
-            f"pump_energy_usage_data: {self.__pump_energy_usage_data}"
+            f" pumps_efficiency_data_raw: {self.__pumps_efficiency_data_raw} " + \
+            f"pumps_energy_usage_data_raw: {self.__pumps_energy_usage_data_raw}"
 
     def change_sensor_config(self, sensor_config: SensorConfig) -> None:
         """
@@ -1491,11 +1502,13 @@ class ScadaData(Serializable):
             self.__sensor_config.surface_species_sensors = \
                 other.sensor_config.surface_species_sensors
 
-        if self.__pump_energy_usage_data is None and other.pump_energy_usage_data is not None:
-            self.__pump_energy_usage_data = other.pump_energy_usage_data
+        if self.__pumps_energy_usage_data_raw is None and \
+                other.pumps_energy_usage_data_raw is not None:
+            self.__pumps_energy_usage_data_raw = other.pumps_energy_usage_data_raw
 
-        if self.__pump_efficiency_data is None and other.pump_efficiency_data is not None:
-            self.__pump_efficiency_data = other.pump_efficiency_data
+        if self.__pumps_efficiency_data_raw is None and \
+                other.pumps_efficiency_data_raw is not None:
+            self.__pumps_efficiency_data_raw = other.pumps_efficiency_data_raw
 
         self.__init()
 
@@ -1581,14 +1594,14 @@ class ScadaData(Serializable):
                  other.bulk_species_link_concentration_raw),
                 axis=0)
 
-        if self.__pump_energy_usage_data is not None:
-            self.__pump_energy_usage_data = np.concatenate(
-                (self.__pump_energy_usage_data, other.pump_energy_usage_data),
+        if self.__pumps_energy_usage_data_raw is not None:
+            self.__pumps_energy_usage_data_raw = np.concatenate(
+                (self.__pumps_energy_usage_data_raw, other.pumps_energy_usage_data_raw),
                 axis=0)
 
-        if self.__pump_efficiency_data is not None:
-            self.__pump_efficiency_data = np.concatenate(
-                (self.__pump_efficiency_data, other.pump_efficiency_data),
+        if self.__pumps_efficiency_data_raw is not None:
+            self.__pumps_efficiency_data_raw = np.concatenate(
+                (self.__pumps_efficiency_data_raw, other.pumps_efficiency_data_raw),
                 axis=0)
 
     def get_data(self) -> np.ndarray:
@@ -1609,6 +1622,8 @@ class ScadaData(Serializable):
                     "nodes_quality": self.__node_quality_data_raw,
                     "links_quality": self.__link_quality_data_raw,
                     "pumps_state": self.__pumps_state_data_raw,
+                    "pumps_efficiency": self.__pumps_efficiency_data_raw,
+                    "pumps_energyconsumption": self.__pumps_energy_usage_data_raw,
                     "valves_state": self.__valves_state_data_raw,
                     "tanks_volume": self.__tanks_volume_data_raw,
                     "bulk_species_node_concentrations": self.__bulk_species_node_concentration_raw,
@@ -1632,6 +1647,10 @@ class ScadaData(Serializable):
                 data.append(self.__valves_state_data_raw)
             if self.__pumps_state_data_raw is not None:
                 data.append(self.__pumps_state_data_raw)
+            if self.__pumps_efficiency_data_raw is not None:
+                data.append(self.__pumps_efficiency_data_raw)
+            if self.__pumps_energy_usage_data_raw is not None:
+                data.append(self.__pumps_energy_usage_data_raw)
             if self.__tanks_volume_data_raw is not None:
                 data.append(self.__tanks_volume_data_raw)
             if self.__surface_species_concentration_raw is not None:
@@ -1896,6 +1915,85 @@ class ScadaData(Serializable):
                for s_id in sensor_locations]
         return self.__sensor_readings[:, idx]
 
+    def get_data_pumps_efficiency(self, sensor_locations: list[str] = None) -> np.ndarray:
+        """
+        Gets the final pump efficiency sensor readings -- note that those might be subject to
+        given sensor faults and sensor noise/uncertainty.
+
+        Parameters
+        ----------
+        sensor_locations : `list[str]`, optional
+            Existing pump efficiency sensor locations for which the sensor readings are requested.
+            If None, the readings from all pump efficiency sensors are returned.
+
+            The default is None.
+
+        Returns
+        -------
+        `numpy.ndarray`
+            Pump efficiency sensor readings.
+        """
+        if self.__sensor_config.pump_efficiency_sensors == []:
+            raise ValueError("No pump efficiency sensors set")
+        if sensor_locations is not None:
+            if not isinstance(sensor_locations, list):
+                raise TypeError("'sensor_locations' must be an instance of 'list[str]' " +
+                                f"but not of '{type(sensor_locations)}'")
+            if any(s_id not in self.__sensor_config.pump_efficiency_sensors
+                   for s_id in sensor_locations):
+                raise ValueError("Invalid sensor ID in 'sensor_locations' -- note that all " +
+                                 "sensors in 'sensor_locations' must be set in the current " +
+                                 "pump efficiency sensor configuration")
+        else:
+            sensor_locations = self.__sensor_config.pump_efficiency_sensors
+
+        if self.__sensor_readings is None:
+            self.get_data()
+
+        idx = [self.__sensor_config.get_index_of_reading(pump_efficiency_sensor=s_id)
+               for s_id in sensor_locations]
+        return self.__sensor_readings[:, idx]
+
+    def get_data_pumps_energyconsumption(self, sensor_locations: list[str] = None) -> np.ndarray:
+        """
+        Gets the final pump energy consumption sensor readings -- note that those might be subject
+        to given sensor faults and sensor noise/uncertainty.
+
+        Parameters
+        ----------
+        sensor_locations : `list[str]`, optional
+            Existing pump energy consumption sensor locations for which
+            the sensor readings are requested.
+            If None, the readings from all pump energy consumption sensors are returned.
+
+            The default is None.
+
+        Returns
+        -------
+        `numpy.ndarray`
+            Pump energy consumption sensor readings.
+        """
+        if self.__sensor_config.pump_energyconsumption_sensors == []:
+            raise ValueError("No pump energy consumption sensors set")
+        if sensor_locations is not None:
+            if not isinstance(sensor_locations, list):
+                raise TypeError("'sensor_locations' must be an instance of 'list[str]' " +
+                                f"but not of '{type(sensor_locations)}'")
+            if any(s_id not in self.__sensor_config.pump_energyconsumption_sensors
+                   for s_id in sensor_locations):
+                raise ValueError("Invalid sensor ID in 'sensor_locations' -- note that all " +
+                                 "sensors in 'sensor_locations' must be set in the current " +
+                                 "pump efficiency sensor configuration")
+        else:
+            sensor_locations = self.__sensor_config.pump_energyconsumption_sensors
+
+        if self.__sensor_readings is None:
+            self.get_data()
+
+        idx = [self.__sensor_config.get_index_of_reading(pump_energyconsumption_sensor=s_id)
+               for s_id in sensor_locations]
+        return self.__sensor_readings[:, idx]
+
     def get_data_valves_state(self, sensor_locations: list[str] = None) -> np.ndarray:
         """
         Gets the final valve state sensor readings -- note that those might be subject to