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

epyt_flow/simulation/scenario_config.py

@@ -3,6 +3,7 @@ Module provides a class for specifying scenario configurations.
 """
 from typing import Any
 from copy import deepcopy
+import os
 import json
 import numpy as np
 
@@ -219,7 +220,7 @@ class ScenarioConfig(Serializable):
         `str`
             Path to the .inp file.
         """
-        return self.__f_inp_in
+        return os.path.join(self._parent_path, self.__f_inp_in)
 
     @property
     def f_msx_in(self) -> str:
@@ -231,7 +232,10 @@ class ScenarioConfig(Serializable):
         `str`
             Path to the .msx file.
         """
-        return self.__f_msx_in
+        if self.__f_msx_in is None:
+            return None
+        else:
+            return os.path.join(self._parent_path, self.__f_msx_in)
 
     @property
     def general_params(self) -> dict:

epyt_flow/simulation/scenario_simulator.py

@@ -4,6 +4,7 @@ Module provides a class for scenario simulations.
 import sys
 import os
 import pathlib
+import time
 from typing import Generator, Union
 from copy import deepcopy
 import shutil
@@ -21,8 +22,9 @@ from .sensor_config import SensorConfig, areaunit_to_id, massunit_to_id, quality
     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, \
-    SENSOR_TYPE_NODE_BULK_SPECIES, SENSOR_TYPE_LINK_BULK_SPECIES, SENSOR_TYPE_SURFACE_SPECIES
+    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 ..uncertainty import ModelUncertainty, SensorNoise
 from .events import SystemEvent, Leakage, ActuatorEvent, SensorFault, SensorReadingAttack, \
     SensorReadingEvent
@@ -109,12 +111,49 @@ class ScenarioSimulator():
             if os.path.isfile(os.path.join(path_to_custom_libs, libepanetmsx_name)):
                 custom_epanetmsx_lib = os.path.join(path_to_custom_libs, libepanetmsx_name)
 
-        self.epanet_api = epanet(self.__f_inp_in, ph=self.__f_msx_in is None,
-                                 customlib=custom_epanet_lib, loadfile=True,
-                                 display_msg=epanet_verbose)
+        with warnings.catch_warnings():
+            # Treat all warnings as exceptions when trying to load .inp and .msx files
+            warnings.simplefilter('error')
 
-        if self.__f_msx_in is not None:
-            self.epanet_api.loadMSXFile(self.__f_msx_in, customMSXlib=custom_epanetmsx_lib)
+            # Workaround for EPyT bug concerning parallel simulations (see EPyT issue #54):
+            # 1. Create random tmp folder (make sure it is unique!)
+            # 2. Copy .inp and .msx file there
+            # 3. Use those copies  when loading EPyT
+            tmp_folder_path = os.path.join(get_temp_folder(), f"{random.randint(int(1e5), int(1e7))}{time.time()}")
+            pathlib.Path(tmp_folder_path).mkdir(parents=True, exist_ok=False)
+
+            def __file_exists(file_in: str) -> bool:
+                try:
+                    return pathlib.Path(file_in).is_file()
+                except Exception:
+                    return False
+
+            if not __file_exists(self.__f_inp_in):
+                my_f_inp_in = self.__f_inp_in
+                self.__my_f_inp_in = None
+            else:
+                my_f_inp_in = os.path.join(tmp_folder_path, pathlib.Path(self.__f_inp_in).name)
+                shutil.copyfile(self.__f_inp_in, my_f_inp_in)
+                self.__my_f_inp_in = my_f_inp_in
+
+            if self.__f_msx_in is not None:
+                if not __file_exists(self.__f_msx_in):
+                    my_f_msx_in = self.__f_msx_in
+                    self.__my_f_msx_in = None
+                else:
+                    my_f_msx_in = os.path.join(tmp_folder_path, pathlib.Path(self.__f_msx_in).name)
+                    shutil.copyfile(self.__f_msx_in, my_f_msx_in)
+                    self.__my_f_msx_in = my_f_msx_in
+            else:
+                my_f_msx_in = None
+                self.__my_f_msx_in = None
+
+            self.epanet_api = epanet(my_f_inp_in, ph=self.__f_msx_in is None,
+                                     customlib=custom_epanet_lib, loadfile=True,
+                                     display_msg=epanet_verbose)
+
+            if self.__f_msx_in is not None:
+                self.epanet_api.loadMSXFile(my_f_msx_in, customMSXlib=custom_epanetmsx_lib)
 
         self.__sensor_config = self.__get_empty_sensor_config()
         if scenario_config is not None:
@@ -393,6 +432,9 @@ class ScenarioSimulator():
         new_sensor_config.quality_node_sensors = self.__sensor_config.quality_node_sensors
         new_sensor_config.quality_link_sensors = self.__sensor_config.quality_link_sensors
         new_sensor_config.pump_state_sensors = self.__sensor_config.pump_state_sensors
+        new_sensor_config.pump_efficiecy_sensors = self.__sensor_config.pump_efficiency_sensors
+        new_sensor_config.pump_energyconsumption_sensors = self.__sensor_config.\
+            pump_energyconsumption_sensors
         new_sensor_config.valve_state_sensors = self.__sensor_config.valve_state_sensors
         new_sensor_config.tank_volume_sensors = self.__sensor_config.tank_volume_sensors
         new_sensor_config.bulk_species_node_sensors = self.__sensor_config.bulk_species_node_sensors
@@ -412,6 +454,11 @@ class ScenarioSimulator():
 
         self.epanet_api.unload()
 
+        if self.__my_f_inp_in is not None:
+            shutil.rmtree(pathlib.Path(self.__my_f_inp_in).parent)
+        if self.__my_f_msx_in is not None:
+            shutil.rmtree(pathlib.Path(self.__my_f_msx_in).parent)
+
     def __enter__(self):
         return self
 
@@ -756,7 +803,7 @@ class ScenarioSimulator():
 
         Returns
         -------
-        `epyt_flow.topology.NetworkTopology`
+        :class:`~epyt_flow.topology.NetworkTopology`
             Topology of this WDN as a graph.
         """
         self.__adapt_to_network_changes()
