epyt-flow 0.3.0__tar.gz → 0.4.0__tar.gz

{epyt_flow-0.3.0 → epyt_flow-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: epyt-flow
-Version: 0.3.0
+Version: 0.4.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
@@ -30,6 +30,7 @@ Requires-Dist: tqdm>=4.66.2
 Requires-Dist: openpyxl>=3.1.2
 Requires-Dist: falcon>=3.1.3
 Requires-Dist: multiprocess>=0.70.16
+Requires-Dist: geopandas>=0.14.4
 Requires-Dist: psutil
 
 [![pypi](https://img.shields.io/pypi/v/epyt-flow.svg)](https://pypi.org/project/epyt-flow/)

{epyt_flow-0.3.0 → epyt_flow-0.4.0}/REQUIREMENTS.txt

@@ -8,4 +8,5 @@ tqdm>=4.66.2
 openpyxl>=3.1.2
 falcon>=3.1.3
 multiprocess>=0.70.16
+geopandas>=0.14.4
 psutil

epyt_flow-0.4.0/epyt_flow/VERSION

@@ -0,0 +1 @@
+0.4.0

{epyt_flow-0.3.0 → epyt_flow-0.4.0}/epyt_flow/data/benchmarks/leakdb.py

@@ -543,7 +543,7 @@ def load_scenarios(scenarios_id: list[int], use_net1: bool = True,
 
     my_uncertainties = {"pipe_length_uncertainty": MyUniformUncertainty(low=0, high=0.25),
                         "pipe_roughness_uncertainty": MyUniformUncertainty(low=0, high=0.25),
-                        "demand_base_uncertainty": MyUniformUncertainty(low=0, high=0.25)}
+                        "base_demand_uncertainty": MyUniformUncertainty(low=0, high=0.25)}
     model_uncertainty = ModelUncertainty(**my_uncertainties)
 
     # Create sensor config (place pressure and flow sensors everywhere)

{epyt_flow-0.3.0 → epyt_flow-0.4.0}/epyt_flow/simulation/events/leakages.py

@@ -182,7 +182,7 @@ class Leakage(SystemEvent, JsonSerializable):
             raise TypeError(f"Can not compare 'Leakage' instance with '{type(other)}' instance")
 
         return super().__eq__(other) and self.__link_id == other.link_id \
-            and self.__diameter == other.diameter and self.__profile == other.profile \
+            and self.__diameter == other.diameter and np.all(self.__profile == other.profile) \
             and self.__node_id == other.node_id and self.area == other.area
 
     def __str__(self) -> str:

{epyt_flow-0.3.0 → epyt_flow-0.4.0}/epyt_flow/simulation/parallel_simulation.py

@@ -1,7 +1,7 @@
 """
 Module provides functions for simulating several scenarios in parallel.
 """
-from typing import Callable
+from typing import Callable, Any
 import os
 import warnings
 from multiprocess import Pool, cpu_count
@@ -38,9 +38,9 @@ def callback_save_to_file(folder_out: str = "") -> Callable[[ScadaData, Scenario
 
 
 def _run_scenario_simulation(scenario_config: ScenarioConfig, scenario_idx: int,
-                             callback: Callable[[ScadaData, ScenarioConfig, int], None]) -> None:
+                             callback: Callable[[ScadaData, ScenarioConfig, int], Any]) -> Any:
     with ScenarioSimulator(scenario_config=scenario_config) as sim:
-        callback(sim.run_simulation(), scenario_config, scenario_idx)
+        return callback(sim.run_simulation(), scenario_config, scenario_idx)
 
 
 class ParallelScenarioSimulation():
@@ -50,8 +50,8 @@ class ParallelScenarioSimulation():
     @staticmethod
     def run(scenarios: list[ScenarioConfig], n_jobs: int = -1,
             max_working_memory_consumption: int = None,
-            callback: Callable[[ScadaData, ScenarioConfig, int], None] = callback_save_to_file()
-            ) -> None:
+            callback: Callable[[ScadaData, ScenarioConfig, int], Any] = callback_save_to_file()
+            ) -> Any:
         """
         Simulates multiple scenarios in parallel.
 
@@ -76,7 +76,7 @@ class ParallelScenarioSimulation():
 
             The callback gets the simulation results as a
             :class:`~epyt_flow.simulation.scada.scada_data.ScadaData` instance, the scenario
-            configuration as a :class: `epyt_flow.simulation.scenario_config.ScenarioConfig`
+            configuration as a :class:`~epyt_flow.simulation.scenario_config.ScenarioConfig`
             instance, and the index of the scenario in 'scenarios' as arguments.
 
             The default is :func:`~epyt_flow.simulation.parallel_simulation.callback_save_to_file`.
@@ -144,4 +144,4 @@ class ParallelScenarioSimulation():
             scenarios_task.append((scenario, scenario_idx, callback))
 
         with Pool(processes=n_parallel_scenarios, maxtasksperchild=1) as pool:
-            pool.starmap(_run_scenario_simulation, scenarios_task)
+            return pool.starmap(_run_scenario_simulation, scenarios_task)

{epyt_flow-0.3.0 → epyt_flow-0.4.0}/epyt_flow/simulation/scada/scada_data_export.py

@@ -109,7 +109,7 @@ class ScadaDataExport():
 
         def __get_sensor_unit(sensor_type):
             if sensor_type == "pressure":
-                if is_flowunit_simetric(scada_data.sensor_config.flow_unit):
+                if not is_flowunit_simetric(scada_data.sensor_config.flow_unit):
                     return "psi"
                 else:
                     return "meter"

{epyt_flow-0.3.0 → epyt_flow-0.4.0}/epyt_flow/simulation/scenario_config.py

@@ -4,6 +4,7 @@ Module provides a class for specifying scenario configurations.
 from typing import Any
 from copy import deepcopy
 import json
+import numpy as np
 
 from ..uncertainty import AbsoluteGaussianUncertainty, RelativeGaussianUncertainty, \
     AbsoluteUniformUncertainty, RelativeUniformUncertainty, ModelUncertainty, \
@@ -350,10 +351,11 @@ class ScenarioConfig(Serializable):
         return self.__f_inp_in == other.f_inp_in and self.__f_msx_in == other.f_msx_in \
             and self.__general_params == other.general_params \
             and self.__memory_consumption_estimate == other.memory_consumption_estimate \
-            and self.__sensor_config == other.sensor_config and self.__controls == other.controls \
+            and self.__sensor_config == other.sensor_config \
+            and np.all(self.__controls == other.controls) \
             and self.__model_uncertainty == other.model_uncertainty \
-            and self.__system_events == other.system_events \
-            and self.__sensor_reading_events == other.sensor_reading_events
+            and np.all(self.__system_events == other.system_events) \
+            and np.all(self.__sensor_reading_events == other.sensor_reading_events)
 
     def __str__(self) -> str:
         return f"f_inp_in: {self.f_inp_in} f_msx_in: {self.f_msx_in} " + \

{epyt_flow-0.3.0 → epyt_flow-0.4.0}/epyt_flow/simulation/scenario_simulator.py

@@ -298,6 +298,7 @@ class ScenarioSimulator():
 
         return deepcopy(list(filter(lambda e: isinstance(e, Leakage), self.__system_events)))
 
+    @property
     def actuator_events(self) -> list[ActuatorEvent]:
         """
         Gets all actuator events.
@@ -483,6 +484,7 @@ class ScenarioSimulator():
 
         if inp_file_path is not None:
             self.epanet_api.saveInputFile(inp_file_path)
+            self.__f_inp_in = inp_file_path
 
             if export_sensor_config is True:
                 report_desc = "\n\n[REPORT]\n"
@@ -537,6 +539,7 @@ class ScenarioSimulator():
 
         if self.__f_msx_in is not None and msx_file_path is not None:
             self.epanet_api.saveMSXFile(msx_file_path)
+            self.__f_msx_in = msx_file_path
 
             if export_sensor_config is True:
                 report_desc = "\n\n[REPORT]\n"
@@ -708,8 +711,9 @@ class ScenarioSimulator():
 
         general_params = {"hydraulic_time_step": self.get_hydraulic_time_step(),
                           "quality_time_step": self.get_quality_time_step(),
+                          "reporting_time_step": self.epanet_api.getTimeReportingStep(),
                           "simulation_duration": self.get_simulation_duration(),
-                          "flow_units": self.get_flow_units(),
+                          "flow_units_id": self.get_flow_units(),
                           "quality_model": self.get_quality_model(),
                           "demand_model": self.get_demand_model()}
 
@@ -766,6 +770,7 @@ class ScenarioSimulator():
         node_tank_names = self.epanet_api.getNodeTankNameID()
 
         links_id = self.epanet_api.getLinkNameID()
+        links_type = self.epanet_api.getLinkType()
         links_data = self.epanet_api.getNodesConnectingLinksID()
         links_diameter = self.epanet_api.getLinkDiameter()
         links_length = self.epanet_api.getLinkLength()
@@ -774,6 +779,11 @@ class ScenarioSimulator():
         links_wall_coeff = self.epanet_api.getLinkWallReactionCoeff()
         links_loss_coeff = self.epanet_api.getLinkMinorLossCoeff()
 
+        pumps_id = self.epanet_api.getLinkPumpNameID()
+        pumps_type = self.epanet_api.getLinkPumpType()
+
+        valves_id = self.epanet_api.getLinkValveNameID()
+
         # Build graph describing the topology
         nodes = []
         for node_id, node_elevation, node_type, node_coord in zip(nodes_id, nodes_elevation,
@@ -788,16 +798,30 @@ class ScenarioSimulator():
             nodes.append((node_id, node_info))
 
         links = []
-        for link_id, link, diameter, length, roughness_coeff, bulk_coeff, wall_coeff, loss_coeff \
-                in zip(links_id, links_data, links_diameter, links_length, links_roughness_coeff,
-                       links_bulk_coeff, links_wall_coeff, links_loss_coeff):
-            links.append((link_id, link, {"diameter": diameter, "length": length,
-                                          "roughness_coeff": roughness_coeff,
-                                          "bulk_coeff": bulk_coeff, "wall_coeff": wall_coeff,
-                                          "loss_coeff": loss_coeff}))
-
-        return NetworkTopology(f_inp=self.f_inp_in, nodes=nodes, links=links,
-                               units=self.get_units_category())
+        for link_id, link_type, link, diameter, length, roughness_coeff, bulk_coeff, wall_coeff, loss_coeff \
+                in zip(links_id, links_type, links_data, links_diameter, links_length,
+                       links_roughness_coeff, links_bulk_coeff, links_wall_coeff, links_loss_coeff):
+            links.append((link_id, list(link),
+                          {"type": link_type, "diameter": diameter, "length": length,
+                           "roughness_coeff": roughness_coeff,
+                           "bulk_coeff": bulk_coeff, "wall_coeff": wall_coeff,
+                           "loss_coeff": loss_coeff}))
+
+        pumps = {}
+        for pump_id, pump_type in zip(pumps_id, pumps_type):
+            link_idx = links_id.index(pump_id)
+            link = links_data[link_idx]
+            pumps[pump_id] = {"type": pump_type, "end_points": link}
+
+        valves = {}
+        for valve_id in valves_id:
+            link_idx = links_id.index(valve_id)
+            link = links_data[link_idx]
+            valve_type = links_type[link_idx]
+            valves[valve_id] = {"type": valve_type, "end_points": link}
+
+        return NetworkTopology(f_inp=self.f_inp_in, nodes=nodes, links=links, pumps=pumps,
+                               valves=valves, units=self.get_units_category())
 
     def randomize_demands(self) -> None:
         """
@@ -1818,14 +1842,14 @@ class ScenarioSimulator():
 
         Parameters
         ----------
-        model_uncertainty : :class:`~epyt_flow.uncertainties.model_uncertainty.ModelUncertainty`
+        model_uncertainty : :class:`~epyt_flow.uncertainty.model_uncertainty.ModelUncertainty`
             Model uncertainty specifications.
         """
         self.__adapt_to_network_changes()
 
         if not isinstance(model_uncertainty, ModelUncertainty):
             raise TypeError("'model_uncertainty' must be an instance of " +
-                            "'epyt_flow.uncertainties.ModelUncertainty' but not of " +
+                            "'epyt_flow.uncertainty.ModelUncertainty' but not of " +
                             f"'{type(model_uncertainty)}'")
 
         self.__model_uncertainty = model_uncertainty

{epyt_flow-0.3.0 → epyt_flow-0.4.0}/epyt_flow/topology.py

@@ -7,6 +7,8 @@ from typing import Any
 import numpy as np
 import networkx as nx
 from scipy.sparse import bsr_array
+from geopandas import GeoDataFrame
+from shapely.geometry import Point, LineString
 
 from .serialization import serializable, JsonSerializable, NETWORK_TOPOLOGY_ID
 
@@ -55,9 +57,15 @@ class NetworkTopology(nx.Graph, JsonSerializable):
         Path to .inp file to which this topology belongs.
     nodes : `list[tuple[str, dict]]`
         List of all nodes -- i.e. node ID and node information such as type and elevation.
-    links : `list[tuple[tuple[str, str], dict]]`
+    links : `list[tuple[str, tuple[str, str], dict]]`
         List of all links/pipes -- i.e. link ID, ID of connecting nodes, and link information
         such as pipe diameter, length, etc.
+    pumps : `dict`
+        List of all pumps -- i.e. valve ID, and information such as
+        pump type and connecting nodes.
+    valves : `dict`
+        List of all valves -- i.e. valve ID, and information such as
+        valve type and connecting nodes.
     units : `int`
         Measurement units category -- i.e. US Customary or SI Metric.
 
@@ -68,12 +76,16 @@ class NetworkTopology(nx.Graph, JsonSerializable):
     """
     def __init__(self, f_inp: str, nodes: list[tuple[str, dict]],
                  links: list[tuple[str, tuple[str, str], dict]],
+                 pumps: dict,
+                 valves: dict,
                  units: int = None,
                  **kwds):
         super().__init__(name=f_inp, **kwds)
 
         self.__nodes = nodes
         self.__links = links
+        self.__pumps = pumps
+        self.__valves = valves
         self.__units = units
 
         if units is None:
@@ -87,11 +99,12 @@ class NetworkTopology(nx.Graph, JsonSerializable):
             self.add_node(node_id, info={"elevation": node_elevation, "type": node_type})
 
         for link_id, link, link_info in links:
+            link_type = link_info["type"]
             link_diameter = link_info["diameter"]
             link_length = link_info["length"]
             self.add_edge(link[0], link[1], length=link_length,
-                          info={"id": link_id, "nodes": link, "diameter": link_diameter,
-                                "length": link_length})
+                          info={"id": link_id, "type": link_type, "nodes": link,
+                                "diameter": link_diameter, "length": link_length})
 
     def convert_units(self, units: int) -> Any:
         """
@@ -161,7 +174,8 @@ class NetworkTopology(nx.Graph, JsonSerializable):
 
             links.append((link_id, link_nodes, link_info))
 
-        return NetworkTopology(f_inp=self.name, nodes=nodes, links=links, units=units)
+        return NetworkTopology(f_inp=self.name, nodes=nodes, links=links, pumps=self.pumps,
+                               valves=self.valves, units=units)
 
     def get_all_nodes(self) -> list[str]:
         """
@@ -185,6 +199,28 @@ class NetworkTopology(nx.Graph, JsonSerializable):
         """
         return [(link_id, end_points) for link_id, end_points, _ in self.__links]
 
+    def get_all_pumps(self) -> list[str]:
+        """
+        Gets the IDs of all pumps.
+
+        Returns
+        -------
+        `list[str]`
+            Pump IDs.
+        """
+        return self.__pumps.keys()
+
+    def get_all_valves(self) -> list[str]:
+        """
+        Gets the IDs of all valves.
+
+        Returns
+        -------
+        `list[str]`
+            Valve IDs.
+        """
+        return self.__valves.keys()
+
     def get_node_info(self, node_id: str) -> dict:
         """
         Gets all information (e.g. elevation, type, etc.) associated with a given node.
@@ -207,17 +243,19 @@ class NetworkTopology(nx.Graph, JsonSerializable):
 
     def get_link_info(self, link_id: str) -> dict:
         """
-        Gets all information (e.g. diameter, length, etc.) associated with a given link/pipe.
+        Gets all information (e.g. diameter, length, etc.) associated with a given link.
+
+        Note that links can be pipes, pumps, or valves.
 
         Parameters
         ----------
         link_id : `str`
-            ID of the link/pipe.
+            ID of the link.
 
         Returns
         -------
         `dict`
-            Information associated with the given link/pipe.
+            Information associated with the given link.
         """
         for link_id_, link_nodes, link_info in self.__links:
             if link_id_ == link_id:
@@ -225,6 +263,68 @@ class NetworkTopology(nx.Graph, JsonSerializable):
 
         raise ValueError(f"Unknown link '{link_id}'")
 
+    def get_pump_info(self, pump_id: str) -> dict:
+        """
+        Gets all information associated with a given pump.
+
+        Parameters
+        ----------
+        pump_id : `str`
+            ID of the pump.
+
+        Returns
+        -------
+        `dict`
+            Pump information.
+        """
+        if pump_id in self.__pumps:
+            return self.__pumps[pump_id]
+        else:
+            raise ValueError(f"Unknown pump: '{pump_id}'")
+
+    def get_valve_info(self, valve_id: str) -> dict:
+        """
+        Gets all information associated with a given valve.
+
+        Parameters
+        ----------
+        valve_id : `str`
+            ID of the valve.
+
+        Returns
+        -------
+        `dict`
+            Valve information.
+        """
+        if valve_id in self.__valves:
+            return self.__valves[valve_id]
+        else:
+            raise ValueError(f"Unknown valve: '{valve_id}'")
+
+    @property
+    def pumps(self) -> dict:
+        """
+        Gets all pumps -- i.e. ID and associated information such as the pump type.
+
+        Returns
+        -------
+        `dict`
+            All pumps and their associated information.
+        """
+        return deepcopy(self.__pumps)
+
+    @property
+    def valves(self) -> dict:
+        """
+        Gets all valves -- i.e. ID and associated information such as the valve type.
+
+        Returns
+        -------
+        `dict`
+            All valves and their associated information.
+        """
+        return deepcopy(self.__valves)
+
     @property
     def units(self) -> int:
         """
@@ -251,18 +351,120 @@ class NetworkTopology(nx.Graph, JsonSerializable):
             self.get_all_nodes() == other.get_all_nodes() \
             and all(link_a[0] == link_b[0] and all(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
+            and self.__units == other.units \
+            and self.__pumps == other.pumps \
+            and self.__valves == other.valves
 
     def __str__(self) -> str:
         return f"f_inp: {self.name} nodes: {self.__nodes} links: {self.__links} " +\
+            f"pumps: {self.__pumps} valves: {self.__valves} " +\
             f"units: {unitscategoryid_to_str(self.__units)}"
 
     def get_attributes(self) -> dict:
         return super().get_attributes() | {"f_inp": self.name,
                                            "nodes": self.__nodes,
                                            "links": self.__links,
+                                           "pumps": self.__pumps,
+                                           "valves": self.__valves,
                                            "units": self.__units}
 
+    def to_gis(self, coord_reference_system: str = None, pumps_as_points: bool = False,
+               valves_as_points: bool = False) -> dict:
+        """
+        Gets the network topology as a dictionary of `geopandas.GeoDataFrames` instances --
+        i.e. each quantity (nodes, links/pipes, valves, etc.) is represented by a
+        `geopandas.GeoDataFrames` instance.
+
+        Parameters
+        ----------
+        coord_reference_system : `str`, optional
+            Coordinate reference system.
+
+            The default is None.
+        pumps_as_points : `bool`, optional
+            If True, pumps are represented by points, otherwise by lines.
+
+            The default is False.
+
+        valves_as_points : `bool`, optional
+            If True, valves are represented by points, otherwise by lines.
+
+            The default is False.
+
+        Returns
+        -------
+        `dict`
+            Network topology as a dictionary of `geopandas.GeoDataFrames` instances.
+            If a quantity does not exist, the data frame will be None.
+        """
+        gis = {"nodes": None, "links": None,
+               "tanks": None, "reservoirs": None,
+               "valves": None, "pumps": None}
+
+        # Nodes
+        node_data = {"id": [], "type": [], "elevation": [], "geometry": []}
+        tank_data = {"id": [], "elevation": [], "diameter": [], "geometry": []}
+        reservoir_data = {"id": [], "elevation": [], "geometry": []}
+        for node_id in self.get_all_nodes():
+            node_info = self.get_node_info(node_id)
+
+            node_data["id"].append(node_id)
+            node_data["type"].append(node_info["type"])
+            node_data["elevation"].append(node_info["elevation"])
+            node_data["geometry"].append(Point(node_info["coord"]))
+
+            if node_info["type"] == "TANK":
+                tank_data["id"].append(node_id)
+                tank_data["elevation"].append(node_info["elevation"])
+                tank_data["diameter"].append(node_info["diameter"])
+                tank_data["geometry"].append(Point(node_info["coord"]))
+            elif node_info["type"] == "RESERVOIR":
+                reservoir_data["id"].append(node_id)
+                reservoir_data["elevation"].append(node_info["elevation"])
+                reservoir_data["geometry"].append(Point(node_info["coord"]))
+
+        gis["nodes"] = GeoDataFrame(node_data, crs=coord_reference_system)
+        gis["tanks"] = GeoDataFrame(tank_data, crs=coord_reference_system)
+        gis["reservoirs"] = GeoDataFrame(reservoir_data, crs=coord_reference_system)
+
+        # Links
+        pipe_data = {"id": [], "type": [], "end_point_a": [], "end_point_b": [],
+                     "length": [], "diameter": [], "geometry": []}
+        valve_data = {"id": [], "type": [], "geometry": []}
+        pump_data = {"id": [], "type": [], "geometry": []}
+        for link_id, link_nodes in self.get_all_links():
+            link_info = self.get_link_info(link_id)
+            end_points_coord = [self.get_node_info(n)["coord"] for n in link_nodes]
+
+            if link_info["type"] == "PIPE":
+                pipe_data["id"].append(link_id)
+                pipe_data["type"].append(link_info["type"])
+                pipe_data["end_point_a"].append(link_nodes[0])
+                pipe_data["end_point_b"].append(link_nodes[1])
+                pipe_data["length"].append(link_info["length"])
+                pipe_data["diameter"].append(link_info["diameter"])
+                pipe_data["geometry"].append(LineString(end_points_coord))
+            elif link_info["type"] == "PUMP":
+                pump_data["id"].append(link_id)
+                pump_data["type"].append(self.get_pump_info(link_id)["type"])
+                if pumps_as_points is True:
+                    pump_data["geometry"].append(Point(end_points_coord[0]))
+                else:
+                    pump_data["geometry"].append(LineString(end_points_coord))
+            else:   # Valve
+                valve_data["id"].append(link_id)
+                valve_data["type"].append(self.get_valve_info[link_id]["type"])
+                if valves_as_points is True:
+                    valve_data["geometry"].append(Point(end_points_coord[0]))
+                else:
+                    valve_data["geometry"].append(LineString(end_points_coord))
+
+        gis["pipes"] = GeoDataFrame(pipe_data, crs=coord_reference_system)
+        gis["valves"] = GeoDataFrame(valve_data, crs=coord_reference_system)
+        gis["pumps"] = GeoDataFrame(pump_data, crs=coord_reference_system)
+
+        return gis
+
     def get_adj_matrix(self) -> bsr_array:
         """
         Gets the adjacency matrix of this graph.