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

epyt_flow/simulation/sensor_config.py

@@ -11,17 +11,19 @@ from epyt.epanet import ToolkitConstants
 from ..serialization import SENSOR_CONFIG_ID, JsonSerializable, serializable
 
 
-SENSOR_TYPE_NODE_PRESSURE     = 1
-SENSOR_TYPE_NODE_QUALITY      = 2
-SENSOR_TYPE_NODE_DEMAND       = 3
-SENSOR_TYPE_LINK_FLOW         = 4
-SENSOR_TYPE_LINK_QUALITY      = 5
-SENSOR_TYPE_VALVE_STATE       = 6
-SENSOR_TYPE_PUMP_STATE        = 7
-SENSOR_TYPE_TANK_VOLUME       = 8
-SENSOR_TYPE_NODE_BULK_SPECIES = 9
-SENSOR_TYPE_LINK_BULK_SPECIES = 10
-SENSOR_TYPE_SURFACE_SPECIES   = 11
+SENSOR_TYPE_NODE_PRESSURE          = 1
+SENSOR_TYPE_NODE_QUALITY           = 2
+SENSOR_TYPE_NODE_DEMAND            = 3
+SENSOR_TYPE_LINK_FLOW              = 4
+SENSOR_TYPE_LINK_QUALITY           = 5
+SENSOR_TYPE_VALVE_STATE            = 6
+SENSOR_TYPE_PUMP_STATE             = 7
+SENSOR_TYPE_TANK_VOLUME            = 8
+SENSOR_TYPE_NODE_BULK_SPECIES      = 9
+SENSOR_TYPE_LINK_BULK_SPECIES      = 10
+SENSOR_TYPE_SURFACE_SPECIES        = 11
+SENSOR_TYPE_PUMP_EFFICIENCY        = 12
+SENSOR_TYPE_PUMP_ENERGYCONSUMPTION = 13
 
 AREA_UNIT_FT2 = 1
 AREA_UNIT_M2 = 2
@@ -462,6 +464,8 @@ class SensorConfig(JsonSerializable):
                  quality_link_sensors: list[str] = [],
                  valve_state_sensors: list[str] = [],
                  pump_state_sensors: list[str] = [],
+                 pump_efficiency_sensors: list[str] = [],
+                 pump_energyconsumption_sensors: list[str] = [],
                  tank_volume_sensors: list[str] = [],
                  bulk_species_node_sensors: dict = {},
                  bulk_species_link_sensors: dict = {},
@@ -572,6 +576,20 @@ class SensorConfig(JsonSerializable):
             raise ValueError("Each item in 'pump_state_sensors' must be in 'pumps' -- cannot " +
                              "place a sensor at a non-existing pump.")
 
+        if not isinstance(pump_efficiency_sensors, list):
+            raise TypeError("'pump_efficiency_sensors' must be an instance of 'list[str]' " +
+                            f"but not of '{type(pump_efficiency_sensors)}'")
+        if any(link not in pumps for link in pump_efficiency_sensors):
+            raise ValueError("Each item in 'pump_efficiency_sensors' must be in 'pumps' -- cannot " +
+                             "place a sensor at a non-existing pump.")
+
+        if not isinstance(pump_energyconsumption_sensors, list):
+            raise TypeError("'pump_energyconsumption_sensors' must be an instance of 'list[str]' " +
+                            f"but not of '{type(pump_energyconsumption_sensors)}'")
+        if any(link not in pumps for link in pump_energyconsumption_sensors):
+            raise ValueError("Each item in 'pump_energyconsumption_sensors' must be in 'pumps' -- cannot " +
+                             "place a sensor at a non-existing pump.")
+
         if not isinstance(tank_volume_sensors, list):
             raise TypeError("'tank_volume_sensors' must be an instance of 'list[str]' " +
                             f"but not of '{type(tank_volume_sensors)}'")
@@ -714,6 +732,8 @@ class SensorConfig(JsonSerializable):
         self.__quality_link_sensors = quality_link_sensors
         self.__valve_state_sensors = valve_state_sensors
         self.__pump_state_sensors = pump_state_sensors
+        self.__pump_energyconsumption_sensors = pump_energyconsumption_sensors
+        self.__pump_efficiency_sensors = pump_efficiency_sensors
         self.__tank_volume_sensors = tank_volume_sensors
         self.__bulk_species_node_sensors = bulk_species_node_sensors
         self.__bulk_species_link_sensors = bulk_species_link_sensors
@@ -771,6 +791,51 @@ class SensorConfig(JsonSerializable):
                             bulkspecies_id_to_idx=sensor_config.bulkspecies_id_to_idx,
                             surfacespecies_id_to_idx=sensor_config.surfacespecies_id_to_idx)
 
+    def is_empty(self) -> bool:
+        """
+        Checks if the sensor configuration is empty -- i.e. no sensors are placed.
+
+        Returns
+        -------
+        `bool`
+            True if no sensors are placed, False otherwise.
+        """
+        if self.__pressure_sensors == [] and self.__flow_sensors == [] \
+                and self.__demand_sensors == [] and self.__quality_node_sensors == [] \
+                and self.__quality_link_sensors == [] and self.__valve_state_sensors == [] \
+                and self.__pump_state_sensors == [] \
+                and self.__pump_energyconsumption_sensors == [] \
+                and self.__pump_efficiency_sensors == [] and self.__tank_volume_sensors == [] \
+                and self.__bulk_species_node_sensors == [] \
+                and self.__bulk_species_link_sensors == [] \
+                and self.__surface_species_sensors == []:
+            return True
+        else:
+            return False
+
+    def place_sensors_everywhere(self) -> None:
+        """
+        Places sensors everywhere -- i.e. every possible quantity is monitored
+        at every position in the network.
+        """
+        self.__pressure_sensors = self.__nodes[:]
+        self.__demand_sensors = self.__nodes[:]
+        self.__flow_sensors = self.__links[:]
+        self.__quality_node_sensors = self.__nodes[:]
+        self.__quality_link_sensors = self.__links[:]
+        self.__pump_state_sensors = self.__pumps[:]
+        self.__pump_energyconsumption_sensors = self.__pumps[:]
+        self.__pump_efficiency_sensors = self.__pumps[:]
+        self.__tank_volume_sensors = self.__tanks[:]
+        self.__bulk_species_node_sensors = {species_id: self.__nodes[:]
+                                            for species_id in self.__bulk_species}
+        self.__bulk_species_link_sensors = {species_id: self.__links[:]
+                                            for species_id in self.__bulk_species}
+        self.__surface_species_sensors = {species_id: self.__links[:]
+                                          for species_id in self.__surface_species}
+
+        self.__compute_indices()
+
     @property
     def node_id_to_idx(self) -> dict:
         """
@@ -1032,6 +1097,12 @@ class SensorConfig(JsonSerializable):
                                            for v in self.__valve_state_sensors], dtype=np.int32)
         self.__pump_state_idx = np.array([self.map_pump_id_to_idx(p)
                                           for p in self.__pump_state_sensors], dtype=np.int32)
+        self.__pump_efficiency_idx = np.array([self.map_pump_id_to_idx(p)
+                                               for p in self.__pump_efficiency_sensors],
+                                               dtype=np.int32)
+        self.__pump_energyconsumption_idx = np.array([self.map_pump_id_to_idx(p)
+                                                      for p in self.__pump_energyconsumption_sensors],
+                                                      dtype=np.int32)
         self.__tank_volume_idx = np.array([self.map_tank_id_to_idx(t)
                                            for t in self.__tank_volume_sensors], dtype=np.int32)
         self.__bulk_species_node_idx = np.array([(self.map_bulkspecies_id_to_idx(s),
@@ -1057,6 +1128,8 @@ class SensorConfig(JsonSerializable):
         n_link_quality_sensors = len(self.__quality_link_sensors)
         n_valve_state_sensors = len(self.__valve_state_sensors)
         n_pump_state_sensors = len(self.__pump_state_sensors)
+        n_pump_efficiency_sensors = len(self.__pump_efficiency_sensors)
+        n_pump_energyconsumption_sensors = len(self.__pump_energyconsumption_sensors)
         n_tank_volume_sensors = len(self.__tank_volume_sensors)
         n_bulk_species_node_sensors = len(list(itertools.chain(
             *self.__bulk_species_node_sensors.values())))
@@ -1070,7 +1143,9 @@ class SensorConfig(JsonSerializable):
         link_quality_idx_shift = node_quality_idx_shift + n_node_quality_sensors
         valve_state_idx_shift = link_quality_idx_shift + n_link_quality_sensors
         pump_state_idx_shift = valve_state_idx_shift + n_valve_state_sensors
-        tank_volume_idx_shift = pump_state_idx_shift + n_pump_state_sensors
+        pump_efficiency_idx_shift = pump_state_idx_shift + n_pump_state_sensors
+        pump_energyconsumption_idx_shift = pump_efficiency_idx_shift + n_pump_efficiency_sensors
+        tank_volume_idx_shift = pump_energyconsumption_idx_shift + n_pump_energyconsumption_sensors
         bulk_species_node_idx_shift = tank_volume_idx_shift + n_tank_volume_sensors
         bulk_species_link_idx_shift = bulk_species_node_idx_shift + n_bulk_species_node_sensors
         surface_species_idx_shift = bulk_species_link_idx_shift + n_bulk_species_link_sensors
@@ -1103,6 +1178,11 @@ class SensorConfig(JsonSerializable):
                                                             valve_state_idx_shift),
                    "pump_state": __build_sensors_id_to_idx(self.__pump_state_sensors,
                                                            pump_state_idx_shift),
+                   "pump_efficiency": __build_sensors_id_to_idx(self.__pump_efficiency_sensors,
+                                                                pump_efficiency_idx_shift),
+                   "pump_energyconsumption":
+                   __build_sensors_id_to_idx(self.__pump_energyconsumption_sensors,
+                                             pump_energyconsumption_idx_shift),
                    "tank_volume": __build_sensors_id_to_idx(self.__tank_volume_sensors,
                                                             tank_volume_idx_shift),
                    "bulk_species_node":
@@ -1526,6 +1606,58 @@ class SensorConfig(JsonSerializable):
 
         self.__compute_indices()
 
+    @property
+    def pump_energyconsumption_sensors(self) -> list[str]:
+        """
+        Gets all pump energy consumption sensors
+        (i.e. IDs of pumps at which the energy consumption is monitored).
+
+        Returns
+        -------
+        `list[str]`
+            All pump IDs with an energy consumption sensor.
+        """
+        return self.__pump_energyconsumption_sensors.copy()
+
+    @pump_energyconsumption_sensors.setter
+    def pump_energyconsumption_sensors(self, pump_energyconsumption_sensors: list[str]) -> None:
+        if not isinstance(pump_energyconsumption_sensors, list):
+            raise TypeError("'pump_energyconsumption_sensors' must be an instance of 'list[str]' " +
+                            f"but not of '{type(pump_energyconsumption_sensors)}'")
+        if any(link not in self.__pumps for link in pump_energyconsumption_sensors):
+            raise ValueError("Each item in 'pump_energyconsumption_sensors' must be in 'pumps' " +
+                             "-- cannot place a sensor at a non-existing pump.")
+
+        self.__pump_energyconsumption_sensors = pump_energyconsumption_sensors
+
+        self.__compute_indices()
+
+    @property
+    def pump_efficiency_sensors(self) -> list[str]:
+        """
+        Gets all pump efficiency sensors
+        (i.e. IDs of pumps at which the efficiency is monitored).
+
+        Returns
+        -------
+        `list[str]`
+            All pump IDs with an efficiency sensor.
+        """
+        return self.__pump_efficiency_sensors.copy()
+
+    @pump_efficiency_sensors.setter
+    def pump_efficiency_sensors(self, pump_efficiency_sensors: list[str]) -> None:
+        if not isinstance(pump_efficiency_sensors, list):
+            raise TypeError("'pump_efficiency_sensors' must be an instance of 'list[str]' " +
+                            f"but not of '{type(pump_efficiency_sensors)}'")
+        if any(link not in self.__pumps for link in pump_efficiency_sensors):
+            raise ValueError("Each item in 'pump_efficiency_sensors' must be in 'pumps' " +
+                             "-- cannot place a sensor at a non-existing pump.")
+
+        self.__pump_efficiency_sensors = pump_efficiency_sensors
+
+        self.__compute_indices()
+
     @property
     def tank_volume_sensors(self) -> list[str]:
         """
@@ -1647,6 +1779,46 @@ class SensorConfig(JsonSerializable):
         """
         return deepcopy(self.__sensors_id_to_idx)
 
+    def get_as_dict(self) -> dict:
+        """
+        Gets the sensor configuration as a dictionary.
+
+        Returns
+        -------
+        `dict`
+            Dictionary of set sensors -- the keys are the sensor types.
+        """
+        r = {}
+
+        if self.__pressure_sensors != []:
+            r["pressure"] = self.__pressure_sensors
+        if self.__flow_sensors != []:
+            r["flow"] = self.__flow_sensors
+        if self.__demand_sensors != []:
+            r["demand"] = self.__demand_sensors
+        if self.__tank_volume_sensors != []:
+            r["tank_volume"] = self.__tank_volume_sensors
+        if self.__valve_state_sensors != []:
+            r["valve_state"] = self.__valve_state_sensors
+        if self.__pump_state_sensors != []:
+            r["pump_state"] = self.__pump_state_sensors
+        if self.__pump_efficiency_sensors != []:
+            r["pump_efficiency"] = self.__pump_efficiency_sensors
+        if self.__pump_energyconsumption_sensors != []:
+            r["pump_energyconsumption"] = self.__pump_energyconsumption_sensors
+        if self.__quality_node_sensors != []:
+            r["node_quality"] = self.__quality_node_sensors
+        if self.__quality_link_sensors != []:
+            r["link_quality"] = self.__quality_link_sensors
+        if self.__bulk_species_node_sensors != {}:
+            r["node_bulk_species"] = self.__bulk_species_node_sensors
+        if self.__bulk_species_link_sensors != {}:
+            r["link_bulk_species"] = self.__bulk_species_link_sensors
+        if self.__surface_species_sensors != {}:
+            r["surface_species"] = self.__surface_species_sensors
+
+        return r
+
     def get_attributes(self) -> dict:
         attr = {"nodes": self.__nodes, "links": self.__links,
                 "valves": self.__valves, "pumps": self.__pumps,
@@ -1659,6 +1831,8 @@ class SensorConfig(JsonSerializable):
                 "quality_link_sensors": self.__quality_link_sensors,
                 "valve_state_sensors": self.__valve_state_sensors,
                 "pump_state_sensors": self.__pump_state_sensors,
+                "pump_efficiency_sensors": self.__pump_efficiency_sensors,
+                "pump_energyconsumption_sensors": self.__pump_energyconsumption_sensors,
                 "tank_volume_sensors": self.__tank_volume_sensors,
                 "bulk_species_node_sensors": self.__bulk_species_node_sensors,
                 "bulk_species_link_sensors": self.__bulk_species_link_sensors,
@@ -1694,6 +1868,8 @@ class SensorConfig(JsonSerializable):
             and self.__quality_link_sensors == other.quality_link_sensors \
             and self.__valve_state_sensors == other.valve_state_sensors \
             and self.__pump_state_sensors == other.pump_state_sensors \
+            and self.__pump_efficiency_sensors == other.pump_efficiency_sensors \
+            and self.__pump_energyconsumption_sensors == other.pump_energyconsumption_sensors \
             and self.__tank_volume_sensors == other.tank_volume_sensors \
             and self.__bulk_species_node_sensors == other.bulk_species_node_sensors \
             and self.__bulk_species_link_sensors == other.bulk_species_link_sensors \
@@ -1719,13 +1895,15 @@ class SensorConfig(JsonSerializable):
             f"pump_id_to_idx: {self.__pump_id_to_idx} tank_id_to_idx: {self.__tank_id_to_idx} " +\
             f"valve_id_to_idx: {self.__valve_id_to_idx} " +\
             f"bulkspecies_id_to_idx: {self.__bulkspecies_id_to_idx} " +\
-            f"surfacespecies_id_to_idx: {self.__surfacespecies_id_to_idx}" +\
+            f"surfacespecies_id_to_idx: {self.__surfacespecies_id_to_idx} " +\
             f"pressure_sensors: {self.__pressure_sensors} flow_sensors: {self.__flow_sensors} " +\
             f"demand_sensors: {self.__demand_sensors} " +\
             f"quality_node_sensors: {self.__quality_node_sensors} " +\
             f"quality_link_sensors: {self.__quality_link_sensors} " +\
             f"valve_state_sensors: {self.__valve_state_sensors} " +\
             f"pump_state_sensors: {self.__pump_state_sensors} " +\
+            f"pump_efficiency_sensors: {self.__pump_efficiency_sensors} " +\
+            f"pump_energyconsumption_sensors: {self.__pump_energyconsumption_sensors} " +\
             f"tank_volume_sensors: {self.__tank_volume_sensors} " +\
             f"bulk_species_node_sensors: {self.__bulk_species_node_sensors} " +\
             f"bulk_species_link_sensors: {self.__bulk_species_link_sensors} " +\
@@ -1740,7 +1918,8 @@ class SensorConfig(JsonSerializable):
 
     def compute_readings(self, pressures: np.ndarray, flows: np.ndarray, demands: np.ndarray,
                          nodes_quality: np.ndarray, links_quality: np.ndarray,
-                         pumps_state: np.ndarray, valves_state: np.ndarray,
+                         pumps_state: np.ndarray, pumps_efficiency: np.ndarray,
+                         pumps_energyconsumption: np.ndarray, valves_state: np.ndarray,
                          tanks_volume: np.ndarray, bulk_species_node_concentrations: np.ndarray,
                          bulk_species_link_concentrations: np.ndarray,
                          surface_species_concentrations: np.ndarray) -> np.ndarray:
@@ -1762,6 +1941,10 @@ class SensorConfig(JsonSerializable):
             Quality values at all links/pipes.
         pumps_state : `numpy.ndarray`
             States of all pumps.
+        pumps_efficiency : `numpy.ndarray`
+            Efficiency of all pumps.
+        pumps_energyconsumption : `numpy.ndarray`
+            Energy consumption of all pumps.
         valves_state : `numpy.ndarray`
             States of all valves.
         tanks_volume : `numpy.ndarray`
@@ -1838,6 +2021,20 @@ class SensorConfig(JsonSerializable):
                 raise ValueError("Pump states readings requested " +
                                  "but no pump state data is given")
 
+        if pumps_efficiency is not None:
+            data.append(pumps_efficiency[:, self.__pump_efficiency_idx])
+        else:
+            if len(self.__pump_efficiency_sensors) != 0:
+                raise ValueError("Pump efficiency readings requested " +
+                                 "but no pump efficiency data is given")
+
+        if pumps_energyconsumption is not None:
+            data.append(pumps_energyconsumption[:, self.__pump_energyconsumption_idx])
+        else:
+            if len(self.__pump_energyconsumption_sensors) != 0:
+                raise ValueError("Pump energy consumption readings requested " +
+                                 "but no pump energy consumption data is given")
+
         if tanks_volume is not None:
             data.append(tanks_volume[:, self.__tank_volume_idx])
         else:
@@ -1877,7 +2074,9 @@ class SensorConfig(JsonSerializable):
     def get_index_of_reading(self, pressure_sensor: str = None, flow_sensor: str = None,
                              demand_sensor: str = None, node_quality_sensor: str = None,
                              link_quality_sensor: str = None, valve_state_sensor: str = None,
-                             pump_state_sensor: str = None, tank_volume_sensor: str = None,
+                             pump_state_sensor: str = None, pump_efficiency_sensor: str = None,
+                             pump_energyconsumption_sensor: str = None,
+                             tank_volume_sensor: str = None,
                              bulk_species_node_sensor: tuple[str, str] = None,
                              bulk_species_link_sensor: tuple[str, str] = None,
                              surface_species_sensor: tuple[str, str] = None) -> int:
@@ -1907,6 +2106,10 @@ class SensorConfig(JsonSerializable):
             ID of the state sensor (at a valve).
         pump_state_sensor : `str`
             ID of the state sensor (at a pump).
+        pump_efficiency_sensor : `str`
+            ID of the efficiency sensor (at a pump).
+        pump_energyconsumption_sensor : `str`
+            ID of the energy consumption sensor (at a pump).
         tank_volume_sensor : `str`
             ID of the water volume sensor (at a tank)
         bulk_species_node_sensor : `tuple[str, str]`
@@ -1930,6 +2133,10 @@ class SensorConfig(JsonSerializable):
             return self.__sensors_id_to_idx["valve_state"][valve_state_sensor]
         elif pump_state_sensor is not None:
             return self.__sensors_id_to_idx["pump_state"][pump_state_sensor]
+        elif pump_efficiency_sensor is not None:
+            return self.__sensors_id_to_idx["pump_efficiency"][pump_efficiency_sensor]
+        elif pump_energyconsumption_sensor is not None:
+            return self.__sensors_id_to_idx["pump_energyconsumption"][pump_energyconsumption_sensor]
         elif tank_volume_sensor is not None:
             return self.__sensors_id_to_idx["tank_volume"][tank_volume_sensor]
         elif surface_species_sensor is not None:

epyt_flow/topology.py

@@ -108,7 +108,7 @@ class NetworkTopology(nx.Graph, JsonSerializable):
 
     def convert_units(self, units: int) -> Any:
         """
-        Converts this instance to a :class:`epyt_flow.topology.NetworkTopology` instance
+        Converts this instance to a :class:`~epyt_flow.topology.NetworkTopology` instance
         where everything is measured in given measurement units category
         (US Customary or SI Metric).
 
@@ -124,7 +124,7 @@ class NetworkTopology(nx.Graph, JsonSerializable):
 
         Returns
         -------
-        :class:`epyt_flow.topology.NetworkTopology`
+        :class:`~epyt_flow.topology.NetworkTopology`
             Network topology with the new measurements units.
         """
         if self.__units is None:
@@ -188,6 +188,17 @@ class NetworkTopology(nx.Graph, JsonSerializable):
         """
         return [node_id for node_id, _ in self.__nodes]
 
+    def get_number_of_nodes(self) -> int:
+        """
+        Returns the number of nodes.
+
+        Returns
+        -------
+        `int`
+            Number of nodes.
+        """
+        return len(self.get_all_nodes())
+
     def get_all_links(self) -> list[tuple[str, tuple[str, str]]]:
         """
         Gets a list of all links/pipes (incl. their end points).
@@ -199,6 +210,131 @@ class NetworkTopology(nx.Graph, JsonSerializable):
         """
         return [(link_id, end_points) for link_id, end_points, _ in self.__links]
 
+    def get_number_of_links(self) -> int:
+        """
+        Returns the number of links.
+
+        Returns
+        -------
+        `int`
+            Number of links.
+        """
+        return len(self.get_all_links())
+
+    def get_all_junctions(self) -> list[str]:
+        """
+        Gets all junctions -- i.e. nodes that are not tanks or reservoirs.
+
+        Returns
+        -------
+        `list[str]`
+            List of all junctions.
+        """
+        r = []
+
+        for node_id in self.get_all_nodes():
+            if self.get_node_info(node_id)["type"] == "JUNCTION":
+                r.append(node_id)
+
+        return r
+
+    def get_number_of_junctions(self) -> int:
+        """
+        Returns the number of junctions.
+
+        Returns
+        -------
+        `int`
+            Number of junctions.
+        """
+        return len(self.get_all_junctions())
+
+    def get_all_tanks(self) -> list[str]:
+        """
+        Gets all tanks -- i.e. nodes that are not junctions or reservoirs.
+
+        Returns
+        -------
+        `list[str]`
+            List of all tanks.
+        """
+        r = []
+
+        for node_id in self.get_all_nodes():
+            if self.get_node_info(node_id)["type"] == "TANK":
+                r.append(node_id)
+
+        return r
+
+    def get_number_of_tanks(self) -> int:
+        """
+        Returns the number of tanks.
+
+        Returns
+        -------
+        `int`
+            Number of tanks.
+        """
+        return len(self.get_all_tanks())
+
+    def get_all_reservoirs(self) -> list[str]:
+        """
+        Gets all reservoirs -- i.e. nodes that are not junctions or tanks.
+
+        Returns
+        -------
+        `list[str]`
+            List of all reservoirs.
+        """
+        r = []
+
+        for node_id in self.get_all_nodes():
+            if self.get_node_info(node_id)["type"] == "RESERVOIR":
+                r.append(node_id)
+
+        return r
+
+    def get_number_of_reservoirs(self) -> int:
+        """
+        Returns the number of reservoirs.
+
+        Returns
+        -------
+        `int`
+            Number of reservoirs.
+        """
+        return len(self.get_all_reservoirs())
+
+    def get_all_pipes(self) -> list[tuple[str, tuple[str, str]]]:
+        """
+        Gets all pipes -- i.e. links that not valves or pumps.
+
+        Returns
+        -------
+        `list[tuple[str, tuple[str, str]]]`
+            List of all pipes -- (link ID, (left node ID, right node ID)).
+        """
+        r = []
+
+        for link_id, link_nodes in self.get_all_links():
+            link_info = self.get_link_info(link_id)
+
+            if link_info["type"] == "PIPE":
+                r.append((link_id, link_nodes))
+
+        return r
+
+    def get_number_of_pipes(self) -> int:
+        """
+        Returns the number of pipes.
+
+        Returns
+        -------
+        `int`
+            Number of pipes.
+        """
+        return len(self.get_all_pipes())
+
     def get_all_pumps(self) -> list[str]:
         """
         Gets the IDs of all pumps.
@@ -208,7 +344,18 @@ class NetworkTopology(nx.Graph, JsonSerializable):
         `list[str]`
             Pump IDs.
         """