@@ -1027,16 +1074,18 @@ class ScenarioSimulator():
         ----------
         sensor_type : `int`
             Sensor type. Must be one of the following:
-                - 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_BULK_SPECIES    = 9
-                - SENSOR_TYPE_SURFACE_SPECIES = 10
+                - 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_BULK_SPECIES           = 9
+                - SENSOR_TYPE_SURFACE_SPECIES        = 10
+                - SENSOR_TYPE_PUMP_EFFICIENCY        = 12
+                - SENSOR_TYPE_PUMP_ENERGYCONSUMPTION = 13
         sensor_locations : `list[str]` or `dict`
             Locations (IDs) of sensors either as a list or as a dict in the case of
             bulk and surface species.
@@ -1057,6 +1106,10 @@ class ScenarioSimulator():
             self.__sensor_config.valve_state_sensors = sensor_locations
         elif sensor_type == SENSOR_TYPE_PUMP_STATE:
             self.__sensor_config.pump_state_sensors = sensor_locations
+        elif sensor_type == SENSOR_TYPE_PUMP_EFFICIENCY:
+            self.__sensor_config.pump_efficiency_sensors = sensor_locations
+        elif sensor_type == SENSOR_TYPE_PUMP_ENERGYCONSUMPTION:
+            self.__sensor_config.pump_energyconsumption_sensors = sensor_locations
         elif sensor_type == SENSOR_TYPE_TANK_VOLUME:
             self.__sensor_config.tank_volume_sensors = sensor_locations
         elif sensor_type == SENSOR_TYPE_NODE_BULK_SPECIES:
@@ -1081,6 +1134,12 @@ class ScenarioSimulator():
         """
         self.set_sensors(SENSOR_TYPE_NODE_PRESSURE, sensor_locations)
 
+    def place_pressure_sensors_everywhere(self) -> None:
+        """
+        Places a pressure sensor at every node in the network.
+        """
+        self.set_pressure_sensors(self.__sensor_config.nodes)
+
     def set_flow_sensors(self, sensor_locations: list[str]) -> None:
         """
         Sets the flow sensors -- i.e. measuring flows at some links/pipes in the network.
@@ -1092,6 +1151,12 @@ class ScenarioSimulator():
         """
         self.set_sensors(SENSOR_TYPE_LINK_FLOW, sensor_locations)
 
+    def place_flow_sensors_everywhere(self) -> None:
+        """
+        Places a flow sensors at every link/pipe in the network.
+        """
+        self.set_flow_sensors(self.__sensor_config.links)
+
     def set_demand_sensors(self, sensor_locations: list[str]) -> None:
         """
         Sets the demand sensors -- i.e. measuring demands at some nodes in the network.
@@ -1103,6 +1168,12 @@ class ScenarioSimulator():
         """
         self.set_sensors(SENSOR_TYPE_NODE_DEMAND, sensor_locations)
 
+    def place_demand_sensors_everywhere(self) -> None:
+        """
+        Places a demand sensor at every node in the network.
+        """
+        self.set_demand_sensors(self.__sensor_config.nodes)
+
     def set_node_quality_sensors(self, sensor_locations: list[str]) -> None:
         """
         Sets the node quality sensors -- i.e. measuring the water quality
@@ -1115,6 +1186,12 @@ class ScenarioSimulator():
         """
         self.set_sensors(SENSOR_TYPE_NODE_QUALITY, sensor_locations)
 
+    def place_node_quality_sensors_everywhere(self) -> None:
+        """
+        Places a water quality sensor at every node in the network.
+        """
+        self.set_node_quality_sensors(self.__sensor_config.nodes)
+
     def set_link_quality_sensors(self, sensor_locations: list[str]) -> None:
         """
         Sets the link quality sensors -- i.e. measuring the water quality
@@ -1127,6 +1204,12 @@ class ScenarioSimulator():
         """
         self.set_sensors(SENSOR_TYPE_LINK_QUALITY, sensor_locations)
 
+    def place_link_quality_sensors_everywhere(self) -> None:
+        """
+        Places a water quality sensor at every link/pipe in the network.
+        """
+        self.set_link_quality_sensors(self.__sensor_config.links)
+
     def set_valve_sensors(self, sensor_locations: list[str]) -> None:
         """
         Sets the valve state sensors -- i.e. retrieving the state of some valves in the network.
@@ -1138,7 +1221,16 @@ class ScenarioSimulator():
         """
         self.set_sensors(SENSOR_TYPE_VALVE_STATE, sensor_locations)
 
-    def set_pump_sensors(self, sensor_locations: list[str]) -> None:
+    def place_valve_sensors_everywhere(self) -> None:
+        """
+        Places a valve state sensor at every valve in the network.
+        """
+        if len(self.__sensor_config.valves) == 0:
+            warnings.warn("Network does not contain any valves", UserWarning)
+
+        self.set_valve_sensors(self.__sensor_config.valves)
+
+    def set_pump_state_sensors(self, sensor_locations: list[str]) -> None:
         """
         Sets the pump state sensors -- i.e. retrieving the state of some pumps in the network.
 
@@ -1149,6 +1241,81 @@ class ScenarioSimulator():
         """
         self.set_sensors(SENSOR_TYPE_PUMP_STATE, sensor_locations)
 
+    def place_pump_state_sensors_everywhere(self) -> None:
+        """
+        Places a pump state sensor at every pump in the network.
+        """
+        if len(self.__sensor_config.pumps) == 0:
+            warnings.warn("Network does not contain any pumps", UserWarning)
+
+        self.set_pump_state_sensors(self.__sensor_config.pumps)
+
+    def set_pump_efficiency_sensors(self, sensor_locations: list[str]) -> None:
+        """
+        Sets the pump efficiency sensors -- i.e. retrieving the efficiency of
+        some pumps in the network.
+
+        Parameters
+        ----------
+        sensor_locations : `list[str]`
+            Locations (IDs) of sensors.
+        """
+        self.set_sensors(SENSOR_TYPE_PUMP_EFFICIENCY, sensor_locations)
+
+    def place_pump_efficiency_sensors_everywhere(self) -> None:
+        """
+        Places a pump efficiency sensor at every pump in the network.
+        """
+        if len(self.__sensor_config.pumps) == 0:
+            warnings.warn("Network does not contain any pumps", UserWarning)
+
+        self.set_pump_efficiency_sensors(self.__sensor_config.pumps)
+
+    def set_pump_energyconsumption_sensors(self, sensor_locations: list[str]) -> None:
+        """
+        Sets the pump energy consumption sensors -- i.e. retrieving the energy consumption of
+        some pumps in the network.
+
+        Parameters
+        ----------
+        sensor_locations : `list[str]`
+            Locations (IDs) of sensors.
+        """
+        self.set_sensors(SENSOR_TYPE_PUMP_ENERGYCONSUMPTION, sensor_locations)
+
+    def place_pump_energyconsumption_sensors_everywhere(self) -> None:
+        """
+        Places a pump energy consumption sensor at every pump in the network.
+        """
+        if len(self.__sensor_config.pumps) == 0:
+            warnings.warn("Network does not contain any pumps", UserWarning)
+
+        self.set_pump_energyconsumption_sensors(self.__sensor_config.pumps)
+
+    def set_pump_sensors(self, sensor_locations: list[str]) -> None:
+        """
+        Sets the pump sensors -- i.e. retrieving the state, efficiency, and energy consumption
+        of some pumps in the network.
+
+        Parameters
+        ----------
+        sensor_locations : `list[str]`
+            Locations (IDs) of sensors.
+        """
+        self.set_sensors(SENSOR_TYPE_PUMP_STATE, sensor_locations)
+        self.set_sensors(SENSOR_TYPE_PUMP_EFFICIENCY, sensor_locations)
+        self.set_sensors(SENSOR_TYPE_PUMP_ENERGYCONSUMPTION, sensor_locations)
+
+    def place_pump_sensors_everywhere(self) -> None:
+        """
+        Palces pump sensors at every pump in the network -- i.e. retrieving the state, efficiency,
+        and energy consumption of all pumps in the network.
+        """
+        if len(self.__sensor_config.pumps) == 0:
+            warnings.warn("Network does not contain any pumps", UserWarning)
+
+        self.set_pump_sensors(self.__sensor_config.pumps)
+
     def set_tank_sensors(self, sensor_locations: list[str]) -> None:
         """
         Sets the tank volume sensors -- i.e. measuring water volumes in some tanks in the network.
@@ -1160,6 +1327,15 @@ class ScenarioSimulator():
         """
         self.set_sensors(SENSOR_TYPE_TANK_VOLUME, sensor_locations)
 
+    def place_tank_sensors_everywhere(self) -> None:
+        """
+        Places a water tank volume sensor at every tank in the network.
+        """
+        if len(self.__sensor_config.tanks) == 0:
+            warnings.warn("Network does not contain any tanks", UserWarning)
+
+        self.set_tank_sensors(self.__sensor_config.tanks)
+
     def set_bulk_species_node_sensors(self, sensor_info: dict) -> None:
         """
         Sets the bulk species node sensors -- i.e. measuring bulk species concentrations
@@ -1172,6 +1348,14 @@ class ScenarioSimulator():
         """
         self.set_sensors(SENSOR_TYPE_NODE_BULK_SPECIES, sensor_info)
 
+    def place_bulk_species_node_sensors_everywhere(self) -> None:
+        """
+        Places bulk species concentration sensors at every node in the network for
+        every bulk species.
+        """
+        self.set_bulk_species_node_sensors({species_id: self.__sensor_config.nodes
+                                            for species_id in self.__sensor_config.bulk_species})
+
     def set_bulk_species_link_sensors(self, sensor_info: dict) -> None:
         """
         Sets the bulk species link/pipe sensors -- i.e. measuring bulk species concentrations
@@ -1184,6 +1368,14 @@ class ScenarioSimulator():
         """
         self.set_sensors(SENSOR_TYPE_LINK_BULK_SPECIES, sensor_info)
 
+    def place_bulk_species_link_sensors_everywhere(self) -> None:
+        """
+        Places bulk species concentration sensors at every link/pipe in the network
+        for every bulk species.
+        """
+        self.set_bulk_species_link_sensors({species_id: self.__sensor_config.links
+                                            for species_id in self.__sensor_config.bulk_species})
+
     def set_surface_species_sensors(self, sensor_info: dict) -> None:
         """
         Sets the surface species sensors -- i.e. measuring surface species concentrations
@@ -1196,6 +1388,22 @@ class ScenarioSimulator():
         """
         self.set_sensors(SENSOR_TYPE_SURFACE_SPECIES, sensor_info)
 
+    def place_surface_species_sensors_everywhere(self) -> None:
+        """
+        Places surface species concentration sensors at every link/pipe in the network
+        for every surface species.
+        """
+        self.set_bulk_species_node_sensors({species_id: self.__sensor_config.links
+                                            for species_id in
+                                            self.__sensor_config.surface_species})
+
+    def place_sensors_everywhere(self) -> None:
+        """
+        Places sensors everywhere -- i.e. every possible quantity is monitored
+        at every position in the network.
+        """
+        self.__sensor_config.place_sensors_everywhere()
+
     def __prepare_simulation(self) -> None:
         self.__adapt_to_network_changes()
 
@@ -1745,11 +1953,6 @@ class ScenarioSimulator():
             tstep = 1
             first_itr = True
             while tstep > 0:
-                if support_abort is True:  # Can the simulation be aborted? If so, handle it.
-                    abort = yield
-                    if abort is not False:
-                        break
-
                 if first_itr is True:  # Fix current time in the first iteration
                     tstep = 0
                     first_itr = False
@@ -1781,8 +1984,8 @@ class ScenarioSimulator():
                 tanks_volume_data = self.epanet_api.getNodeTankVolume().reshape(1, -1)
 
                 pump_idx = self.epanet_api.getLinkPumpIndex()
-                pump_energy_usage_data = self.epanet_api.getLinkEnergy(pump_idx).reshape(1, -1)
-                pump_efficiency_data = self.epanet_api.getLinkPumpEfficiency().reshape(1, -1)
+                pumps_energy_usage_data = self.epanet_api.getLinkEnergy(pump_idx).reshape(1, -1)
+                pumps_efficiency_data = self.epanet_api.getLinkPumpEfficiency().reshape(1, -1)
 
                 link_valve_idx = self.epanet_api.getLinkValveIndex()
                 valves_state_data = self.epanet_api.getLinkStatus(link_valve_idx).reshape(1, -1)
@@ -1796,8 +1999,8 @@ class ScenarioSimulator():
                                        pumps_state_data_raw=pumps_state_data,
                                        valves_state_data_raw=valves_state_data,
                                        tanks_volume_data_raw=tanks_volume_data,
-                                       pump_energy_usage_data=pump_energy_usage_data,
-                                       pump_efficiency_data=pump_efficiency_data,
+                                       pumps_energy_usage_data_raw=pumps_energy_usage_data,
+                                       pumps_efficiency_data_raw=pumps_efficiency_data,
                                        sensor_readings_time=np.array([total_time]),
                                        sensor_reading_events=self.__sensor_reading_events,
                                        sensor_noise=self.__sensor_noise,
@@ -1806,19 +2009,26 @@ class ScenarioSimulator():
                 # Yield results in a regular time interval only!
                 if total_time % reporting_time_step == 0 and total_time >= reporting_time_start:
                     if return_as_dict is True:
-                        yield {"pressure_data_raw": pressure_data,
-                               "flow_data_raw": flow_data,
-                               "demand_data_raw": demand_data,
-                               "node_quality_data_raw": quality_node_data,
-                               "link_quality_data_raw": quality_link_data,
-                               "pumps_state_data_raw": pumps_state_data,
-                               "valves_state_data_raw": valves_state_data,
-                               "tanks_volume_data_raw": tanks_volume_data,
-                               "pump_energy_usage_data": pump_energy_usage_data,
-                               "pump_efficiency_data": pump_efficiency_data,
-                               "sensor_readings_time": np.array([total_time])}
+                        data = {"pressure_data_raw": pressure_data,
+                                "flow_data_raw": flow_data,
+                                "demand_data_raw": demand_data,
+                                "node_quality_data_raw": quality_node_data,
+                                "link_quality_data_raw": quality_link_data,
+                                "pumps_state_data_raw": pumps_state_data,
+                                "valves_state_data_raw": valves_state_data,
+                                "tanks_volume_data_raw": tanks_volume_data,
+                                "pumps_energy_usage_data_raw": pumps_energy_usage_data,
+                                "pumps_efficiency_data_raw": pumps_efficiency_data,
+                                "sensor_readings_time": np.array([total_time])}
                     else:
-                        yield scada_data
+                        data = scada_data
+
+                    if support_abort is True:  # Can the simulation be aborted? If so, handle it.
+                        abort = yield
+                        if abort is not False:
+                            break
+
+                    yield data
 
                 # Apply control modules
                 for control in self.__controls:
@@ -1947,6 +2157,30 @@ class ScenarioSimulator():
         """
         self.__adapt_to_network_changes()
 
+        if flow_units_id is not None:
+            if flow_units_id == ToolkitConstants.EN_CFS:
+                self.epanet_api.setFlowUnitsCFS()
+            elif flow_units_id == ToolkitConstants.EN_GPM:
+                self.epanet_api.setFlowUnitsGPM()
+            elif flow_units_id == ToolkitConstants.EN_MGD:
+                self.epanet_api.setFlowUnitsMGD()
+            elif flow_units_id == ToolkitConstants.EN_IMGD:
+                self.epanet_api.setFlowUnitsIMGD()
+            elif flow_units_id == ToolkitConstants.EN_AFD:
+                self.epanet_api.setFlowUnitsAFD()
+            elif flow_units_id == ToolkitConstants.EN_LPS:
+                self.epanet_api.setFlowUnitsLPS()
+            elif flow_units_id == ToolkitConstants.EN_LPM:
+                self.epanet_api.setFlowUnitsLPM()
+            elif flow_units_id == ToolkitConstants.EN_MLD:
+                self.epanet_api.setFlowUnitsMLD()
+            elif flow_units_id == ToolkitConstants.EN_CMH:
+                self.epanet_api.setFlowUnitsCMH()
+            elif flow_units_id == ToolkitConstants.EN_CMD:
+                self.epanet_api.setFlowUnitsCMD()
+            else:
+                raise ValueError(f"Unknown flow units '{flow_units_id}'")
+
         if demand_model is not None:
             self.epanet_api.setDemandModel(demand_model["type"], demand_model["pressure_min"],
                                            demand_model["pressure_required"],
@@ -1991,30 +2225,6 @@ class ScenarioSimulator():
                                  "greater than the hydraulic time step")
             self.epanet_api.setTimeQualityStep(quality_time_step)
 
-        if flow_units_id is not None:
-            if flow_units_id == ToolkitConstants.EN_CFS:
-                self.epanet_api.setFlowUnitsCFS()
-            elif flow_units_id == ToolkitConstants.EN_GPM:
-                self.epanet_api.setFlowUnitsGPM()
-            elif flow_units_id == ToolkitConstants.EN_MGD:
-                self.epanet_api.setFlowUnitsMGD()
-            elif flow_units_id == ToolkitConstants.EN_IMGD:
-                self.epanet_api.setFlowUnitsIMGD()
-            elif flow_units_id == ToolkitConstants.EN_AFD:
-                self.epanet_api.setFlowUnitsAFD()
-            elif flow_units_id == ToolkitConstants.EN_LPS:
-                self.epanet_api.setFlowUnitsLPS()
-            elif flow_units_id == ToolkitConstants.EN_LPM:
-                self.epanet_api.setFlowUnitsLPM()
-            elif flow_units_id == ToolkitConstants.EN_MLD:
-                self.epanet_api.setFlowUnitsMLD()
-            elif flow_units_id == ToolkitConstants.EN_CMH:
-                self.epanet_api.setFlowUnitsCMH()
-            elif flow_units_id == ToolkitConstants.EN_CMD:
-                self.epanet_api.setFlowUnitsCMD()
-            else:
-                raise ValueError(f"Unknown flow units '{flow_units_id}'")
-
         if quality_model is not None:
             if quality_model["type"] == "NONE":
                 self.epanet_api.setQualityType("none")

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):