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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: epyt-flow
-Version: 0.3.0
+Version: 0.5.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.5.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.5.0/epyt_flow/VERSION

@@ -0,0 +1 @@
+0.5.0

{epyt_flow-0.3.0 → epyt_flow-0.5.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.5.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.5.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.5.0}/epyt_flow/simulation/scada/scada_data.py

@@ -1163,6 +1163,9 @@ class ScadaData(Serializable):
             :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.
+
         Returns
         -------
         `numpy.ndarray`
@@ -1180,6 +1183,9 @@ class ScadaData(Serializable):
             :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.
+
         Returns
         -------
         `numpy.ndarray`

{epyt_flow-0.3.0 → epyt_flow-0.5.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.5.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.5.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.5.0}/epyt_flow/simulation/scenario_visualizer.py

@@ -12,7 +12,7 @@ class ScenarioVisualizer():
 
     Parameters
     ----------
-    scenario : :class:`epyt_flow.simulation.scenario_simulator.ScenarioSimulator`
+    scenario : :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`
         Scenario to be visualized.
     """
     def __init__(self, scenario: ScenarioSimulator):

{epyt_flow-0.3.0 → epyt_flow-0.5.0}/epyt_flow/simulation/sensor_config.py

@@ -1647,6 +1647,42 @@ 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.__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,
@@ -1719,7 +1755,7 @@ 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} " +\