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

epyt_flow/simulation/scada/scada_data_export.py

@@ -142,7 +142,11 @@ class ScadaDataExport():
                     unit_desc = massunit_to_str(sensor_config.
                                                 bulk_species_mass_unit[surface_species_idx])
 
-                col_desc[col_id] = [sensor_type, item_id, unit_desc]
+                if sensor_type not in ["bulk_species_node", "bulk_species_link", "surface_species"]:
+                    col_desc[col_id] = [sensor_type, item_id, unit_desc]
+                else:
+                    for location_id, c_id in col_id.items():
+                        col_desc[c_id] = [sensor_type, f"{item_id} @ {location_id}", unit_desc]
 
         return np.array(col_desc, dtype=object)
 

epyt_flow/simulation/scenario_simulator.py

@@ -1644,64 +1644,73 @@ class ScenarioSimulator():
 
         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([0])}
+                data = {"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([0])}
             else:
-                yield ScadaData(sensor_config=self.__sensor_config,
-                                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([0]),
-                                sensor_reading_events=self.__sensor_reading_events,
-                                sensor_noise=self.__sensor_noise,
-                                frozen_sensor_config=frozen_sensor_config)
+                data = ScadaData(sensor_config=self.__sensor_config,
+                                 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([0]),
+                                 sensor_reading_events=self.__sensor_reading_events,
+                                 sensor_noise=self.__sensor_noise,
+                                 frozen_sensor_config=frozen_sensor_config)
+
+            if support_abort is True:  # Can the simulation be aborted? If so, handle it.
+                abort = yield
+                if abort is True:
+                    return None
+
+            yield data
 
         # 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
-                if abort is not False:
-                    break
-
             # 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:
+                if verbose is True:
+                    try:
+                        next(progress_bar)
+                    except StopIteration:
+                        pass
+
                 bulk_species_node_concentrations, bulk_species_link_concentrations, \
                     surface_species_concentrations = __get_concentrations()
 
                 # 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_link_concentration_raw":
-                                   bulk_species_link_concentrations,
-                               "surface_species_concentration_raw": surface_species_concentrations,
-                               "sensor_readings_time": np.array([total_time])}
+                        data = {"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])}
                     else:
-                        yield ScadaData(sensor_config=self.__sensor_config,
-                                        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_reading_events=self.__sensor_reading_events,
-                                        sensor_noise=self.__sensor_noise,
-                                        frozen_sensor_config=frozen_sensor_config)
+                        data = ScadaData(sensor_config=self.__sensor_config,
+                                         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_reading_events=self.__sensor_reading_events,
+                                         sensor_noise=self.__sensor_noise,
+                                         frozen_sensor_config=frozen_sensor_config)
+
+                    if support_abort is True:  # Can the simulation be aborted? If so, handle it.
+                        abort = yield
+                        if abort is not False:
+                            break
+
+                    yield data
 
         self.__running_simulation = False
 
@@ -1816,11 +1825,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
@@ -1843,27 +1847,36 @@ 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 {"node_quality_data_raw": quality_node_data,
-                           "link_quality_data_raw": quality_link_data,
-                           "sensor_readings_time": np.array([total_time])}
+                    data = {"node_quality_data_raw": quality_node_data,
+                            "link_quality_data_raw": quality_link_data,
+                            "sensor_readings_time": np.array([total_time])}
                 else:
-                    yield ScadaData(sensor_config=self.__sensor_config,
-                                    node_quality_data_raw=quality_node_data,
-                                    link_quality_data_raw=quality_link_data,
-                                    sensor_readings_time=np.array([total_time]),
-                                    sensor_reading_events=self.__sensor_reading_events,
-                                    sensor_noise=self.__sensor_noise,
-                                    frozen_sensor_config=frozen_sensor_config)
+                    data = ScadaData(sensor_config=self.__sensor_config,
+                                     node_quality_data_raw=quality_node_data,
+                                     link_quality_data_raw=quality_link_data,
+                                     sensor_readings_time=np.array([total_time]),
+                                     sensor_reading_events=self.__sensor_reading_events,
+                                     sensor_noise=self.__sensor_noise,
+                                     frozen_sensor_config=frozen_sensor_config)
+
+                if support_abort is True:  # Can the simulation be aborted? If so, handle it.
+                    abort = yield
+                    if abort is True:
+                        break
+
+                yield data
 
             # Next
             tstep = self.epanet_api.nextQualityAnalysisStep()
 
         self.epanet_api.closeHydraulicAnalysis()
 
-    def run_simulation(self, hyd_export: str = None, verbose: bool = False,
-                       frozen_sensor_config: bool = False) -> ScadaData:
+    def run_hydraulic_simulation(self, hyd_export: str = None, verbose: bool = False,
+                                 frozen_sensor_config: bool = False) -> ScadaData:
         """
-        Runs the simulation of this scenario.
+        Runs the hydraulic simulation of this scenario (incl. basic quality if set).
+
+        Note that this function does not call EPANET-MSX even if an .msx file was provided.
 
         Parameters
         ----------
@@ -1896,12 +1909,8 @@ class ScenarioSimulator():
 
         result = None
 
-        hyd_export_old = hyd_export
-        if self.__f_msx_in is not None:
-            hyd_export = os.path.join(get_temp_folder(), f"epytflow_MSX_{uuid.uuid4()}.hyd")
-
         # Run hydraulic simulation step-by-step
-        gen = self.run_simulation_as_generator
+        gen = self.run_hydraulic_simulation_as_generator
         for scada_data in gen(hyd_export=hyd_export,
                               verbose=verbose,
                               return_as_dict=True,
@@ -1923,32 +1932,18 @@ class ScenarioSimulator():
                            sensor_noise=self.__sensor_noise,
                            frozen_sensor_config=frozen_sensor_config)
 
-        # If necessary, run advanced quality simulation utilizing the computed hydraulics
-        if self.f_msx_in is not None:
-            gen = self.run_advanced_quality_simulation
-            result_msx = gen(hyd_file_in=hyd_export,
-                             verbose=verbose,
-                             frozen_sensor_config=frozen_sensor_config)
-            result.join(result_msx)
-
-            if hyd_export_old is not None:
-                shutil.copyfile(hyd_export, hyd_export_old)
-
-            try:
-                # temp solution
-                os.remove(hyd_export)
-            except:
-                warnings.warn(f"Failed to remove temporary file '{hyd_export}'")
-
         return result
 
-    def run_simulation_as_generator(self, hyd_export: str = None, verbose: bool = False,
-                                    support_abort: bool = False,
-                                    return_as_dict: bool = False,
-                                    frozen_sensor_config: bool = False,
-                                    ) -> Generator[Union[ScadaData, dict], bool, None]:
+    def run_hydraulic_simulation_as_generator(self, hyd_export: str = None, verbose: bool = False,
+                                              support_abort: bool = False,
+                                              return_as_dict: bool = False,
+                                              frozen_sensor_config: bool = False,
+                                              ) -> Generator[Union[ScadaData, dict], bool, None]:
         """
-        Runs the simulation of this scenario and provides the results as a generator.
+        Runs the hydraulic simulation of this scenario (incl. basic quality if set) and
+        provides the results as a generator.
+
+        Note that this function does not run EPANET-MSX, even if an .msx file was provided.
 
         Parameters
         ----------
@@ -2021,11 +2016,11 @@ class ScenarioSimulator():
                     first_itr = False
 
                 if verbose is True:
-                    #if (total_time + tstep) % requested_time_step == 0:
-                    try:
-                        next(progress_bar)
-                    except StopIteration:
-                        pass
+                    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:
@@ -2088,7 +2083,7 @@ class ScenarioSimulator():
 
                     if support_abort is True:  # Can the simulation be aborted? If so, handle it.
                         abort = yield
-                        if abort is not False:
+                        if abort is True:
                             break
 
                     yield data
@@ -2112,6 +2107,69 @@ class ScenarioSimulator():
             self.__running_simulation = False
             raise ex
 
+    def run_simulation(self, hyd_export: str = None, verbose: bool = False,
+                       frozen_sensor_config: bool = False) -> ScadaData:
+        """
+        Runs the simulation of this scenario.
+
+        Parameters
+        ----------
+        hyd_export : `str`, optional
+            Path to an EPANET .hyd file for storing the simulated hydraulics -- these hydraulics
+            can be used later for an advanced quality analysis using EPANET-MSX.
+
+            If None, the simulated hydraulics will NOT be exported to an EPANET .hyd file.
+
+            The default is None.
+        verbose : `bool`, optional
+            If True, method will be verbose (e.g. showing a progress bar).
+
+            The default is False.
+        frozen_sensor_config : `bool`, optional
+            If True, the sensor config can not be changed and only the required sensor nodes/links
+            will be stored -- this usually leads to a significant reduction in memory consumption.
+
+            The default is False.
+
+        Returns
+        -------
+        :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
+
+        hyd_export_old = hyd_export
+        if self.__f_msx_in is not None:
+            hyd_export = os.path.join(get_temp_folder(), f"epytflow_MSX_{uuid.uuid4()}.hyd")
+
+        # Run hydraulic simulation step-by-step
+        result = self.run_hydraulic_simulation(hyd_export=hyd_export, verbose=verbose,
+                                               frozen_sensor_config=frozen_sensor_config)
+
+        # If necessary, run advanced quality simulation utilizing the computed hydraulics
+        if self.f_msx_in is not None:
+            gen = self.run_advanced_quality_simulation
+            result_msx = gen(hyd_file_in=hyd_export,
+                             verbose=verbose,
+                             frozen_sensor_config=frozen_sensor_config)
+            result.join(result_msx)
+
+            if hyd_export_old is not None:
+                shutil.copyfile(hyd_export, hyd_export_old)
+
+            try:
+                # temp solution
+                os.remove(hyd_export)
+            except:
+                warnings.warn(f"Failed to remove temporary file '{hyd_export}'")
+
+        return result
+
     def set_model_uncertainty(self, model_uncertainty: ModelUncertainty) -> None:
         """
         Specifies the model uncertainties.
@@ -2480,3 +2538,65 @@ class ScenarioSimulator():
         self.__warn_if_quality_set()
         self.set_general_parameters(quality_model={"type": "TRACE",
                                                    "trace_node_id": trace_node_id})
+
+    def add_species_injection_source(self, species_id: str, node_id: str, pattern: np.ndarray,
+                                     source_type: int, pattern_id: str = None,
+                                     source_strength: int = 1.) -> None:
+        """
+        Adds a new external (bulk or surface) species injection source at a particular node.
+
+        Parameters
+        ----------
+        species_id : `str`
+            ID of the (bulk or surface) species.
+        node_id : `str`
+            ID of the node at which this external (bulk or surface) species injection source
+            is placed.
+        pattern : `numpy.ndarray`
+            1d source pattern.
+        source_type : `int`,
+            Type of the external (bulk or surface) species injection source -- must be one of
+            the following EPANET toolkit constants:
+
+                - EN_CONCEN     = 0
+                - EN_MASS       = 1
+                - EN_SETPOINT   = 2
+                - EN_FLOWPACED  = 3
+
+            Description:
+
+                - E_CONCEN Sets the concentration of external inflow entering a node
+                - EN_MASS Injects a given mass/minute into a node
+                - EN_SETPOINT Sets the concentration leaving a node to a given value
+                - EN_FLOWPACED Adds a given value to the concentration leaving a node
+        pattern_id : `str`, optional
+            ID of the source pattern.
+
+            If None, a pattern_id will be generated automatically -- be aware that this
+            could conflict with existing pattern IDs (in this case, an exception is raised).
+
+            The default is None.
+        source_strength : `int`, optional
+            Injection source strength -- i.e. injection = source_strength * pattern.
+
+            The default is 1.
+        """
+        source_type_ = "None"
+        if source_type == ToolkitConstants.EN_CONCEN:
+            source_type_ = "CONCEN"
+        elif source_type == ToolkitConstants.EN_MASS:
+            source_type_ = "MASS"
+        elif source_type == ToolkitConstants.EN_SETPOINT:
+            source_type_ = "SETPOINT"
+        elif source_type == ToolkitConstants.EN_FLOWPACED:
+            source_type_ = "FLOWPACED"
+
+        if pattern_id is None:
+            pattern_id = f"{species_id}_{node_id}"
+        if pattern_id in self.epanet_api.getMSXPatternsNameID():
+            raise ValueError("Invalid 'pattern_id' -- " +
+                             f"there already exists a pattern with ID '{pattern_id}'")
+
+        self.epanet_api.addMSXPattern(pattern_id, pattern)
+        self.epanet_api.setMSXSources(node_id, species_id, source_type_, source_strength,
+                                      pattern_id)

epyt_flow/simulation/sensor_config.py

@@ -112,7 +112,7 @@ def massunit_to_str(unit_id: int) -> str:
     Parameters
     ----------
     unit_id : `int`
-        ID of the flow unit.
+        ID of the mass unit.
 
         Must be one of the following constant:
 
@@ -1916,6 +1916,53 @@ class SensorConfig(JsonSerializable):
             f"{list(map(massunit_to_str, self.__surface_species_mass_unit))} " +\
             f"surface_species_area_unit: {areaunit_to_str(self.__surface_species_area_unit)}"
 
+    def get_bulk_species_mass_unit_id(self, bulk_species_id: str) -> int:
+        """
+        Returns the mass unit of a given bulk species.
+
+        Parameters
+        ----------
+        bulk_species_id : `str`
+            ID of the bulk species.
+
+        Returns
+        -------
+        `int`
+            ID of the mass unit.
+
+            Will be one of the following constant:
+
+                - MASS_UNIT_MG   = 4
+                - MASS_UNIT_UG   = 5
+                - MASS_UNIT_MOL  = 6
+                - MASS_UNIT_MMOL = 7
+        """
+        return self.__bulk_species_mass_unit[self.map_bulkspecies_id_to_idx(bulk_species_id)]
+
+    def get_surface_species_mass_unit_id(self, surface_species_id: str) -> int:
+        """
+        Returns the mass unit of a given surface species.
+
+        Parameters
+        ----------
+        surface_species_id : `str`
+            ID of the surface species.
+
+        Returns
+        -------
+        `int`
+            ID of the mass unit.
+
+            Will be one of the following constant:
+
+                - MASS_UNIT_MG   = 4
+                - MASS_UNIT_UG   = 5
+                - MASS_UNIT_MOL  = 6
+                - MASS_UNIT_MMOL = 7
+        """
+        return self.__surface_species_mass_unit[self.map_surfacespecies_id_to_idx(
+            surface_species_id)]
+
     def compute_readings(self, pressures: np.ndarray, flows: np.ndarray, demands: np.ndarray,
                          nodes_quality: np.ndarray, links_quality: np.ndarray,
                          pumps_state: np.ndarray, pumps_efficiency: np.ndarray,

epyt_flow/uncertainty/model_uncertainty.py

@@ -293,17 +293,23 @@ class ModelUncertainty(JsonSerializable):
             epanet_api.setNodeElevations(elevations)
 
         if self.__constants is not None:
-            constants = epanet_api.getMSXConstantsValue()
+            constants = np.array(epanet_api.getMSXConstantsValue())
             constants = self.__constants.apply_batch(constants)
             epanet_api.setMSXConstantsValue(constants)
 
         if self.__parameters is not None:
             parameters_pipes = epanet_api.getMSXParametersPipesValue()
             for i, pipe_idx in enumerate(epanet_api.getLinkPipeIndex()):
-                parameters_pipes[i] = self.__parameters.apply_batch(parameters_pipes[i])
-                epanet_api.setMSXParametersPipesValue(pipe_idx, parameters_pipes[i])
+                if len(parameters_pipes[i]) == 0:
+                    continue
+
+                parameters_pipes_val = self.__parameters.apply_batch(np.array(parameters_pipes[i]))
+                epanet_api.setMSXParametersPipesValue(pipe_idx, parameters_pipes_val)
 
             parameters_tanks = epanet_api.getMSXParametersTanksValue()
             for i, tank_idx in enumerate(epanet_api.getNodeTankIndex()):
-                parameters_tanks[i] = self.__parameters.apply_batch(parameters_tanks[i])
-                epanet_api.setMSXParametersTanksValue(tank_idx, parameters_tanks[i])
+                if parameters_tanks[i] is None or len(parameters_tanks[i]) == 0:
+                    continue
+
+                parameters_tanks_val = self.__parameters.apply_batch(np.array(parameters_tanks[i]))
+                epanet_api.setMSXParametersTanksValue(tank_idx, parameters_tanks_val)

{epyt_flow-0.7.0.dist-info → epyt_flow-0.7.1.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: epyt-flow
-Version: 0.7.0
+Version: 0.7.1
 Summary: EPyT-Flow -- EPANET Python Toolkit - Flow
 Author-email: André Artelt <aartelt@techfak.uni-bielefeld.de>, "Marios S. Kyriakou" <kiriakou.marios@ucy.ac.cy>, "Stelios G. Vrachimis" <vrachimis.stelios@ucy.ac.cy>
 License: MIT License
 Project-URL: Homepage, https://github.com/WaterFutures/EPyT-Flow
-Project-URL: Documentation, https://epyt-flow.readthedocs.io/en/latest/
+Project-URL: Documentation, https://epyt-flow.readthedocs.io/en/stable/
 Project-URL: Repository, https://github.com/WaterFutures/EPyT-Flow.git
 Project-URL: Issues, https://github.com/WaterFutures/EPyT-Flow/issues
 Keywords: epanet,water,networks,hydraulics,quality,simulations

{epyt_flow-0.7.0.dist-info → epyt_flow-0.7.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-epyt_flow/VERSION,sha256=ln2a-xATRmZxZvLnboGRC8GQSI19QdUMoAcunZLwDjI,6
+epyt_flow/VERSION,sha256=kCMRx7s4-hZY_0A972FY7nN4_p1uLihPocOHNcMb0ws,6
 epyt_flow/__init__.py,sha256=KNDiPWiHdB9a5ZF1ipjA1uoq61TwU2ThjaStpvSLBtY,1742
 epyt_flow/metrics.py,sha256=W-dolnrmWfoanyvg-knoe2QMUtFwV1xODp4D4EwsQ00,14261
 epyt_flow/serialization.py,sha256=ltWcLiTw62s0KG2DSgkQBkn6CCkxy9soDGq_ENohkrI,13998
@@ -87,7 +87,7 @@ epyt_flow/data/benchmarks/batadal_data.py,sha256=oIzcysGivMPAgrfzrk5l8i-j6Ii96DP
 epyt_flow/data/benchmarks/battledim.py,sha256=yLwiQB0x7yq197XSM77tjHm7E7ucTbrybFaNxZx2TtM,20448
 epyt_flow/data/benchmarks/battledim_data.py,sha256=0vHm-2eAiLv6U-n5dqUUWS1o_szFRy9mVJ3eqDRp4PE,3373
 epyt_flow/data/benchmarks/gecco_water_quality.py,sha256=1buZRJiNf4jsqWYg4Ud90GhqaiLVo4yij3RAZJkzsqE,10985
-epyt_flow/data/benchmarks/leakdb.py,sha256=iNgGVTQT7Sl8xXC1iCyTZTJ0OHXW_n5uqsM7NBTIBHU,25046
+epyt_flow/data/benchmarks/leakdb.py,sha256=bhqdJkFMBNdgvQyYWYIpFHFA5ly9Tt51z6nGkyo56-g,25117
 epyt_flow/data/benchmarks/leakdb_data.py,sha256=FNssgMkC1wqWVlaOrrihr4Od9trEZY7KeK5KuBeRMvM,507058
 epyt_flow/data/benchmarks/water_usage.py,sha256=FLqjff3pha33oEU9ZM3UGPXn9eJJumsJH8Gdj7YFX3A,4778
 epyt_flow/gym/__init__.py,sha256=KNTDtPTEtHwZ4ehHfj9qGw81Z9acFqPIgMzYUzH5_uM,115
@@ -112,9 +112,9 @@ epyt_flow/rest_api/scenario/uncertainty_handlers.py,sha256=uuu6AP11ZZUp2P3Dnukjg
 epyt_flow/simulation/__init__.py,sha256=VGGJqJRUoXZjKJ0-m6KPp3JQqD_1TFW0pofLgkwZJ8M,164
 epyt_flow/simulation/parallel_simulation.py,sha256=VmC7xemjxRB_N0fx1AAQ7ux82tnyTi7jk7jfFpeg7gM,6523
 epyt_flow/simulation/scenario_config.py,sha256=NyadeCihpR4bpsWVPj7J-1DU2w1CEN0pAo2yh0t8Xkg,26751
-epyt_flow/simulation/scenario_simulator.py,sha256=VYYUlpukvD9vLs8zmZWTb7-HCrmQlydxw52JyHiWKzE,105251
+epyt_flow/simulation/scenario_simulator.py,sha256=RnPvgEvEZO2rxXPu3jpBGTCjl7LQ6pnSjjPrRhvsMgY,110315
 epyt_flow/simulation/scenario_visualizer.py,sha256=fpj67zl69q-byg7Oxocqhmu1S3P7B3ROCkSYzWyM--0,2187
-epyt_flow/simulation/sensor_config.py,sha256=rX13QQv-OBoybCSJZR0gBsGP0GejBAuJ8BRDULKMIDU,90946
+epyt_flow/simulation/sensor_config.py,sha256=1YduJTNpEhbndIxRXGGx9_nNxH45RIA9bSNJQFXRatA,92255
 epyt_flow/simulation/events/__init__.py,sha256=tIdqzs7_Cus4X2kbZG4Jl2zs-zsk_4rnajFOCvL0zlI,185
 epyt_flow/simulation/events/actuator_events.py,sha256=2_MPYbYO9As6fMkm5Oy9pjSB9kCvFuKpGu8ykYDAydg,7903
 epyt_flow/simulation/events/event.py,sha256=kARPV20XCAl6zxnJwI9U7ICtZUPACO_rgAmtHm1mGCs,2603
@@ -125,15 +125,15 @@ epyt_flow/simulation/events/sensor_reading_event.py,sha256=rQ-CmdpSUyZzDFYwNUGH2
 epyt_flow/simulation/events/system_event.py,sha256=0KI2iaAaOyC9Y-FIfFVazeKT_4ORQRp26gWyMBUu_3c,2396
 epyt_flow/simulation/scada/__init__.py,sha256=ZFAxJVqwEVsgiyFilFetnb13gPhZg1JEOPWYvKIJT4c,90
 epyt_flow/simulation/scada/advanced_control.py,sha256=5h7dmSMcNlTE7TMZa8gQVnOCGMf7uZy60r9aOfKDxMc,4487
-epyt_flow/simulation/scada/scada_data.py,sha256=SlJEcAB06JNCZBl0IO8nv-axamcvznzUAg5SwCdjc2U,110591
-epyt_flow/simulation/scada/scada_data_export.py,sha256=0BwDgV-5qZx17wIyWQ8Nl2TPgho3mBI49027RDq8sDA,11217
+epyt_flow/simulation/scada/scada_data.py,sha256=hwXoZafhd8vrB3Rug_bldNmMfiAeZhGK-ZNKDrHhJxg,139708
+epyt_flow/simulation/scada/scada_data_export.py,sha256=ohAn6vB9UEHesLBFg1lUZ6OgsYkJjYI4q3iTb-tL0fU,11501
 epyt_flow/uncertainty/__init__.py,sha256=ZRjuJL9rDpWVSdPwObPxFpEmMTcgAl3VmPOsS6cIyGg,89
-epyt_flow/uncertainty/model_uncertainty.py,sha256=-2QT2AffZerKZyZ_w_mmeqYpfBALyPDvV61sCrvcK1o,13966
+epyt_flow/uncertainty/model_uncertainty.py,sha256=SD2sYGqj7K0Ys0Lvak4HsbP18A0SmwsK5Mnys_pZilg,14191
 epyt_flow/uncertainty/sensor_noise.py,sha256=zJVULxnxVPSSqc6UW0iwZ9O-HGf9dn4CwScPqf4yCY0,2324
 epyt_flow/uncertainty/uncertainties.py,sha256=jzaAwv5--HGc-H4-SwB0s-pAnzhhFuc06IXck7rC5l8,17902
 epyt_flow/uncertainty/utils.py,sha256=gq66c9-QMOxOqI6wgWLyFxjVV0fbG0_8Yzd6mQjNYNo,5315
-epyt_flow-0.7.0.dist-info/LICENSE,sha256=-4hYIY2BLmCkdOv2_PehEwlnMKTCes8_oyIUXjKtkug,1076
-epyt_flow-0.7.0.dist-info/METADATA,sha256=UCqXTyaYY6EEBHf85PKDVH2sFglzFvWK-30vBrGP2mI,9420
-epyt_flow-0.7.0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-epyt_flow-0.7.0.dist-info/top_level.txt,sha256=Wh_kd7TRL8ownCw3Y3dxx-9C0iTSk6wNauv_NX9JcrY,10
-epyt_flow-0.7.0.dist-info/RECORD,,
+epyt_flow-0.7.1.dist-info/LICENSE,sha256=-4hYIY2BLmCkdOv2_PehEwlnMKTCes8_oyIUXjKtkug,1076
+epyt_flow-0.7.1.dist-info/METADATA,sha256=t8szo6HkAXOXM1sWpoOUvx1zqkzZoWjm8dhgC_6CTms,9420
+epyt_flow-0.7.1.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+epyt_flow-0.7.1.dist-info/top_level.txt,sha256=Wh_kd7TRL8ownCw3Y3dxx-9C0iTSk6wNauv_NX9JcrY,10
+epyt_flow-0.7.1.dist-info/RECORD,,