-        return self.__pumps.keys()
+        return list(self.__pumps.keys())
+
+    def get_number_of_pumps(self) -> int:
+        """
+        Returns the number of pumps.
+
+        Returns
+        -------
+        `int`
+            Number of pumps.
+        """
+        return len(self.get_all_pumps())
 
     def get_all_valves(self) -> list[str]:
         """
@@ -219,7 +366,18 @@ class NetworkTopology(nx.Graph, JsonSerializable):
         `list[str]`
             Valve IDs.
         """
-        return self.__valves.keys()
+        return list(self.__valves.keys())
+
+    def get_number_of_valves(self) -> int:
+        """
+        Returns the number of valves.
+
+        Returns
+        -------
+        `int`
+            Number of valves.
+        """
+        return len(self.get_all_valves())
 
     def get_node_info(self, node_id: str) -> dict:
         """

epyt_flow/utils.py

@@ -153,8 +153,10 @@ def plot_timeseries_data(data: np.ndarray, labels: list[str] = None, x_axis_labe
 
 
 def plot_timeseries_prediction(y: np.ndarray, y_pred: np.ndarray,
-                               confidence_interval: np.ndarray = None, show: bool = True,
-                               ax: matplotlib.axes.Axes = None) -> matplotlib.axes.Axes:
+                               confidence_interval: np.ndarray = None,
+                               x_axis_label: str = None, y_axis_label: str = None,
+                               show: bool = True, ax: matplotlib.axes.Axes = None
+                               ) -> matplotlib.axes.Axes:
     """
     Plots the prediction (e.g. forecast) of *single* time series together with the
     ground truth time series. In addition, confidence intervals can be plotted as well.
@@ -169,6 +171,14 @@ def plot_timeseries_prediction(y: np.ndarray, y_pred: np.ndarray,
         Confidence interval (upper and lower value) for each prediction in `y_pred`.
         If not None, the confidence interval is plotted as well.
 
+        The default is None.
+    x_axis_label : `str`, optional
+        X axis label.
+
+        The default is None.
+    y_axis_label : `str`, optional
+        Y axis label.
+
         The default is None.
     show : `bool`, optional
         If True, the plot/figure is shown in a window.
@@ -198,6 +208,14 @@ def plot_timeseries_prediction(y: np.ndarray, y_pred: np.ndarray,
         raise ValueError("'y_pred' must be a 1d array")
     if len(y.shape) != 1:
         raise ValueError("'y' must be a 1d array")
+    if x_axis_label is not None:
+        if not isinstance(x_axis_label, str):
+            raise TypeError("'x_axis_label' must be an instance of 'str' " +
+                            f"but not of '{type(x_axis_label)}'")
+    if y_axis_label is not None:
+        if not isinstance(y_axis_label, str):
+            raise TypeError("'y_axis_label' must be an instance of 'str' " +
+                            f"but not of '{type(y_axis_label)}'")
     if not isinstance(show, bool):
         raise TypeError(f"'show' must be an instance of 'bool' but not of '{type(show)}'")
     if ax is not None:
@@ -218,6 +236,11 @@ def plot_timeseries_prediction(y: np.ndarray, y_pred: np.ndarray,
     ax.plot(y_pred, ".-", label="Prediction")
     ax.legend()
 
+    if x_axis_label is not None:
+        ax.set_xlabel(x_axis_label)
+    if y_axis_label is not None:
+        ax.set_ylabel(y_axis_label)
+
     if show is True and fig is not None:
         plt.show()
 

{epyt_flow-0.4.0.dist-info → epyt_flow-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: epyt-flow
-Version: 0.4.0
+Version: 0.6.0
 Summary: EPyT-Flow -- EPANET Python Toolkit - Flow
 Author-email: André Artelt <aartelt@techfak.uni-bielefeld.de>, "Marios S. Kyriakou" <kiriakou.marios@ucy.ac.cy>, "Stelios G. Vrachimis" <vrachimis.stelios@ucy.ac.cy>
 License: MIT License
@@ -20,7 +20,7 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: epyt >=1.1.6
+Requires-Dist: epyt >=1.1.9
 Requires-Dist: requests >=2.31.0
 Requires-Dist: scipy >=1.11.4
 Requires-Dist: u-msgpack-python >=2.8.0