epyt-flow 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

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
@@ -92,6 +94,7 @@ class ScenarioSimulator():
         self.__controls = []
         self.__system_events = []
         self.__sensor_reading_events = []
+        self.__running_simulation = False
 
         custom_epanet_lib = None
         custom_epanetmsx_lib = None
@@ -109,12 +112,50 @@ 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,
+                                     display_warnings=False)
+
+            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 +434,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_efficiency_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 +456,9 @@ 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)
+
     def __enter__(self):
         return self
 
@@ -697,6 +744,19 @@ class ScenarioSimulator():
                 "units": qualityunit_to_id(qual_info.QualityChemUnits),
                 "trace_node_id": qual_info.TraceNode}
 
+    def get_reporting_time_step(self) -> int:
+        """
+        Gets the reporting time steps -- i.e. time steps at which sensor readings are provided.
+
+        Is always a multiple of the hydraulic time step.
+
+        Returns
+        -------
+        `int`
+            Reporting time steps in seconds.
+        """
+        return self.epanet_api.getTimeReportingStep()
+
     def get_scenario_config(self) -> ScenarioConfig:
         """
         Gets the configuration of this scenario -- i.e. all information & elements
@@ -711,7 +771,7 @@ 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(),
+                          "reporting_time_step": self.get_reporting_time_step(),
                           "simulation_duration": self.get_simulation_duration(),
                           "flow_units_id": self.get_flow_units(),
                           "quality_model": self.get_quality_model(),
@@ -756,7 +816,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()
@@ -827,6 +887,9 @@ class ScenarioSimulator():
         """
         Randomizes all demand patterns.
         """
+        if self.__running_simulation is True:
+            raise RuntimeError("Can not change general parameters when simulation is running.")
+
         self.__adapt_to_network_changes()
 
         # Get all demand patterns
@@ -949,6 +1012,9 @@ class ScenarioSimulator():
         event : :class:`~epyt_flow.simulation.events.system_event.SystemEvent`
             System event.
         """
+        if self.__running_simulation is True:
+            raise RuntimeError("Can not add events when simulation is running.")
+
         self.__adapt_to_network_changes()
 
         if not isinstance(event, SystemEvent):
@@ -968,6 +1034,9 @@ class ScenarioSimulator():
         sensor_fault_event : :class:`~epyt_flow.simulation.events.sensor_faults.SensorFault`
             Sensor fault specifications.
         """
+        if self.__running_simulation is True:
+            raise RuntimeError("Can not add events when simulation is running.")
+
         self.__adapt_to_network_changes()
 
         sensor_fault_event.validate(self.__sensor_config)
@@ -988,6 +1057,9 @@ class ScenarioSimulator():
         sensor_reading_attack : :class:`~epyt_flow.simulation.events.sensor_reading_attack.SensorReadingAttack`
             Sensor fault specifications.
         """
+        if self.__running_simulation is True:
+            raise RuntimeError("Can not add events when simulation is running.")
+
         self.__adapt_to_network_changes()
 
         sensor_reading_attack.validate(self.__sensor_config)
@@ -1008,6 +1080,9 @@ class ScenarioSimulator():
         event : :class:`~epyt_flow.simulation.events.sensor_reading_event.SensorReadingEvent`
             Sensor reading event.
         """
+        if self.__running_simulation is True:
+            raise RuntimeError("Can not add events when simulation is running.")
+
         self.__adapt_to_network_changes()
 
         event.validate(self.__sensor_config)
@@ -1027,16 +1102,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 +1134,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 +1162,22 @@ class ScenarioSimulator():
         """
         self.set_sensors(SENSOR_TYPE_NODE_PRESSURE, sensor_locations)
 
+    def place_pressure_sensors_everywhere(self, junctions_only: bool = False) -> None:
+        """
+        Places a pressure sensor at every node in the network.
+
+        Parameters
+        ----------
+        junctions_only : `bool`, optional
+            If True, pressure sensors are only placed at junctions but not at tanks and reservoirs.
+
+            The default is False.
+        """
+        if junctions_only is True:
+            self.set_pressure_sensors(self.epanet_api.getNodeJunctionNameID())
+        else:
+            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 +1189,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 +1206,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 +1224,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 +1242,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 +1259,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 +1279,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 +1365,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 +1386,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 +1406,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 +1426,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()
 
@@ -1234,6 +1480,9 @@ class ScenarioSimulator():
         :class:`~epyt_flow.simulation.scada.scada_data.ScadaData`
             Quality simulation results as SCADA data.
         """
+        if self.__running_simulation is True:
+            raise RuntimeError("A simulation is already running.")
+
         if self.__f_msx_in is None:
             raise ValueError("No .msx file specified")
 
@@ -1298,6 +1547,9 @@ class ScenarioSimulator():
             Generator containing the current EPANET-MSX simulation results as SCADA data
             (i.e. species concentrations).
         """
+        if self.__running_simulation is True:
+            raise RuntimeError("A simulation is already running.")
+
         if self.__f_msx_in is None:
             raise ValueError("No .msx file specified")
 
@@ -1314,6 +1566,8 @@ class ScenarioSimulator():
 
         self.epanet_api.initializeMSXQualityAnalysis(ToolkitConstants.EN_NOSAVE)
 
+        self.__running_simulation = True
+
         bulk_species_idx = self.epanet_api.getMSXSpeciesIndex(self.__sensor_config.bulk_species)
         surface_species_idx = self.epanet_api.getMSXSpeciesIndex(
             self.__sensor_config.surface_species)
@@ -1406,6 +1660,7 @@ class ScenarioSimulator():
 
         # Run step-by-step simulation
         tleft = 1
+        total_time = 0
         while tleft > 0:
             if support_abort is True:  # Can the simulation be aborted? If so, handle it.
                 abort = yield
@@ -1448,6 +1703,8 @@ class ScenarioSimulator():
                                         sensor_noise=self.__sensor_noise,
                                         frozen_sensor_config=frozen_sensor_config)
 
+        self.__running_simulation = False
+
     def run_basic_quality_simulation(self, hyd_file_in: str, verbose: bool = False,
                                      frozen_sensor_config: bool = False) -> ScadaData:
         """
@@ -1473,6 +1730,9 @@ class ScenarioSimulator():
         :class:`~epyt_flow.simulation.scada.scada_data.ScadaData`
             Quality simulation results as SCADA data.
         """
+        if self.__running_simulation is True:
+            raise RuntimeError("A simulation is already running.")
+
         result = None
 
         # Run simulation step-by-step
@@ -1533,6 +1793,9 @@ class ScenarioSimulator():
         :class:`~epyt_flow.simulation.scada.scada_data.ScadaData`
             Generator with the current simulation results/states as SCADA data.
         """
+        if self.__running_simulation is True:
+            raise RuntimeError("A simulation is already running.")
+
         requested_time_step = self.epanet_api.getTimeHydraulicStep()
         reporting_time_start = self.epanet_api.getTimeReportingStart()
         reporting_time_step = self.epanet_api.getTimeReportingStep()
@@ -1626,6 +1889,9 @@ class ScenarioSimulator():
         :class:`~epyt_flow.simulation.scada.scada_data.ScadaData`
             Simulation results as SCADA data (i.e. sensor readings).
         """
+        if self.__running_simulation is True:
+            raise RuntimeError("A simulation is already running.")
+
         self.__adapt_to_network_changes()
 
         result = None
@@ -1720,10 +1986,15 @@ class ScenarioSimulator():
             Generator with the current simulation results/states as SCADA data
             (i.e. sensor readings).
         """
+        if self.__running_simulation is True:
+            raise RuntimeError("A simulation is already running.")
+
         self.__adapt_to_network_changes()
 
         self.__prepare_simulation()
 
+        self.__running_simulation = True
+
         self.epanet_api.openHydraulicAnalysis()
         self.epanet_api.openQualityAnalysis()
         self.epanet_api.initializeHydraulicAnalysis(ToolkitConstants.EN_SAVE)
@@ -1745,11 +2016,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 +2047,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 +2062,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 +2072,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:
@@ -1831,9 +2104,12 @@ class ScenarioSimulator():
             self.epanet_api.closeQualityAnalysis()
             self.epanet_api.closeHydraulicAnalysis()
 
+            self.__running_simulation = False
+
             if hyd_export is not None:
                 self.epanet_api.saveHydraulicFile(hyd_export)
         except Exception as ex:
+            self.__running_simulation = False
             raise ex
 
     def set_model_uncertainty(self, model_uncertainty: ModelUncertainty) -> None:
@@ -1845,6 +2121,9 @@ class ScenarioSimulator():
         model_uncertainty : :class:`~epyt_flow.uncertainty.model_uncertainty.ModelUncertainty`
             Model uncertainty specifications.
         """
+        if self.__running_simulation is True:
+            raise RuntimeError("Can not set uncertainties when simulation is running.")
+
         self.__adapt_to_network_changes()
 
         if not isinstance(model_uncertainty, ModelUncertainty):
@@ -1863,6 +2142,9 @@ class ScenarioSimulator():
         sensor_noise : :class:`~epyt_flow.uncertainties.sensor_noise.SensorNoise`
             Sensor noise specification.
         """
+        if self.__running_simulation is True:
+            raise RuntimeError("Can not set sensor noise when simulation is running.")
+
         self.__adapt_to_network_changes()
 
         if not isinstance(sensor_noise, SensorNoise):
@@ -1945,8 +2227,35 @@ class ScenarioSimulator():
 
             The default is None.
         """
+        if self.__running_simulation is True:
+            raise RuntimeError("Can not change general parameters when simulation is running.")
+
         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 +2300,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")
@@ -2067,6 +2352,9 @@ class ScenarioSimulator():
         Sets water age analysis -- i.e. estimates the water age (in hours) at
         all places in the network.
         """
+        if self.__running_simulation is True:
+            raise RuntimeError("Can not change general parameters when simulation is running.")
+
         self.__adapt_to_network_changes()
 
         self.__warn_if_quality_set()
@@ -2095,6 +2383,9 @@ class ScenarioSimulator():
 
             The default is MASS_UNIT_MG.
         """
+        if self.__running_simulation is True:
+            raise RuntimeError("Can not change general parameters when simulation is running.")
+
         self.__adapt_to_network_changes()
 
         self.__warn_if_quality_set()
@@ -2139,6 +2430,9 @@ class ScenarioSimulator():
 
             The default is 1.
         """
+        if self.__running_simulation is True:
+            raise RuntimeError("Can not change general parameters when simulation is running.")
+
         self.__adapt_to_network_changes()
 
         if self.epanet_api.getQualityInfo().QualityCode != ToolkitConstants.EN_CHEM:
@@ -2175,6 +2469,9 @@ class ScenarioSimulator():
         trace_node_id : `str`
             ID of the node traced in the source tracing analysis.
         """
+        if self.__running_simulation is True:
+            raise RuntimeError("Can not change general parameters when simulation is running.")
+
         self.__adapt_to_network_changes()
 
         if trace_node_id not in self.__sensor_config.nodes: