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

epyt_flow/simulation/scenario_simulator.py

@@ -17,15 +17,17 @@ from epyt.epanet import ToolkitConstants
 from tqdm import tqdm
 
 from .scenario_config import ScenarioConfig
-from .sensor_config import SensorConfig, SENSOR_TYPE_LINK_FLOW, SENSOR_TYPE_LINK_QUALITY, \
-    SENSOR_TYPE_NODE_DEMAND, SENSOR_TYPE_NODE_PRESSURE, SENSOR_TYPE_NODE_QUALITY, \
+from .sensor_config import SensorConfig, areaunit_to_id, massunit_to_id, qualityunits_to_id, \
+    qualityunits_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
 from ..uncertainty import ModelUncertainty, SensorNoise
 from .events import SystemEvent, Leakage, ActuatorEvent, SensorFault, SensorReadingAttack, \
     SensorReadingEvent
 from .scada import ScadaData, AdvancedControlModule
-from ..topology import NetworkTopology
+from ..topology import NetworkTopology, UNITS_SIMETRIC, UNITS_USCUSTOM
 from ..utils import get_temp_folder
 
 
@@ -48,6 +50,10 @@ class ScenarioSimulator():
 
         If this is None, then 'f_inp_in' must be set with a valid path to the .inp file
         that is to be simulated.
+    epanet_verbose : `bool`, optional
+        If True, EPyT is verbose and might print messages from time to time.
+
+        The default is False.
 
     Attributes
     ----------
@@ -56,7 +62,7 @@ class ScenarioSimulator():
     """
 
     def __init__(self, f_inp_in: str = None, f_msx_in: str = None,
-                 scenario_config: ScenarioConfig = None):
+                 scenario_config: ScenarioConfig = None, epanet_verbose: bool = False):
         if f_msx_in is not None and f_inp_in is None:
             raise ValueError("'f_inp_in' must be set if 'f_msx_in' is set.")
         if f_inp_in is None and scenario_config is None:
@@ -74,6 +80,9 @@ class ScenarioSimulator():
                 raise TypeError("'scenario_config' must be an instance of " +
                                 "'epyt_flow.simulation.ScenarioConfig' but not of " +
                                 f"'{type(scenario_config)}'")
+        if not isinstance(epanet_verbose, bool):
+            raise TypeError("'epanet_verbose' must be an instance of 'bool' " +
+                            f"but not of '{type(epanet_verbose)}'")
 
         self.__f_inp_in = f_inp_in if scenario_config is None else scenario_config.f_inp_in
         self.__f_msx_in = f_msx_in if scenario_config is None else scenario_config.f_msx_in
@@ -86,37 +95,28 @@ class ScenarioSimulator():
 
         custom_epanet_lib = None
         custom_epanetmsx_lib = None
-        if sys.platform.startswith("linux"):
+        if sys.platform.startswith("linux") or sys.platform.startswith("darwin") :
             path_to_custom_libs = os.path.join(pathlib.Path(__file__).parent.resolve(),
                                                "..", "customlibs")
 
-            if os.path.isfile(os.path.join(path_to_custom_libs, "libepanet2_2.so")):
-                custom_epanet_lib = os.path.join(path_to_custom_libs, "libepanet2_2.so")
-            if os.path.isfile(os.path.join(path_to_custom_libs, "libepanetmsx2_2_0.so")):
-                custom_epanetmsx_lib = os.path.join(path_to_custom_libs, "libepanetmsx2_2_0.so")
+            libepanet_name = "libepanet2_2.so" if sys.platform.startswith("linux") \
+                else "libepanet2_2.dylib"
+            libepanetmsx_name = "libepanetmsx2_2_0.so" if sys.platform.startswith("linux") \
+                else "libepanetmsx2_2_0.dylib"
+
+            if os.path.isfile(os.path.join(path_to_custom_libs, libepanet_name)):
+                custom_epanet_lib = os.path.join(path_to_custom_libs, libepanet_name)
+            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)
+                                 customlib=custom_epanet_lib, loadfile=True,
+                                 display_msg=epanet_verbose)
 
-        bulk_species = []
-        surface_species = []
         if self.__f_msx_in is not None:
             self.epanet_api.loadMSXFile(self.__f_msx_in, customMSXlib=custom_epanetmsx_lib)
 
-            for species_id, species_type in zip(self.epanet_api.getMSXSpeciesNameID(),
-                                                self.epanet_api.getMSXSpeciesType()):
-                if species_type == "BULK":
-                    bulk_species.append(species_id)
-                elif species_type == "WALL":
-                    surface_species.append(species_id)
-
-        self.__sensor_config = SensorConfig(nodes=self.epanet_api.getNodeNameID(),
-                                            links=self.epanet_api.getLinkNameID(),
-                                            valves=self.epanet_api.getLinkValveNameID(),
-                                            pumps=self.epanet_api.getLinkPumpNameID(),
-                                            tanks=self.epanet_api.getNodeTankNameID(),
-                                            bulk_species=bulk_species,
-                                            surface_species=surface_species)
+        self.__sensor_config = self.__get_empty_sensor_config()
         if scenario_config is not None:
             if scenario_config.general_params is not None:
                 self.set_general_parameters(**scenario_config.general_params)
@@ -132,6 +132,51 @@ class ScenarioSimulator():
             for event in scenario_config.sensor_reading_events:
                 self.add_sensor_reading_event(event)
 
+    def __get_empty_sensor_config(self, node_id_to_idx: dict = None, link_id_to_idx: dict = None,
+                                  valve_id_to_idx: dict = None, pump_id_to_idx: dict = None,
+                                  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)
+        bulk_species = []
+        surface_species = []
+        bulk_species_mass_unit = []
+        surface_species_mass_unit = []
+        surface_species_area_unit = None
+
+        if self.__f_msx_in is not None:
+            surface_species_area_unit = areaunit_to_id(self.epanet_api.getMSXAreaUnits())
+
+            for species_id, species_type, mass_unit in zip(self.epanet_api.getMSXSpeciesNameID(),
+                                                           self.epanet_api.getMSXSpeciesType(),
+                                                           self.epanet_api.getMSXSpeciesUnits()):
+                if species_type == "BULK":
+                    bulk_species.append(species_id)
+                    bulk_species_mass_unit.append(massunit_to_id(mass_unit))
+                elif species_type == "WALL":
+                    surface_species.append(species_id)
+                    surface_species_mass_unit.append(massunit_to_id(mass_unit))
+
+        return SensorConfig(nodes=self.epanet_api.getNodeNameID(),
+                            links=self.epanet_api.getLinkNameID(),
+                            valves=self.epanet_api.getLinkValveNameID(),
+                            pumps=self.epanet_api.getLinkPumpNameID(),
+                            tanks=self.epanet_api.getNodeTankNameID(),
+                            bulk_species=bulk_species,
+                            surface_species=surface_species,
+                            flow_unit=flow_unit,
+                            quality_unit=quality_unit,
+                            bulk_species_mass_unit=bulk_species_mass_unit,
+                            surface_species_mass_unit=surface_species_mass_unit,
+                            surface_species_area_unit=surface_species_area_unit,
+                            node_id_to_idx=node_id_to_idx,
+                            link_id_to_idx=link_id_to_idx,
+                            valve_id_to_idx=valve_id_to_idx,
+                            pump_id_to_idx=pump_id_to_idx,
+                            tank_id_to_idx=tank_id_to_idx,
+                            bulkspecies_id_to_idx=bulkspecies_id_to_idx,
+                            surfacespecies_id_to_idx=surfacespecies_id_to_idx)
+
     @property
     def f_inp_in(self) -> str:
         """
@@ -295,6 +340,21 @@ class ScenarioSimulator():
         return deepcopy(list(filter(lambda e: isinstance(e, SensorFault),
                                     self.__sensor_reading_events)))
 
+    @property
+    def sensor_reading_attacks(self) -> list[SensorReadingAttack]:
+        """
+        Gets all sensor reading attacks.
+
+        Returns
+        -------
+        list[:class:`~epyt_flow.simulation.events.sensor_reading_attacks.SensorReadingAttack`]
+            All sensor reading attacks.
+        """
+        self.__adapt_to_network_changes()
+
+        return deepcopy(list(filter(lambda e: isinstance(e, SensorReadingAttack)),
+                             self.__sensor_reading_events))
+
     @property
     def sensor_reading_events(self) -> list[SensorReadingEvent]:
         """
@@ -312,57 +372,33 @@ class ScenarioSimulator():
     def __adapt_to_network_changes(self):
         nodes = self.epanet_api.getNodeNameID()
         links = self.epanet_api.getLinkNameID()
-        valves = self.epanet_api.getLinkValveNameID()
-        pumps = self.epanet_api.getLinkPumpNameID()
-        tanks = self.epanet_api.getNodeTankNameID()
-        bulk_species = []
-        surface_species = []
-
-        if self.__f_msx_in is not None:
-            for species_id, species_type in zip(self.epanet_api.getMSXSpeciesNameID(),
-                                                self.epanet_api.getMSXSpeciesType()):
-                if species_type == "BULK":
-                    bulk_species.append(species_id)
-                elif species_type == "WALL":
-                    surface_species.append(species_id)
 
         node_id_to_idx = {node_id: self.epanet_api.getNodeIndex(node_id) - 1 for node_id in nodes}
         link_id_to_idx = {link_id: self.epanet_api.getLinkIndex(link_id) - 1 for link_id in links}
         valve_id_to_idx = None  # {valve_id: self.epanet_api.getLinkValveIndex(valve_id) for valve_id in valves}
-        pump_id_to_idx = None # {pump_id: self.epanet_api.getLinkPumpIndex(pump_id) - 1 for pump_id in pumps}
-        tank_id_to_idx = None #{tank_id: self.epanet_api.getNodeTankIndex(tank_id) - 1 for tank_id in tanks}
+        pump_id_to_idx = None  # {pump_id: self.epanet_api.getLinkPumpIndex(pump_id) - 1 for pump_id in pumps}
+        tank_id_to_idx = None  # {tank_id: self.epanet_api.getNodeTankIndex(tank_id) - 1 for tank_id in tanks}
         bulkspecies_id_to_idx = None
         surfacespecies_id_to_idx = None
 
-        if nodes != self.__sensor_config.nodes or links != self.__sensor_config.links or \
-            valves != self.__sensor_config.valves or pumps != self.__sensor_config.pumps or \
-            tanks != self.__sensor_config.tanks or \
-            bulk_species != self.__sensor_config.bulk_species or \
-                surface_species != self.__sensor_config.surface_species:
-            # Adapt sensor configuration if anything in the network topology changed
-            new_sensor_config = SensorConfig(nodes=nodes, links=links, valves=valves, pumps=pumps,
-                                             tanks=tanks, bulk_species=bulk_species,
-                                             surface_species=surface_species,
-                                             node_id_to_idx=node_id_to_idx,
-                                             link_id_to_idx=link_id_to_idx,
-                                             valve_id_to_idx=valve_id_to_idx,
-                                             pump_id_to_idx=pump_id_to_idx,
-                                             tank_id_to_idx=tank_id_to_idx,
-                                             bulkspecies_id_to_idx=bulkspecies_id_to_idx,
-                                             surfacespecies_id_to_idx=surfacespecies_id_to_idx)
-            new_sensor_config.pressure_sensors = self.__sensor_config.pressure_sensors
-            new_sensor_config.flow_sensors = self.__sensor_config.flow_sensors
-            new_sensor_config.demand_sensors = self.__sensor_config.demand_sensors
-            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.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
-            new_sensor_config.bulk_species_link_sensors = self.__sensor_config.bulk_species_link_sensors
-            new_sensor_config.surface_species_sensors = self.__sensor_config.surface_species_sensors
-
-            self.__sensor_config = new_sensor_config
+        # Adapt sensor configuration to potential cahnges in the network's topology
+        new_sensor_config = self.__get_empty_sensor_config(node_id_to_idx, link_id_to_idx,
+                                                           valve_id_to_idx, pump_id_to_idx,
+                                                           tank_id_to_idx, bulkspecies_id_to_idx,
+                                                           surfacespecies_id_to_idx)
+        new_sensor_config.pressure_sensors = self.__sensor_config.pressure_sensors
+        new_sensor_config.flow_sensors = self.__sensor_config.flow_sensors
+        new_sensor_config.demand_sensors = self.__sensor_config.demand_sensors
+        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.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
+        new_sensor_config.bulk_species_link_sensors = self.__sensor_config.bulk_species_link_sensors
+        new_sensor_config.surface_species_sensors = self.__sensor_config.surface_species_sensors
+
+        self.__sensor_config = new_sensor_config
 
     def close(self):
         """
@@ -381,22 +417,185 @@ class ScenarioSimulator():
     def __exit__(self, *args):
         self.close()
 
+    def save_to_epanet_file(self, inp_file_path: str, msx_file_path: str = None,
+                            export_sensor_config: bool = True) -> None:
+        """
+        Exports this scenario to EPANET files -- i.e. an .inp file
+        and (optionally) a .msx file if EPANET-MSX was loaded.
+
+        Parameters
+        ----------
+        inp_file_path : `str`
+            Path to the .inp file where this scenario will be stored.
+
+            If 'inp_file_path' is None, 'msx_file_path' must not be None!
+        msx_file_path : `str`, optional
+            Path to the .msx file where this MSX component of this scneario will be stored.
+
+            Note that this is only applicable if EPANET-MSX was loaded.
+
+            The default is None.
+        export_sensor_config : `bool`, optional
+            If True, the current sensor placement is exported as well.
+
+            The default is True.
+        """
+        if inp_file_path is None and msx_file_path is None:
+            raise ValueError("At least one of the paths (.inp and .msx) must not be None")
+        if inp_file_path is not None:
+            if not isinstance(inp_file_path, str):
+                raise TypeError("'inp_file_path' must be an instance of 'str' " +
+                                f"but not of '{type(inp_file_path)}'")
+        if msx_file_path is not None:
+            if not isinstance(msx_file_path, str):
+                raise TypeError("msx_file_path' msut be an instance of 'str' " +
+                                f"but not of {type(msx_file_path)}")
+        if not isinstance(export_sensor_config, bool):
+            raise TypeError("'export_sensor_config' must be an instance of 'bool' " +
+                            f"but not of '{type(export_sensor_config)}'")
+
+        def __override_report_section(file_in: str, report_desc: str) -> None:
+            with open(file_in, mode="r+", encoding="utf-8") as f_in:
+                # Find and remove exiting REPORT section
+                content = f_in.read()
+                try:
+                    report_section_start_idx = content.index("[REPORT]")
+                    report_section_end_idx = content.index("[", report_section_start_idx + 1)
+
+                    content = content[:report_section_start_idx] + content[report_section_end_idx:]
+                    f_in.seek(0)
+                    f_in.write(content)
+                    f_in.truncate()
+                except ValueError:
+                    pass
+
+                # Write new REPORT section in the very end of the file
+                write_end_section = False
+                try:
+                    end_idx = content.index("[END]")
+                    write_end_section = True
+                    f_in.seek(end_idx)
+                except ValueError:
+                    pass
+                f_in.write(report_desc)
+                if write_end_section is True:
+                    f_in.write("\n[END]")
+
+        if inp_file_path is not None:
+            self.epanet_api.saveInputFile(inp_file_path)
+
+            if export_sensor_config is True:
+                report_desc = "\n\n[REPORT]\n"
+                report_desc += "ENERGY YES\n"
+                report_desc += "STATUS YES\n"
+
+                nodes = []
+                links = []
+
+                # Parse sensor config
+                pressure_sensors = self.__sensor_config.pressure_sensors
+                if len(pressure_sensors) != 0:
+                    report_desc += "Pressure YES\n"
+                    nodes += pressure_sensors
+
+                flow_sensors = self.__sensor_config.flow_sensors
+                if len(flow_sensors) != 0:
+                    report_desc += "Flow YES\n"
+                    links += flow_sensors
+
+                demand_sensors = self.__sensor_config.demand_sensors
+                if len(demand_sensors) != 0:
+                    report_desc += "Demand YES\n"
+                    nodes += demand_sensors
+
+                node_quality_sensors = self.__sensor_config.quality_node_sensors
+                if len(node_quality_sensors) != 0:
+                    report_desc += "Quality YES\n"
+                    nodes += node_quality_sensors
+
+                link_quality_sensors = self.__sensor_config.quality_link_sensors
+                if len(link_quality_sensors) != 0:
+                    if len(node_quality_sensors) == 0:
+                        report_desc += "Quality YES\n"
+                    links += link_quality_sensors
+
+                # Create final REPORT section
+                nodes = list(set(nodes))
+                links = list(set(links))
+
+                if len(nodes) != 0:
+                    if set(nodes) == set(self.__sensor_config.nodes):
+                        nodes = ["ALL"]
+                    report_desc += f"NODES {' '.join(nodes)}\n"
+
+                if len(links) != 0:
+                    if set(links) == set(self.__sensor_config.links):
+                        links = ["ALL"]
+                    report_desc += f"LINKS {' '.join(links)}\n"
+
+                __override_report_section(inp_file_path, report_desc)
+
+        if self.__f_msx_in is not None and msx_file_path is not None:
+            self.epanet_api.saveMSXFile(msx_file_path)
+
+            if export_sensor_config is True:
+                report_desc = "\n\n[REPORT]\n"
+                species = []
+                nodes = []
+                links = []
+
+                # Parse sensor config
+                bulk_species_node_sensors = self.__sensor_config.bulk_species_node_sensors
+                for bulk_species_id in bulk_species_node_sensors.keys():
+                    species.append(bulk_species_id)
+                    nodes += bulk_species_node_sensors[bulk_species_id]
+
+                bulk_species_link_sensors = self.__sensor_config.bulk_species_link_sensors
+                for bulk_species_id in bulk_species_link_sensors.keys():
+                    species.append(bulk_species_id)
+                    links += bulk_species_link_sensors[bulk_species_id]
+
+                surface_species_link_sensors = self.__sensor_config.surface_species_sensors
+                for surface_species_id in surface_species_link_sensors.keys():
+                    species.append(surface_species_id)
+                    links += surface_species_link_sensors[surface_species_id]
+
+                nodes = list(set(nodes))
+                links = list((set(links)))
+                species = list(set(species))
+
+                # Create REPORT section
+                if len(nodes) != 0:
+                    if set(nodes) == set(self.__sensor_config.nodes):
+                        nodes = ["ALL"]
+                    report_desc += f"NODES {' '.join(nodes)}\n"
+
+                if len(links) != 0:
+                    if set(links) == set(self.__sensor_config.links):
+                        links = ["ALL"]
+                    report_desc += f"LINKS {' '.join(links)}\n"
+
+                for species_id in species:
+                    report_desc += f"SPECIES {species_id} YES\n"
+
+                __override_report_section(msx_file_path, report_desc)
+
     def get_flow_units(self) -> int:
         """
         Gets the flow units.
 
         Will be one of the following EPANET toolkit constants:
 
-            - EN_CFS = 0
-            - EN_GPM = 1
-            - EN_MGD = 2
-            - EN_IMGD = 3
-            - EN_AFD = 4
-            - EN_LPS = 5
-            - EN_LPM = 6
-            - EN_MLD = 7
-            - EN_CMH = 8
-            - EN_CMD = 9
+            - 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)
 
         Returns
         -------
@@ -405,6 +604,27 @@ class ScenarioSimulator():
         """
         return self.epanet_api.api.ENgetflowunits()
 
+    def get_units_category(self) -> int:
+        """
+        Gets the category of units -- i.e. US Customary or SI Metric units.
+
+        Will be one of the following constants:
+
+            - UNITS_USCUSTOM = 0  (US Customary)
+            - UNITS_SIMETRIC = 1  (SI Metric)
+
+        Returns
+        -------
+        `int`
+            Units category.
+        """
+        if self.get_flow_units() in [ToolkitConstants.EN_CFS, ToolkitConstants.EN_GPM,
+                                     ToolkitConstants.EN_MGD, ToolkitConstants.EN_IMGD,
+                                     ToolkitConstants.EN_AFD]:
+            return UNITS_USCUSTOM
+        else:
+            return UNITS_SIMETRIC
+
     def get_hydraulic_time_step(self) -> int:
         """
         Gets the hydraulic time step -- i.e. time step in the hydraulic simulation.
@@ -471,7 +691,7 @@ class ScenarioSimulator():
         return {"code": qual_info.QualityCode,
                 "type": qual_info.QualityType,
                 "chemical_name": qual_info.QualityChemName,
-                "units": qual_info.QualityChemUnits,
+                "units": qualityunits_to_id(qual_info.QualityChemUnits),
                 "trace_node_id": qual_info.TraceNode}
 
     def get_scenario_config(self) -> ScenarioConfig:
@@ -516,8 +736,12 @@ class ScenarioSimulator():
         n_time_steps = int(self.epanet_api.getTimeSimulationDuration() /
                            self.epanet_api.getTimeReportingStep())
         n_quantities = self.epanet_api.getNodeCount() * 3 + self.epanet_api.getNodeTankCount() + \
-            self.epanet_api.getLinkValveCount() + self.epanet_api.getLinkPumpCount() + \
-            self.epanet_api.getLinkCount() * 2
+                       self.epanet_api.getLinkValveCount() + self.epanet_api.getLinkPumpCount() + \
+                       self.epanet_api.getLinkCount() * 2
+
+        if self.__f_msx_in is not None:
+            n_quantities += self.epanet_api.getLinkCount() * 2 + self.epanet_api.getNodeCount()
+
         n_bytes_per_quantity = 64
 
         return n_time_steps * n_quantities * n_bytes_per_quantity * .000001
@@ -561,7 +785,8 @@ class ScenarioSimulator():
                                           "bulk_coeff": bulk_coeff, "wall_coeff": wall_coeff,
                                           "loss_coeff": loss_coeff}))
 
-        return NetworkTopology(f_inp=self.f_inp_in, nodes=nodes, links=links)
+        return NetworkTopology(f_inp=self.f_inp_in, nodes=nodes, links=links,
+                               units=self.get_units_category())
 
     def randomize_demands(self) -> None:
         """
@@ -974,30 +1199,48 @@ class ScenarioSimulator():
         :class:`~epyt_flow.simulation.scada.scada_data.ScadaData`
             Quality simulation results as SCADA data.
         """
+        if self.__f_msx_in is None:
+            raise ValueError("No .msx file specified")
+
         result = None
 
         gen = self.run_advanced_quality_simulation_as_generator
         for scada_data in gen(hyd_file_in=hyd_file_in,
                               verbose=verbose,
+                              return_as_dict=True,
                               frozen_sensor_config=frozen_sensor_config):
             if result is None:
-                result = scada_data
+                result = {}
+                for data_type, data in scada_data.items():
+                    result[data_type] = [data]
             else:
-                result.concatenate(scada_data)
+                for data_type, data in scada_data.items():
+                    result[data_type].append(data)
 
-        return result
+        # Build ScadaData instance
+        for data_type in result:
+            if not any(d is None for d in result[data_type]):
+                result[data_type] = np.concatenate(result[data_type], axis=0)
+            else:
+                result[data_type] = None
+
+        return ScadaData(**result,
+                         sensor_config=self.__sensor_config,
+                         sensor_reading_events=self.__sensor_reading_events,
+                         sensor_noise=self.__sensor_noise,
+                         frozen_sensor_config=frozen_sensor_config)
 
     def run_advanced_quality_simulation_as_generator(self, hyd_file_in: str, verbose: bool = False,
                                                      support_abort: bool = False,
                                                      return_as_dict: bool = False,
                                                      frozen_sensor_config: bool = False
-                                                     ) -> Generator[Union[ScadaData, dict],
-                                                                    bool, None]:
+                                                     ) -> Generator[Union[ScadaData, dict], bool, None]:
         """
         Runs an advanced quality analysis using EPANET-MSX.
 
         Parameters
         ----------
+        support_abort : `bool`, optional
         hyd_file_in : `str`
             Path to an EPANET .hyd file for storing the simulated hydraulics --
             the quality analysis is computed using those hydraulics.
@@ -1020,6 +1263,9 @@ class ScenarioSimulator():
             Generator containing the current EPANET-MSX simulation results as SCADA data
             (i.e. species concentrations).
         """
+        if self.__f_msx_in is None:
+            raise ValueError("No .msx file specified")
+
         # Load pre-computed hydraulics
         self.epanet_api.useMSXHydraulicFile(hyd_file_in)
 
@@ -1054,13 +1300,13 @@ class ScenarioSimulator():
             bulk_species_link_concentrations = []
             for species_idx in bulk_species_idx:
                 cur_species_concentrations = []
-                for node_idx in range(1, n_nodes+1):
+                for node_idx in range(1, n_nodes + 1):
                     concen = msx_get_cur_value(0, node_idx, species_idx)
                     cur_species_concentrations.append(concen)
                 bulk_species_node_concentrations.append(cur_species_concentrations)
 
                 cur_species_concentrations = []
-                for link_idx in range(1, n_links+1):
+                for link_idx in range(1, n_links + 1):
                     concen = msx_get_cur_value(1, link_idx, species_idx)
                     cur_species_concentrations.append(concen)
                 bulk_species_link_concentrations.append(cur_species_concentrations)
@@ -1068,13 +1314,13 @@ class ScenarioSimulator():
             if len(bulk_species_node_concentrations) == 0:
                 bulk_species_node_concentrations = None
             else:
-                bulk_species_node_concentrations = np.array(bulk_species_node_concentrations).\
+                bulk_species_node_concentrations = np.array(bulk_species_node_concentrations). \
                     reshape((1, len(bulk_species_idx), n_nodes))
 
             if len(bulk_species_link_concentrations) == 0:
                 bulk_species_link_concentrations = None
             else:
-                bulk_species_link_concentrations = np.array(bulk_species_link_concentrations).\
+                bulk_species_link_concentrations = np.array(bulk_species_link_concentrations). \
                     reshape((1, len(bulk_species_idx), n_links))
 
             # Surface species
@@ -1082,7 +1328,7 @@ class ScenarioSimulator():
             for species_idx in surface_species_idx:
                 cur_species_concentrations = []
 
-                for link_idx in range(1, n_links+1):
+                for link_idx in range(1, n_links + 1):
                     concen = msx_get_cur_value(1, link_idx, species_idx)
                     cur_species_concentrations.append(concen)
 
@@ -1091,7 +1337,7 @@ class ScenarioSimulator():
             if len(surface_species_concentrations) == 0:
                 surface_species_concentrations = None
             else:
-                surface_species_concentrations = np.array(surface_species_concentrations).\
+                surface_species_concentrations = np.array(surface_species_concentrations). \
                     reshape((1, len(surface_species_idx), n_links))
 
             return bulk_species_node_concentrations, bulk_species_link_concentrations, \
@@ -1102,14 +1348,17 @@ class ScenarioSimulator():
             surface_species_concentrations = __get_concentrations(init_qual=True)
 
         if verbose is True:
-            next(progress_bar)
+            try:
+                next(progress_bar)
+            except StopIteration:
+                pass
 
         if reporting_time_start == 0:
             if return_as_dict is True:
                 yield {"bulk_species_node_concentration_raw": bulk_species_node_concentrations,
                        "bulk_species_link_concentration_raw": bulk_species_link_concentrations,
                        "surface_species_concentration_raw": surface_species_concentrations,
-                       "sensor_readings_time": np.array([total_time])}
+                       "sensor_readings_time": np.array([0])}
             else:
                 yield ScadaData(sensor_config=self.__sensor_config,
                                 bulk_species_node_concentration_raw=bulk_species_node_concentrations,
@@ -1131,21 +1380,24 @@ class ScenarioSimulator():
             # Compute current time step
             total_time, tleft = self.epanet_api.stepMSXQualityAnalysisTimeLeft()
 
+            if verbose is True:
+                try:
+                    next(progress_bar)
+                except StopIteration:
+                    pass
+
             # Fetch data at regular time intervals
             if total_time % hyd_time_step == 0:
                 bulk_species_node_concentrations, bulk_species_link_concentrations, \
                     surface_species_concentrations = __get_concentrations()
 
-                if verbose is True:
-                    next(progress_bar)
-
                 # Report 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 {"bulk_species_node_concentration_raw":
-                               bulk_species_node_concentrations,
+                                   bulk_species_node_concentrations,
                                "bulk_species_link_concentration_raw":
-                               bulk_species_link_concentrations,
+                                   bulk_species_link_concentrations,
                                "surface_species_concentration_raw": surface_species_concentrations,
                                "sensor_readings_time": np.array([total_time])}
                     else:
@@ -1216,13 +1468,13 @@ class ScenarioSimulator():
                                                   support_abort: bool = False,
                                                   return_as_dict: bool = False,
                                                   frozen_sensor_config: bool = False,
-                                                  ) -> Generator[Union[ScadaData, dict],
-                                                                 bool, None]:
+                                                  ) -> Generator[Union[ScadaData, dict], bool, None]:
         """
         Runs a basic quality analysis using EPANET.
 
         Parameters
         ----------
+        support_abort : `bool`, optional
         hyd_file_in : `str`
             Path to an EPANET .hyd file for storing the simulated hydraulics --
             the quality analysis is computed using those hydraulics.
@@ -1277,16 +1529,16 @@ class ScenarioSimulator():
 
             if verbose is True:
                 if (total_time + tstep) % requested_time_step == 0:
-                    next(progress_bar)
+                    try:
+                        next(progress_bar)
+                    except StopIteration:
+                        pass
 
             # Compute current time step
             t = self.epanet_api.runQualityAnalysis()
             total_time = t
 
             # Fetch data
-            quality_node_data = None
-            quality_link_data = None
-
             quality_node_data = self.epanet_api.getNodeActualQuality().reshape(1, -1)
             quality_link_data = self.epanet_api.getLinkActualQuality().reshape(1, -1)
 
@@ -1381,7 +1633,11 @@ class ScenarioSimulator():
             if hyd_export_old is not None:
                 shutil.copyfile(hyd_export, hyd_export_old)
 
-            os.remove(hyd_export)
+            try:
+                # temp solution
+                os.remove(hyd_export)
+            except:
+                warnings.warn(f"Failed to remove temporary file '{hyd_export}'")
 
         return result
 
@@ -1464,8 +1720,11 @@ class ScenarioSimulator():
                     first_itr = False
 
                 if verbose is True:
-                    if (total_time + tstep) % requested_time_step == 0:
+                    #if (total_time + tstep) % requested_time_step == 0:
+                    try:
                         next(progress_bar)
+                    except StopIteration:
+                        pass
 
                 # Apply system events in a regular time interval only!
                 if (total_time + tstep) % requested_time_step == 0:
@@ -1478,14 +1737,6 @@ class ScenarioSimulator():
                 total_time = t
 
                 # Fetch data
-                pressure_data = None
-                flow_data = None
-                demand_data = None
-                quality_node_data = None
-                quality_link_data = None
-                pumps_state_data = None
-                valves_state_data = None
-
                 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,
@@ -1641,16 +1892,16 @@ class ScenarioSimulator():
 
             Must be one of the following EPANET toolkit constants:
 
-                - EN_CFS = 0
-                - EN_GPM = 1
-                - EN_MGD = 2
-                - EN_IMGD = 3
-                - EN_AFD = 4
-                - EN_LPS = 5
-                - EN_LPM = 6
-                - EN_MLD = 7
-                - EN_CMH = 8
-                - EN_CMD = 9
+                - 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)
 
             The default is None.
         quality_model : `dict`, optional
@@ -1738,7 +1989,7 @@ class ScenarioSimulator():
                 self.epanet_api.setQualityType("age")
             elif quality_model["type"] == "CHEM":
                 self.epanet_api.setQualityType("chem", quality_model["chemical_name"],
-                                               quality_model["units"])
+                                               qualityunits_to_str(quality_model["units"]))
             elif quality_model["type"] == "TRACE":
                 self.epanet_api.setQualityType("trace", quality_model["trace_node_id"])
             else:
@@ -1789,7 +2040,7 @@ class ScenarioSimulator():
         self.set_general_parameters(quality_model={"type": "AGE"})
 
     def enable_chemical_analysis(self, chemical_name: str = "Chlorine",
-                                 chemical_units: str = "mg/L") -> None:
+                                 chemical_units: int = MASS_UNIT_MG) -> None:
         """
         Sets chemical analysis.
 
@@ -1803,9 +2054,13 @@ class ScenarioSimulator():
             The default is "Chlorine".
         chemical_units : `str`, optional
             Units that the chemical is measured in.
-            Either "mg/L" or "ug/L".
 
-            The default is "mg/L".
+            Must be one of the following constants:
+
+                - MASS_UNIT_MG = 4  (mg/L)
+                - MASS_UNIT_UG = 5  (ug/L)
+
+            The default is MASS_UNIT_MG.
         """
         self.__adapt_to_network_changes()