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

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} " + \
@@ -415,8 +417,8 @@ class ScenarioConfig(Serializable):
             general_params["demand_model"] = general_settings["demand_model"]
         if "quality_model" in general_settings.keys():
             general_params["quality_model"] = general_settings["quality_model"]
-        if "flow_units" in general_settings.keys():
-            general_params["flow_units"] = general_settings["flow_units"]
+        if "flow_units_id" in general_settings.keys():
+            general_params["flow_units_id"] = general_settings["flow_units_id"]
 
         sensor_config = data["sensors"]
 

epyt_flow/simulation/scenario_simulator.py

@@ -17,8 +17,8 @@ from epyt.epanet import ToolkitConstants
 from tqdm import tqdm
 
 from .scenario_config import ScenarioConfig
-from .sensor_config import SensorConfig, areaunit_to_id, massunit_to_id, qualityunits_to_id, \
-    qualityunits_to_str, MASS_UNIT_MG, \
+from .sensor_config import SensorConfig, areaunit_to_id, massunit_to_id, qualityunit_to_id, \
+    qualityunit_to_str, MASS_UNIT_MG, \
     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_TANK_VOLUME, SENSOR_TYPE_VALVE_STATE, \
@@ -137,7 +137,7 @@ class ScenarioSimulator():
                                   tank_id_to_idx: dict = None, bulkspecies_id_to_idx: dict = None,
                                   surfacespecies_id_to_idx: dict = None) -> SensorConfig:
         flow_unit = self.epanet_api.api.ENgetflowunits()
-        quality_unit = qualityunits_to_id(self.epanet_api.getQualityInfo().QualityChemUnits)
+        quality_unit = qualityunit_to_id(self.epanet_api.getQualityInfo().QualityChemUnits)
         bulk_species = []
         surface_species = []
         bulk_species_mass_unit = []
@@ -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"
@@ -691,7 +694,7 @@ class ScenarioSimulator():
         return {"code": qual_info.QualityCode,
                 "type": qual_info.QualityType,
                 "chemical_name": qual_info.QualityChemName,
-                "units": qualityunits_to_id(qual_info.QualityChemUnits),
+                "units": qualityunit_to_id(qual_info.QualityChemUnits),
                 "trace_node_id": qual_info.TraceNode}
 
     def get_scenario_config(self) -> ScenarioConfig:
@@ -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()}
 
@@ -761,8 +765,12 @@ class ScenarioSimulator():
         nodes_id = self.epanet_api.getNodeNameID()
         nodes_elevation = self.epanet_api.getNodeElevations()
         nodes_type = [self.epanet_api.TYPENODE[i] for i in self.epanet_api.getNodeTypeIndex()]
+        nodes_coord = [self.epanet_api.api.ENgetcoord(node_idx)
+                       for node_idx in self.epanet_api.getNodeIndex()]
+        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()
@@ -771,22 +779,49 @@ 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, node_elevation, node_type in zip(nodes_id, nodes_elevation, nodes_type):
-            nodes.append((node, {"elevation": node_elevation, "type": node_type}))
+        for node_id, node_elevation, node_type, node_coord in zip(nodes_id, nodes_elevation,
+                                                                  nodes_type, nodes_coord):
+            node_info = {"elevation": node_elevation,
+                         "coord": node_coord,
+                         "type": node_type}
+            if node_type == "TANK":
+                node_tank_idx = node_tank_names.index(node_id) + 1
+                node_info["diameter"] = float(self.epanet_api.getNodeTankDiameter(node_tank_idx))
 
-        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}))
+            nodes.append((node_id, node_info))
 
-        return NetworkTopology(f_inp=self.f_inp_in, nodes=nodes, links=links,
-                               units=self.get_units_category())
+        links = []
+        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:
         """
@@ -1739,8 +1774,7 @@ class ScenarioSimulator():
                 # Fetch data
                 pressure_data = self.epanet_api.getNodePressure().reshape(1, -1)
                 flow_data = self.epanet_api.getLinkFlows().reshape(1, -1)
-                demand_data = self.epanet_api.getNodeActualDemand().reshape(1,
-                                                                            -1)  # TODO: Does not go back after emitter coefficient is changed back to zero
+                demand_data = self.epanet_api.getNodeActualDemand().reshape(1, -1)
                 quality_node_data = self.epanet_api.getNodeActualQuality().reshape(1, -1)
                 quality_link_data = self.epanet_api.getLinkActualQuality().reshape(1, -1)
                 pumps_state_data = self.epanet_api.getLinkPumpState().reshape(1, -1)
@@ -1808,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
@@ -1841,7 +1875,7 @@ class ScenarioSimulator():
     def set_general_parameters(self, demand_model: dict = None, simulation_duration: int = None,
                                hydraulic_time_step: int = None, quality_time_step: int = None,
                                reporting_time_step: int = None, reporting_time_start: int = None,
-                               flow_units: int = None, quality_model: dict = None) -> None:
+                               flow_units_id: int = None, quality_model: dict = None) -> None:
         """
         Sets some general parameters.
 
@@ -1886,22 +1920,22 @@ class ScenarioSimulator():
             Start time (in seconds) at which reporting of hydraulic and quality states starts.
 
             The default is None.
-        flow_units : `int`, optional
+        flow_units_id : `int`, optional
             Specifies the flow units -- i.e. all flows will be reported in these units.
             If None, the units from the .inp file will be used.
 
             Must be one of the following EPANET toolkit constants:
 
-                - EN_CFS = 0 (cu foot/sec)
-                - EN_GPM = 1 (gal/min)
-                - EN_MGD = 2 (Million gal/day)
-                - EN_IMGD = 3 (Imperial MGD)
-                - EN_AFD = 4 (ac-foot/day)
-                - EN_LPS = 5 (liter/sec)
-                - EN_LPM = 6 (liter/min)
-                - EN_MLD = 7 (Megaliter/day)
-                - EN_CMH = 8 (cubic meter/hr)
-                - EN_CMD = 9 (cubic meter/day)
+                - EN_CFS  = 0  (cubic foot/sec)
+                - EN_GPM  = 1  (gal/min)
+                - EN_MGD  = 2  (Million gal/day)
+                - EN_IMGD = 3  (Imperial MGD)
+                - EN_AFD  = 4  (ac-foot/day)
+                - EN_LPS  = 5  (liter/sec)
+                - EN_LPM  = 6  (liter/min)
+                - EN_MLD  = 7  (Megaliter/day)
+                - EN_CMH  = 8  (cubic meter/hr)
+                - EN_CMD  = 9  (cubic meter/day)
 
             The default is None.
         quality_model : `dict`, optional
@@ -1922,8 +1956,7 @@ class ScenarioSimulator():
             if not isinstance(simulation_duration, int) or simulation_duration <= 0:
                 raise ValueError("'simulation_duration' must be a positive integer specifying " +
                                  "the number of seconds to simulate")
-            self.epanet_api.setTimeSimulationDuration(simulation_duration)  # TODO: Changing the simulation
-            # duration from .inp file seems to break EPANET-MSX
+            self.epanet_api.setTimeSimulationDuration(simulation_duration)
 
         if hydraulic_time_step is not None:
             if not isinstance(hydraulic_time_step, int) or hydraulic_time_step <= 0:
@@ -1958,29 +1991,29 @@ class ScenarioSimulator():
                                  "greater than the hydraulic time step")
             self.epanet_api.setTimeQualityStep(quality_time_step)
 
-        if flow_units is not None:
-            if flow_units == ToolkitConstants.EN_CFS:
+        if flow_units_id is not None:
+            if flow_units_id == ToolkitConstants.EN_CFS:
                 self.epanet_api.setFlowUnitsCFS()
-            elif flow_units == ToolkitConstants.EN_GPM:
+            elif flow_units_id == ToolkitConstants.EN_GPM:
                 self.epanet_api.setFlowUnitsGPM()
-            elif flow_units == ToolkitConstants.EN_MGD:
+            elif flow_units_id == ToolkitConstants.EN_MGD:
                 self.epanet_api.setFlowUnitsMGD()
-            elif flow_units == ToolkitConstants.EN_IMGD:
+            elif flow_units_id == ToolkitConstants.EN_IMGD:
                 self.epanet_api.setFlowUnitsIMGD()
-            elif flow_units == ToolkitConstants.EN_AFD:
+            elif flow_units_id == ToolkitConstants.EN_AFD:
                 self.epanet_api.setFlowUnitsAFD()
-            elif flow_units == ToolkitConstants.EN_LPS:
+            elif flow_units_id == ToolkitConstants.EN_LPS:
                 self.epanet_api.setFlowUnitsLPS()
-            elif flow_units == ToolkitConstants.EN_LPM:
+            elif flow_units_id == ToolkitConstants.EN_LPM:
                 self.epanet_api.setFlowUnitsLPM()
-            elif flow_units == ToolkitConstants.EN_MLD:
+            elif flow_units_id == ToolkitConstants.EN_MLD:
                 self.epanet_api.setFlowUnitsMLD()
-            elif flow_units == ToolkitConstants.EN_CMH:
+            elif flow_units_id == ToolkitConstants.EN_CMH:
                 self.epanet_api.setFlowUnitsCMH()
-            elif flow_units == ToolkitConstants.EN_CMD:
+            elif flow_units_id == ToolkitConstants.EN_CMD:
                 self.epanet_api.setFlowUnitsCMD()
             else:
-                raise ValueError(f"Unknown flow units '{flow_units}'")
+                raise ValueError(f"Unknown flow units '{flow_units_id}'")
 
         if quality_model is not None:
             if quality_model["type"] == "NONE":
@@ -1989,7 +2022,7 @@ class ScenarioSimulator():
                 self.epanet_api.setQualityType("age")
             elif quality_model["type"] == "CHEM":
                 self.epanet_api.setQualityType("chem", quality_model["chemical_name"],
-                                               qualityunits_to_str(quality_model["units"]))
+                                               qualityunit_to_str(quality_model["units"]))
             elif quality_model["type"] == "TRACE":
                 self.epanet_api.setQualityType("trace", quality_model["trace_node_id"])
             else: