epyt-flow 0.15.0b1__py3-none-any.whl → 0.16.0__py3-none-any.whl

epyt_flow/simulation/scenario_simulator.py

@@ -136,41 +136,27 @@ class ScenarioSimulator():
         self.__running_simulation = False
         self.__uncertainties_applied = False
 
-        # 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
-            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)
-        else:
-            my_f_msx_in = None
+        if scenario_config is not None:     # Extract .inp file from NetworkTopology if necessary
+            if __file_exists(self.__f_inp_in) is False:
+                network_topo = scenario_config.network_topo
+                if network_topo is not None:
+                    warnings.info(".inp file not found -- extracting network data from NetworkTopology")
+                    network_topo.to_inp_file(self.__f_inp_in)
+                else:
+                    raise ValueError(".inp file does not exist and 'scenario_config' does not " +
+                                     "contain a specification of the network topology")
 
         from epanet_plus import EPyT   # Workaround: Sphinx autodoc "importlib.import_module TypeError: __mro_entries__"
-        self.epanet_api = EPyT(my_f_inp_in, use_project=self.__f_msx_in is None)
+        self.epanet_api = EPyT(self.__f_inp_in, use_project=self.__f_msx_in is None)
 
         if self.__f_msx_in is not None:
-            self.epanet_api.load_msx_file(my_f_msx_in)
+            self.epanet_api.load_msx_file(self.__f_msx_in)
 
         # Do not raise exceptions in the case of EPANET warnings and errors
         self.epanet_api.set_error_handling(raise_exception_on_error=raise_exception_on_error,
@@ -188,7 +174,8 @@ class ScenarioSimulator():
 
             self._model_uncertainty = scenario_config.model_uncertainty
             self._sensor_noise = scenario_config.sensor_noise
-            self._sensor_config = scenario_config.sensor_config
+            if scenario_config.sensor_config is not None:
+                self._sensor_config = scenario_config.sensor_config
 
             for control in scenario_config.custom_controls:
                 self.add_custom_control(control)
@@ -614,9 +601,6 @@ class ScenarioSimulator():
         """
         self.epanet_api.close()
 
-        if self.__my_f_inp_in is not None:
-            shutil.rmtree(pathlib.Path(self.__my_f_inp_in).parent)
-
     def __enter__(self):
         return self
 
@@ -924,11 +908,19 @@ class ScenarioSimulator():
         """
         return self.epanet_api.get_reporting_time_step()
 
-    def get_scenario_config(self) -> ScenarioConfig:
+    def get_scenario_config(self, include_network_topology: bool = True) -> ScenarioConfig:
         """
         Gets the configuration of this scenario -- i.e. all information & elements
         that completely describe this scenario.
 
+        Parameters
+        ----------
+        include_network_topology : `bool`, optional
+            If True, the full specification of the network topology (incl. demand patterns)
+            will be included in the scenario configuration.
+
+            The default is True.
+
         Returns
         -------
         :class:`~epyt_flow.simulation.scenario_config.ScenarioConfig`
@@ -944,7 +936,12 @@ class ScenarioSimulator():
                           "quality_model": self.get_quality_model(),
                           "demand_model": self.get_demand_model()}
 
+        network_topology = None
+        if include_network_topology is True:
+            network_topology = self.get_topology(include_demand_patterns=True)
+
         return ScenarioConfig(f_inp_in=self.__f_inp_in, f_msx_in=self.__f_msx_in,
+                              network_topology=network_topology,
                               general_params=general_params, sensor_config=self.sensor_config,
                               memory_consumption_estimate=self.estimate_memory_consumption(),
                               custom_controls=self.custom_controls,
@@ -981,10 +978,18 @@ class ScenarioSimulator():
 
         return n_time_steps * n_quantities * n_bytes_per_quantity * .000001
 
-    def get_topology(self) -> NetworkTopology:
+    def get_topology(self, include_demand_patterns: bool = False) -> NetworkTopology:
         """
         Gets the topology (incl. information such as elevations, pipe diameters, etc.) of this WDN.
 
+        Parameters
+        ----------
+        include_demand_patterns : `bool`, optional
+            If True, demand patterns will be included -- be aware that this will increase
+            the object's memory footprint.
+
+            The default is False.
+
         Returns
         -------
         :class:`~epyt_flow.topology.NetworkTopology`
@@ -993,6 +998,12 @@ class ScenarioSimulator():
         self._adapt_to_network_changes()
 
         # Collect information about the topology of the water distribution network
+        patterns = {}
+        if include_demand_patterns is True:
+            patterns = {pattern_id: self.epanet_api.get_pattern(
+                self.epanet_api.getpatternindex(pattern_id))
+                        for pattern_id in self.epanet_api.get_all_patterns_id()}
+
         nodes_id = self.epanet_api.get_all_nodes_id()
         nodes_elevation = [self.epanet_api.get_node_elevation(node_idx)
                            for node_idx in self.epanet_api.get_all_nodes_idx()]
@@ -1002,7 +1013,16 @@ class ScenarioSimulator():
                        for node_idx in self.epanet_api.get_all_nodes_idx()]
         nodes_comments = [self.epanet_api.get_node_comment(node_idx)
                           for node_idx in self.epanet_api.get_all_nodes_idx()]
-        node_tank_names = self.epanet_api.get_all_tanks_id()
+        nodes_base_demand = [self.epanet_api.get_node_base_demand(node_idx)
+                             for node_idx in self.epanet_api.get_all_nodes_idx()]
+
+        node_demand_patterns_id = []
+        for node_idx in self.epanet_api.get_all_nodes_idx():
+            r = []
+            for pattern_idx in self.epanet_api.get_node_demand_patterns_idx(node_idx):
+                if pattern_idx != 0:
+                    r.append(self.epanet_api.getpatternid(pattern_idx))
+            node_demand_patterns_id.append(r)
 
         links_id = self.epanet_api.get_all_links_id()
         links_type = [self.epanet_api.get_link_type(link_idx)
@@ -1014,65 +1034,121 @@ class ScenarioSimulator():
                         for link_idx in self.epanet_api.get_all_links_idx()]
         links_roughness_coeff = [self.epanet_api.get_link_roughness(link_idx)
                                  for link_idx in self.epanet_api.get_all_links_idx()]
-        links_bulk_coeff = [self.epanet_api.get_link_bulk_raction_coeff(link_idx)
+        links_bulk_coeff = [self.epanet_api.get_link_bulk_reaction_coeff(link_idx)
                             for link_idx in self.epanet_api.get_all_links_idx()]
-        links_wall_coeff = [self.epanet_api.get_link_wall_raction_coeff(link_idx)
+        links_wall_coeff = [self.epanet_api.get_link_wall_reaction_coeff(link_idx)
                             for link_idx in self.epanet_api.get_all_links_idx()]
         links_loss_coeff = [self.epanet_api.get_link_minorloss(link_idx)
                             for link_idx in self.epanet_api.get_all_links_idx()]
+        link_init_setting = [self.epanet_api.get_link_init_setting(link_idx)
+                             for link_idx in self.epanet_api.get_all_links_idx()]
+        link_init_status = [self.epanet_api.get_link_init_status(link_idx)
+                            for link_idx in self.epanet_api.get_all_links_idx()]
 
         pumps_id = self.epanet_api.get_all_pumps_id()
         pumps_type = [self.epanet_api.get_pump_type(pump_idx)
                       for pump_idx in self.epanet_api.get_all_pumps_idx()]
+        pumps_hcurve = [int(self.epanet_api.getlinkvalue(pump_idx, EpanetConstants.EN_PUMP_HCURVE))
+                        for pump_idx in self.epanet_api.get_all_pumps_idx()]
 
         valves_id = self.epanet_api.get_all_valves_id()
 
         # Build graph describing the topology
+        curves = {}
+        def __add_curve(curve_id: str) -> None:
+            curve_type = self.epanet_api.getcurvetype(pump_hcurve_idx)
+            len = self.epanet_api.getcurvelen(pump_hcurve_idx)
+            curve_data = []
+            for i in range(len):
+                x, y = self.epanet_api.getcurvevalue(pump_hcurve_idx, i+1)
+                curve_data.append((x, y))
+            curves[curve_id] = (curve_type, curve_data)
+
         nodes = []
         for node_id, node_elevation, node_type, \
-                node_coord, node_comment in zip(nodes_id, nodes_elevation, nodes_type, nodes_coord,
-                                                nodes_comments):
+                node_coord, node_comment, node_base_demand, node_demand_patterns in \
+                    zip(nodes_id, nodes_elevation, nodes_type, nodes_coord,
+                        nodes_comments, nodes_base_demand, node_demand_patterns_id):
             node_info = {"elevation": node_elevation,
                          "coord": node_coord,
                          "comment": node_comment,
-                         "type": node_type}
+                         "type": node_type,
+                         "base_demand": node_base_demand}
+            if include_demand_patterns is True:
+                node_info["demand_patterns_id"] = node_demand_patterns
             if node_type == EpanetConstants.EN_TANK:
                 node_tank_idx = self.epanet_api.get_node_idx(node_id)
                 node_info["diameter"] = float(self.epanet_api.get_tank_diameter(node_tank_idx))
-                node_info["volume"] = float(self.epanet_api.get_tank_volume(node_tank_idx))
                 node_info["max_level"] = float(self.epanet_api.get_tank_max_level(node_tank_idx))
                 node_info["min_level"] = float(self.epanet_api.get_tank_min_level(node_tank_idx))
+                node_info["min_vol"] = float(self.epanet_api.get_tank_min_vol(node_tank_idx))
                 node_info["mixing_fraction"] = float(self.epanet_api.get_tank_mix_fraction(node_tank_idx))
                 node_info["mixing_model"] = int(self.epanet_api.get_tank_mix_model(node_tank_idx))
+                node_info["init_vol"] = self.epanet_api.getnodevalue(node_tank_idx,
+                                                                     EpanetConstants.EN_INITVOLUME)
+                node_info["cylindric"] = self.epanet_api.getnodevalue(node_tank_idx,
+                                                                      EpanetConstants.EN_VOLCURVE) == 0
+                node_info["can_overflow"] = bool(self.epanet_api.can_tank_overflow(node_tank_idx))
+
+                node_info["vol_curve_id"] = ""
+                tank_vol_curve_idx = int(self.epanet_api.get_tank_vol_curve_idx(node_tank_idx))
+                if tank_vol_curve_idx != 0:
+                    curve_id = self.epanet_api.getcurveid(tank_vol_curve_idx)
+                    node_info["vol_curve_id"] = curve_id
+
+                    if curve_id not in curves:
+                        __add_curve(curve_id)
 
             nodes.append((node_id, node_info))
 
         links = []
         for link_id, link_type, link, diameter, length, roughness_coeff, bulk_coeff, \
-            wall_coeff, loss_coeff in zip(links_id, links_type, links_data, links_diameter,
-                                          links_length, links_roughness_coeff, links_bulk_coeff,
-                                          links_wall_coeff, links_loss_coeff):
+            wall_coeff, loss_coeff, initial_setting, initial_status in \
+                zip(links_id, links_type, links_data, links_diameter, links_length,
+                    links_roughness_coeff, links_bulk_coeff, links_wall_coeff, links_loss_coeff,
+                    link_init_setting, link_init_status):
             links.append((link_id, list(link),
                           {"type": link_type, "diameter": diameter, "length": length,
                            "roughness_coeff": roughness_coeff,
                            "bulk_coeff": bulk_coeff, "wall_coeff": wall_coeff,
-                           "loss_coeff": loss_coeff}))
+                           "loss_coeff": loss_coeff, "init_setting": initial_setting,
+                           "init_status": initial_status}))
 
         pumps = {}
-        for pump_id, pump_type in zip(pumps_id, pumps_type):
+        for pump_id, pump_type, pump_hcurve_idx in zip(pumps_id, pumps_type, pumps_hcurve):
             link_idx = links_id.index(pump_id)
             link = links_data[link_idx]
-            pumps[pump_id] = {"type": pump_type, "end_points": link}
+            pump_init_setting = link_init_setting[link_idx]
+            pump_init_status = link_init_status[link_idx]
+
+            curve_id = None
+            if pump_hcurve_idx != 0:
+                curve_id = self.epanet_api.getcurveid(pump_hcurve_idx)
+
+                if curve_id not in curves:
+                    __add_curve(curve_id)
+
+            pumps[pump_id] = {"type": pump_type, "end_points": link,
+                              "init_setting": pump_init_setting,
+                              "init_status": pump_init_status,
+                              "curve_id": curve_id}
 
         valves = {}
         for valve_id in valves_id:
             link_idx = links_id.index(valve_id)
             link = links_data[link_idx]
             valve_type = links_type[link_idx]
-            valves[valve_id] = {"type": valve_type, "end_points": link}
+            valve_diameter = links_diameter[link_idx]
+            valve_init_setting = link_init_setting[link_idx]
+            valve_init_status = link_init_status[link_idx]
+            valves[valve_id] = {"type": valve_type, "end_points": link,
+                                "diameter": valve_diameter,
+                                "initial_setting": valve_init_setting,
+                                "initial_status": valve_init_status}
 
         return NetworkTopology(f_inp=self.f_inp_in, nodes=nodes, links=links, pumps=pumps,
-                               valves=valves, units=self.get_units_category())
+                               valves=valves, curves=curves, patterns=patterns,
+                               units=self.get_units_category())
 
     def plot_topology(self, export_to_file: str = None) -> None:
         """
@@ -1195,7 +1271,7 @@ class ScenarioSimulator():
         else:
             base_demand = 0
             for demand_idx in range(n_demand_categories):
-                base_demand += self.epanet_api.getbasedemand(node_idx)[demand_idx + 1]
+                base_demand += self.epanet_api.getbasedemand(node_idx, demand_idx + 1)
 
             return base_demand
 
@@ -1223,11 +1299,14 @@ class ScenarioSimulator():
         node_idx = self.epanet_api.get_node_idx(node_id)
 
         if self.epanet_api.getnodetype(node_idx) != EpanetConstants.EN_RESERVOIR:
-            demand_pattern_idx = self.epanet_api.getdemandpattern(node_idx)
+            demand_pattern_idx = self.epanet_api.getdemandpattern(node_idx, 1)
         else:
             demand_pattern_idx = self.epanet_api.getnodevalue(node_idx, EpanetConstants.EN_PATTERN)
 
-        return self.get_pattern(self.epanet_api.getpatternid(demand_pattern_idx))
+        if demand_pattern_idx == 0:
+            return None
+        else:
+            return self.get_pattern(self.epanet_api.getpatternid(demand_pattern_idx))
 
     def set_node_demand_pattern(self, node_id: str, base_demand: float, demand_pattern_id: str,
                                 demand_pattern: np.ndarray = None) -> None:
@@ -1959,7 +2038,8 @@ class ScenarioSimulator():
     def run_advanced_quality_simulation(self, hyd_file_in: str, verbose: bool = False,
                                         frozen_sensor_config: bool = False,
                                         use_quality_time_step_as_reporting_time_step: bool = False,
-                                        reapply_uncertainties: bool = False
+                                        reapply_uncertainties: bool = False,
+                                        float_type: type = np.float32
                                         ) -> ScadaData:
         """
         Runs an advanced quality analysis using EPANET-MSX.
@@ -1989,6 +2069,10 @@ class ScenarioSimulator():
             If True, the uncertainties are re-applied on the original properties.
 
             The default is False.
+        float_type : `type`, optional
+            Floating point type (precision).
+
+            The default is 32bit -- i.e., numpy.float32
 
         Returns
         -------
@@ -2010,7 +2094,8 @@ class ScenarioSimulator():
                                  frozen_sensor_config=frozen_sensor_config,
                                  use_quality_time_step_as_reporting_time_step=
                                  use_quality_time_step_as_reporting_time_step,
-                                 reapply_uncertainties=reapply_uncertainties):
+                                 reapply_uncertainties=reapply_uncertainties,
+                                 float_type=float_type):
             if result is None:
                 result = {}
                 for data_type, data in scada_data.items():
@@ -2038,7 +2123,8 @@ class ScenarioSimulator():
                                                      return_as_dict: bool = False,
                                                      frozen_sensor_config: bool = False,
                                                      use_quality_time_step_as_reporting_time_step: bool = False,
-                                                     reapply_uncertainties: bool = False
+                                                     reapply_uncertainties: bool = False,
+                                                     float_type: type = np.float32,
                                                      ) -> Generator[Union[tuple[ScadaData, bool], tuple[dict, bool]], bool, None]:
         """
         Runs an advanced quality analysis using EPANET-MSX.
@@ -2072,6 +2158,10 @@ class ScenarioSimulator():
             If True, the uncertainties are re-applied on the original properties.
 
             The default is False.
+        float_type : `type`, optional
+            Floating point type (precision).
+
+            The default is 32bit -- i.e., numpy.float32
 
         Returns
         -------
@@ -2145,13 +2235,15 @@ 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,
+                                                            dtype=float_type). \
                     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,
+                                                            dtype=float_type). \
                     reshape((1, len(bulk_species_idx), n_links))
 
             # Surface species
@@ -2168,7 +2260,8 @@ 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,
+                                                          dtype=float_type). \
                     reshape((1, len(surface_species_idx), n_links))
 
             return bulk_species_node_concentrations, bulk_species_link_concentrations, \
@@ -2271,7 +2364,8 @@ class ScenarioSimulator():
 
     def run_basic_quality_simulation(self, hyd_file_in: str, verbose: bool = False,
                                      frozen_sensor_config: bool = False,
-                                     use_quality_time_step_as_reporting_time_step: bool = False
+                                     use_quality_time_step_as_reporting_time_step: bool = False,
+                                     float_type: type = np.float32
                                      ) -> ScadaData:
         """
         Runs a basic quality analysis using EPANET.
@@ -2297,6 +2391,10 @@ class ScenarioSimulator():
             with the hydraulic simulation.
 
             The default is False.
+        float_type : `type`, optional
+            Floating point type (precision).
+
+            The default is 32bit -- i.e., numpy.float32
 
         Returns
         -------
@@ -2315,7 +2413,8 @@ class ScenarioSimulator():
                                  return_as_dict=True,
                                  frozen_sensor_config=frozen_sensor_config,
                                  use_quality_time_step_as_reporting_time_step=
-                                 use_quality_time_step_as_reporting_time_step):
+                                 use_quality_time_step_as_reporting_time_step,
+                                 float_type=float_type):
             if result is None:
                 result = {}
                 for data_type, data in scada_data.items():
@@ -2339,7 +2438,8 @@ class ScenarioSimulator():
                                                   support_abort: bool = False,
                                                   return_as_dict: bool = False,
                                                   frozen_sensor_config: bool = False,
-                                                  use_quality_time_step_as_reporting_time_step: bool = False
+                                                  use_quality_time_step_as_reporting_time_step: bool = False,
+                                                  float_type: type = np.float32
                                                   ) -> Generator[Union[tuple[ScadaData, bool], tuple[dict, bool]], bool, None]:
         """
         Runs a basic quality analysis using EPANET.
@@ -2371,6 +2471,10 @@ class ScenarioSimulator():
             with the hydraulic simulation.
 
             The default is False.
+        float_type : `type`, optional
+            Floating point type (precision).
+
+            The default is 32bit -- i.e., numpy.float32
 
         Returns
         -------
@@ -2429,8 +2533,10 @@ class ScenarioSimulator():
             error_code = self.epanet_api.get_last_error_code()
             if last_error_code == 0:
                 last_error_code = error_code
-            quality_node_data = np.array(self.epanet_api.getnodevalues(EpanetConstants.EN_QUALITY)).reshape(1, -1)
-            quality_link_data = np.array(self.epanet_api.getlinkvalues(EpanetConstants.EN_QUALITY)).reshape(1, -1)
+            quality_node_data = np.array(self.epanet_api.getnodevalues(EpanetConstants.EN_QUALITY),
+                                         dtype=float_type).reshape(1, -1)
+            quality_link_data = np.array(self.epanet_api.getlinkvalues(EpanetConstants.EN_QUALITY),
+                                         dtype=float_type).reshape(1, -1)
 
             # Yield results in a regular time interval only!
             if total_time % reporting_time_step == 0 and total_time >= reporting_time_start:
@@ -2467,7 +2573,8 @@ class ScenarioSimulator():
 
     def run_hydraulic_simulation(self, hyd_export: str = None, verbose: bool = False,
                                  frozen_sensor_config: bool = False,
-                                 reapply_uncertainties: bool = False) -> ScadaData:
+                                 reapply_uncertainties: bool = False,
+                                 float_type: type = np.float32) -> ScadaData:
         """
         Runs the hydraulic simulation of this scenario (incl. basic quality if set).
 
@@ -2495,6 +2602,10 @@ class ScenarioSimulator():
             If True, the uncertainties are re-applied on the original properties.
 
             The default is False.
+        float_type : `type`, optional
+            Floating point type (precision).
+
+            The default is 32bit -- i.e., numpy.float32
 
         Returns
         -------
@@ -2514,7 +2625,8 @@ class ScenarioSimulator():
                                  verbose=verbose,
                                  return_as_dict=True,
                                  frozen_sensor_config=frozen_sensor_config,
-                                 reapply_uncertainties=reapply_uncertainties):
+                                 reapply_uncertainties=reapply_uncertainties,
+                                 float_type=float_type):
             if result is None:
                 result = {}
                 for data_type, data in scada_data.items():
@@ -2544,7 +2656,8 @@ class ScenarioSimulator():
                                               support_abort: bool = False,
                                               return_as_dict: bool = False,
                                               frozen_sensor_config: bool = False,
-                                              reapply_uncertainties: bool = False
+                                              reapply_uncertainties: bool = False,
+                                              float_type: type = np.float32
                                               ) -> Generator[Union[tuple[ScadaData, bool], tuple[dict, bool]], bool, None]:
         """
         Runs the hydraulic simulation of this scenario (incl. basic quality if set) and
@@ -2585,6 +2698,10 @@ class ScenarioSimulator():
             If True, the uncertainties are re-applied on the original properties.
 
             The default is False.
+        float_type : `type`, optional
+            Floating point type (precision).
+
+            The default is 32bit -- i.e., numpy.float32
 
         Returns
         -------
@@ -2603,7 +2720,7 @@ class ScenarioSimulator():
 
         self.epanet_api.openH()
         self.epanet_api.openQ()
-        self.epanet_api.initH(EpanetConstants.EN_SAVE)
+        self.epanet_api.initH(EpanetConstants.EN_SAVE_AND_INIT)
         self.epanet_api.initQ(EpanetConstants.EN_SAVE)
 
         requested_total_time = self.epanet_api.get_simulation_duration()
@@ -2653,32 +2770,42 @@ class ScenarioSimulator():
                     last_error_code = error_code
 
                 # Fetch data
-                pressure_data = np.array(self.epanet_api.getnodevalues(EpanetConstants.EN_PRESSURE)).reshape(1, -1)
-                flow_data = np.array(self.epanet_api.getlinkvalues(EpanetConstants.EN_FLOW)).reshape(1, -1)
-                demand_data = np.array(self.epanet_api.getnodevalues(EpanetConstants.EN_DEMAND)).reshape(1, -1)
-                quality_node_data = np.array(self.epanet_api.getnodevalues(EpanetConstants.EN_QUALITY)).reshape(1, -1)
-                quality_link_data = np.array(self.epanet_api.getlinkvalues(EpanetConstants.EN_QUALITY)).reshape(1, -1)
+                pressure_data = np.array(self.epanet_api.getnodevalues(EpanetConstants.EN_PRESSURE),
+                                         dtype=float_type).reshape(1, -1)
+                flow_data = np.array(self.epanet_api.getlinkvalues(EpanetConstants.EN_FLOW),
+                                     dtype=float_type).reshape(1, -1)
+                demand_data = np.array(self.epanet_api.getnodevalues(EpanetConstants.EN_DEMAND),
+                                       dtype=float_type).reshape(1, -1)
+                quality_node_data = np.array(self.epanet_api.getnodevalues(EpanetConstants.EN_QUALITY),
+                                             dtype=float_type).reshape(1, -1)
+                quality_link_data = np.array(self.epanet_api.getlinkvalues(EpanetConstants.EN_QUALITY),
+                                             dtype=float_type).reshape(1, -1)
 
                 tanks_volume_data = None
                 if len(self.epanet_api.get_all_tanks_idx()) > 0:
                     tanks_volume_data = np.array([self.epanet_api.get_tank_volume(tank_idx)
-                                                  for tank_idx in self.epanet_api.get_all_tanks_idx()]).reshape(1, -1)
+                                                  for tank_idx in self.epanet_api.get_all_tanks_idx()],
+                                                  dtype=float_type).reshape(1, -1)
 
                 pumps_state_data = None
                 pumps_energy_usage_data = None
                 pumps_efficiency_data = None
                 if len(self.epanet_api.get_all_pumps_idx()) > 0:
                     pumps_state_data = np.array([self.epanet_api.getlinkvalue(link_idx, EpanetConstants.EN_PUMP_STATE)
-                                                for link_idx in self.epanet_api.get_all_pumps_idx()]).reshape(1, -1)
+                                                for link_idx in self.epanet_api.get_all_pumps_idx()],
+                                                dtype=float_type).reshape(1, -1)
                     pumps_energy_usage_data = np.array([self.epanet_api.get_pump_energy_usage(pump_idx)
-                                                        for pump_idx in self.epanet_api.get_all_pumps_idx()]).reshape(1, -1)
+                                                        for pump_idx in self.epanet_api.get_all_pumps_idx()],
+                                                        dtype=float_type).reshape(1, -1)
                     pumps_efficiency_data = np.array([self.epanet_api.get_pump_efficiency(pump_idx)
-                                                      for pump_idx in self.epanet_api.get_all_pumps_idx()]).reshape(1, -1)
+                                                      for pump_idx in self.epanet_api.get_all_pumps_idx()],
+                                                      dtype=float_type).reshape(1, -1)
 
                 valves_state_data = None
                 if len(self.epanet_api.get_all_valves_idx()) > 0:
                     valves_state_data = np.array([self.epanet_api.getlinkvalue(link_valve_idx, EpanetConstants.EN_STATUS)
-                                                  for link_valve_idx in self.epanet_api.get_all_valves_idx()]).reshape(1, -1)
+                                                  for link_valve_idx in self.epanet_api.get_all_valves_idx()],
+                                                  dtype=float_type).reshape(1, -1)
 
                 scada_data = ScadaData(network_topo=network_topo,
                                        sensor_config=self._sensor_config,
@@ -2753,7 +2880,8 @@ class ScenarioSimulator():
 
     def run_simulation(self, hyd_export: str = None, verbose: bool = False,
                        frozen_sensor_config: bool = False,
-                       reapply_uncertainties: bool = False) -> ScadaData:
+                       reapply_uncertainties: bool = False,
+                       float_type: type = np.float32) -> ScadaData:
         """
         Runs the simulation of this scenario.
 
@@ -2779,6 +2907,10 @@ class ScenarioSimulator():
             If True, the uncertainties are re-applied on the original properties.
 
             The default is False.
+        float_type : `type`, optional
+            Floating point type (precision).
+
+            The default is 32bit -- i.e., numpy.float32
 
         Returns
         -------
@@ -2799,7 +2931,8 @@ class ScenarioSimulator():
         # Run hydraulic simulation step-by-step
         result = self.run_hydraulic_simulation(hyd_export=hyd_export, verbose=verbose,
                                                frozen_sensor_config=frozen_sensor_config,
-                                               reapply_uncertainties=reapply_uncertainties)
+                                               reapply_uncertainties=reapply_uncertainties,
+                                               float_type=float_type)
 
         # If necessary, run advanced quality simulation utilizing the computed hydraulics
         if self.f_msx_in is not None:
@@ -2807,7 +2940,8 @@ class ScenarioSimulator():
             result_msx = gen(hyd_file_in=hyd_export,
                              verbose=verbose,
                              frozen_sensor_config=frozen_sensor_config,
-                             reapply_uncertainties=reapply_uncertainties)
+                             reapply_uncertainties=reapply_uncertainties,
+                             float_type=float_type)
             result.join(result_msx)
 
             if hyd_export_old is not None:
@@ -3472,7 +3606,8 @@ class ScenarioSimulator():
                 if node_init_qual < 0:
                     raise ValueError(f"{node_id}: Initial node quality can not be negative")
 
-            for node_idx in self.epanet_api.get_all_nodes_idx():
+            for node_id, node_init_qual in initial_quality.items():
+                node_idx = self.epanet_api.get_node_idx(node_id)
                 self.epanet_api.set_node_init_quality(node_idx, node_init_qual)
 
         if order_wall is not None:
@@ -3720,17 +3855,18 @@ class ScenarioSimulator():
                 any(not isinstance(species_id, str) or not isinstance(link_initial_conc, list)
                     for species_id, link_initial_conc in inital_conc.items()) or \
                 any(not isinstance(link_initial_conc, tuple)
-                    for link_initial_conc in inital_conc.values()) or \
+                    for link_initial_conc in list(itertools.chain(*inital_conc.values()))) or \
                 any(not isinstance(link_id, str) or not isinstance(conc, float)
-                    for link_id, conc in inital_conc.values()):
+                    for link_id, conc in list(itertools.chain(*inital_conc.values()))):
             raise TypeError("'inital_conc' must be an instance of " +
                             "'dict[str, list[tuple[str, float]]'")
         if any(species_id not in self.sensor_config.bulk_species
                for species_id in inital_conc.keys()):
             raise ValueError("Unknown bulk species in 'inital_conc'")
-        if any(link_id not in self.sensor_config.links for link_id, _ in inital_conc.values()):
+        if any(link_id not in self.sensor_config.links for link_id, _ in
+               list(itertools.chain(*inital_conc.values()))):
             raise ValueError("Unknown link ID in 'inital_conc'")
-        if any(conc < 0 for _, conc in inital_conc.values()):
+        if any(conc < 0 for _, conc in list(itertools.chain(*inital_conc.values()))):
             raise ValueError("Initial link concentration can not be negative")
 
         for species_id, link_initial_conc in inital_conc.items():