epyt-flow 0.7.3__py3-none-any.whl → 0.8.1__py3-none-any.whl

epyt_flow/simulation/scenario_simulator.py

@@ -61,6 +61,18 @@ class ScenarioSimulator():
     ----------
     epanet_api : `epyt.epanet`
         API to EPANET and EPANET-MSX.
+    _model_uncertainty : :class:`~epyt_flow.uncertainty.model_uncertainty.ModelUncertainty`, protected
+        Model uncertainty.
+    _sensor_noise : :class:`~epyt_flow.uncertainty.sensor_noise.SensorNoise`, protected
+        Sensor noise.
+    _sensor_config : :class:`~epyt_flow.simulation.sensor_config.SensorConfig`, protected
+        Sensor configuration.
+    _controls : list[:class:`~epyt_flow.simulation.scada.advanced_control.AdvancedControlModule`], protected
+        List of custom control modules.
+    _system_events : list[:class:`~epyt_flow.simulation.events.system_event.SystemEvent`], protected
+        Lsit of system events such as leakages.
+    _sensor_reading_events : list[:class:`~epyt_flow.simulation.events.sensor_reading_event.SensorReadingEvent`], protected
+        List of sensor reading events such as sensor override attacks.
     """
 
     def __init__(self, f_inp_in: str = None, f_msx_in: str = None,
@@ -69,6 +81,8 @@ class ScenarioSimulator():
             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:
             raise ValueError("Either 'f_inp_in' or 'scenario_config' must be set.")
+        if scenario_config is not None and f_inp_in is not None:
+            raise ValueError("'f_inp_in' or 'scenario_config' can not be used at the same time")
         if f_inp_in is not None:
             if not isinstance(f_inp_in, str):
                 raise TypeError("'f_inp_in' must be an instance of 'str' but not of " +
@@ -88,12 +102,12 @@ class ScenarioSimulator():
 
         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
-        self.__model_uncertainty = ModelUncertainty()
-        self.__sensor_noise = None
-        self.__sensor_config = None
-        self.__controls = []
-        self.__system_events = []
-        self.__sensor_reading_events = []
+        self._model_uncertainty = ModelUncertainty()
+        self._sensor_noise = None
+        self._sensor_config = None
+        self._controls = []
+        self._system_events = []
+        self._sensor_reading_events = []
         self.__running_simulation = False
 
         custom_epanet_lib = None
@@ -140,14 +154,11 @@ class ScenarioSimulator():
             if self.__f_msx_in is not None:
                 if not __file_exists(self.__f_msx_in):
                     my_f_msx_in = self.__f_msx_in
-                    self.__my_f_msx_in = None
                 else:
                     my_f_msx_in = os.path.join(tmp_folder_path, pathlib.Path(self.__f_msx_in).name)
                     shutil.copyfile(self.__f_msx_in, my_f_msx_in)
-                    self.__my_f_msx_in = my_f_msx_in
             else:
                 my_f_msx_in = None
-                self.__my_f_msx_in = None
 
             self.epanet_api = epanet(my_f_inp_in, ph=self.__f_msx_in is None,
                                      customlib=custom_epanet_lib, loadfile=True,
@@ -157,14 +168,14 @@ class ScenarioSimulator():
             if self.__f_msx_in is not None:
                 self.epanet_api.loadMSXFile(my_f_msx_in, customMSXlib=custom_epanetmsx_lib)
 
-        self.__sensor_config = self.__get_empty_sensor_config()
+        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)
 
-            self.__model_uncertainty = scenario_config.model_uncertainty
-            self.__sensor_noise = scenario_config.sensor_noise
-            self.__sensor_config = scenario_config.sensor_config
+            self._model_uncertainty = scenario_config.model_uncertainty
+            self._sensor_noise = scenario_config.sensor_noise
+            self._sensor_config = scenario_config.sensor_config
 
             for control in scenario_config.controls:
                 self.add_control(control)
@@ -173,10 +184,10 @@ 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:
+    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 = qualityunit_to_id(self.epanet_api.getQualityInfo().QualityChemUnits)
         bulk_species = []
@@ -228,7 +239,7 @@ class ScenarioSimulator():
         `str`
             Path to the .inp file.
         """
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         return self.__f_inp_in
 
@@ -242,7 +253,7 @@ class ScenarioSimulator():
         `str`
             Path to the .msx file.
         """
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         return self.__f_msx_in
 
@@ -256,13 +267,13 @@ class ScenarioSimulator():
         :class:`~epyt_flow.uncertainty.model_uncertainty.ModelUncertainty`
             Model uncertainty.
         """
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
-        return deepcopy(self.__model_uncertainty)
+        return deepcopy(self._model_uncertainty)
 
     @model_uncertainty.setter
     def model_uncertainty(self, model_uncertainty: ModelUncertainty) -> None:
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         self.set_model_uncertainty(model_uncertainty)
 
@@ -276,13 +287,13 @@ class ScenarioSimulator():
         :class:`~epyt_flow.uncertainty.sensor_noise.SensorNoise`
             Sensor noise.
         """
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
-        return deepcopy(self.__sensor_noise)
+        return deepcopy(self._sensor_noise)
 
     @sensor_noise.setter
     def sensor_noise(self, sensor_noise: SensorNoise) -> None:
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         self.set_sensor_noise(sensor_noise)
 
@@ -296,9 +307,9 @@ class ScenarioSimulator():
         :class:`~epyt_flow.simulation.sensor_config.SensorConfig`
             Sensor configuration.
         """
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
-        return deepcopy(self.__sensor_config)
+        return deepcopy(self._sensor_config)
 
     @sensor_config.setter
     def sensor_config(self, sensor_config: SensorConfig) -> None:
@@ -309,7 +320,7 @@ class ScenarioSimulator():
 
         sensor_config.validate(self.epanet_api)
 
-        self.__sensor_config = sensor_config
+        self._sensor_config = sensor_config
 
     @property
     def controls(self) -> list[AdvancedControlModule]:
@@ -321,9 +332,9 @@ class ScenarioSimulator():
         list[:class:`~epyt_flow.simulation.scada.advanced_control.AdvancedControlModule`]
             All control modules.
         """
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
-        return deepcopy(self.__controls)
+        return deepcopy(self._controls)
 
     @property
     def leakages(self) -> list[Leakage]:
@@ -335,9 +346,9 @@ class ScenarioSimulator():
         list[:class:`~epyt_flow.simulation.events.leakages.Leakage`]
             All leakages.
         """
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
-        return deepcopy(list(filter(lambda e: isinstance(e, Leakage), self.__system_events)))
+        return deepcopy(list(filter(lambda e: isinstance(e, Leakage), self._system_events)))
 
     @property
     def actuator_events(self) -> list[ActuatorEvent]:
@@ -349,9 +360,9 @@ class ScenarioSimulator():
         list[:class:`~epyt_flow.simulation.events.actuator_event.ActuatorEvent`]
             All actuator events.
         """
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
-        return deepcopy(list(filter(lambda e: isinstance(e, ActuatorEvent), self.__system_events)))
+        return deepcopy(list(filter(lambda e: isinstance(e, ActuatorEvent), self._system_events)))
 
     @property
     def system_events(self) -> list[SystemEvent]:
@@ -363,9 +374,9 @@ class ScenarioSimulator():
         list[:class:`~epyt_flow.simulation.events.system_event.SystemEvent`]
             All system events.
         """
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
-        return deepcopy(self.__system_events)
+        return deepcopy(self._system_events)
 
     @property
     def sensor_faults(self) -> list[SensorFault]:
@@ -377,10 +388,10 @@ class ScenarioSimulator():
         list[:class:`~epyt_flow.simulation.events.sensor_faults.SensorFault`]
             All sensor faults.
         """
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         return deepcopy(list(filter(lambda e: isinstance(e, SensorFault),
-                                    self.__sensor_reading_events)))
+                                    self._sensor_reading_events)))
 
     @property
     def sensor_reading_attacks(self) -> list[SensorReadingAttack]:
@@ -392,10 +403,10 @@ class ScenarioSimulator():
         list[:class:`~epyt_flow.simulation.events.sensor_reading_attacks.SensorReadingAttack`]
             All sensor reading attacks.
         """
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         return deepcopy(list(filter(lambda e: isinstance(e, SensorReadingAttack)),
-                             self.__sensor_reading_events))
+                             self._sensor_reading_events))
 
     @property
     def sensor_reading_events(self) -> list[SensorReadingEvent]:
@@ -407,11 +418,11 @@ class ScenarioSimulator():
         list[:class:`~epyt_flow.simulation.events.sensor_reading_event.SensorReadingEvent`]
             All sensor reading events.
         """
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
-        return deepcopy(self.__sensor_reading_events)
+        return deepcopy(self._sensor_reading_events)
 
-    def __adapt_to_network_changes(self):
+    def _adapt_to_network_changes(self):
         nodes = self.epanet_api.getNodeNameID()
         links = self.epanet_api.getLinkNameID()
 
@@ -424,26 +435,26 @@ class ScenarioSimulator():
         surfacespecies_id_to_idx = None
 
         # 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.pump_efficiency_sensors = self.__sensor_config.pump_efficiency_sensors
-        new_sensor_config.pump_energyconsumption_sensors = self.__sensor_config.\
+        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.pump_efficiency_sensors = self._sensor_config.pump_efficiency_sensors
+        new_sensor_config.pump_energyconsumption_sensors = self._sensor_config.\
             pump_energyconsumption_sensors
-        new_sensor_config.valve_state_sensors = self.__sensor_config.valve_state_sensors
-        new_sensor_config.tank_volume_sensors = self.__sensor_config.tank_volume_sensors
-        new_sensor_config.bulk_species_node_sensors = self.__sensor_config.bulk_species_node_sensors
-        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
+        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
+        self._sensor_config = new_sensor_config
 
     def close(self):
         """
@@ -542,27 +553,27 @@ class ScenarioSimulator():
                 links = []
 
                 # Parse sensor config
-                pressure_sensors = self.__sensor_config.pressure_sensors
+                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
+                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
+                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
+                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
+                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"
@@ -573,12 +584,12 @@ class ScenarioSimulator():
                 links = list(set(links))
 
                 if len(nodes) != 0:
-                    if set(nodes) == set(self.__sensor_config.nodes):
+                    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):
+                    if set(links) == set(self._sensor_config.links):
                         links = ["ALL"]
                     report_desc += f"LINKS {' '.join(links)}\n"
 
@@ -595,17 +606,17 @@ class ScenarioSimulator():
                 links = []
 
                 # Parse sensor config
-                bulk_species_node_sensors = self.__sensor_config.bulk_species_node_sensors
+                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
+                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
+                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]
@@ -616,12 +627,12 @@ class ScenarioSimulator():
 
                 # Create REPORT section
                 if len(nodes) != 0:
-                    if set(nodes) == set(self.__sensor_config.nodes):
+                    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):
+                    if set(links) == set(self._sensor_config.links):
                         links = ["ALL"]
                     report_desc += f"LINKS {' '.join(links)}\n"
 
@@ -767,7 +778,7 @@ class ScenarioSimulator():
         :class:`~epyt_flow.simulation.scenario_config.ScenarioConfig`
             Complete scenario specification.
         """
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         general_params = {"hydraulic_time_step": self.get_hydraulic_time_step(),
                           "quality_time_step": self.get_quality_time_step(),
@@ -795,7 +806,7 @@ class ScenarioSimulator():
         `float`
             Estimated memory consumption in MB.
         """
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         n_time_steps = int(self.epanet_api.getTimeSimulationDuration() /
                            self.epanet_api.getTimeReportingStep())
@@ -819,7 +830,7 @@ class ScenarioSimulator():
         :class:`~epyt_flow.topology.NetworkTopology`
             Topology of this WDN as a graph.
         """
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         # Collect information about the topology of the water distribution network
         nodes_id = self.epanet_api.getNodeNameID()
@@ -883,6 +894,22 @@ class ScenarioSimulator():
         return NetworkTopology(f_inp=self.f_inp_in, nodes=nodes, links=links, pumps=pumps,
                                valves=valves, units=self.get_units_category())
 
+    def plot_topology(self, export_to_file: str = None) -> None:
+        """
+        Plots the topology of the water distribution network.
+
+        Parameters
+        ----------
+        export_to_file : `str`, optional
+            Path to the file where the visualization will be stored.
+            If None, visualization will be just shown but NOT be stored
+            anywhere.
+
+            The default is None.
+        """
+        from .scenario_visualizer import ScenarioVisualizer
+        ScenarioVisualizer(self).show_plot(export_to_file)
+
     def randomize_demands(self) -> None:
         """
         Randomizes all demand patterns.
@@ -890,7 +917,7 @@ class ScenarioSimulator():
         if self.__running_simulation is True:
             raise RuntimeError("Can not change general parameters when simulation is running.")
 
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         # Get all demand patterns
         demand_patterns_idx = self.epanet_api.getNodeDemandPatternIndex()
@@ -927,9 +954,9 @@ class ScenarioSimulator():
         demand_pattern : `numpy.ndarray`
             Demand pattern over time. Final demand over time = base_demand * demand_pattern
         """
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
-        if node_id not in self.__sensor_config.nodes:
+        if node_id not in self._sensor_config.nodes:
             raise ValueError(f"Unknown node '{node_id}'")
         if not isinstance(base_demand, float):
             raise TypeError("'base_demand' must be an instance of 'float' " +
@@ -958,14 +985,14 @@ class ScenarioSimulator():
         control : :class:`~epyt_flow.simulation.scada.advanced_control.AdvancedControlModule`
             Control module.
         """
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         if not isinstance(control, AdvancedControlModule):
             raise TypeError("'control' must be an instance of " +
                             "'epyt_flow.simulation.scada.AdvancedControlModule' not of " +
                             f"'{type(control)}'")
 
-        self.__controls.append(control)
+        self._controls.append(control)
 
     def add_leakage(self, leakage_event: Leakage) -> None:
         """
@@ -976,7 +1003,7 @@ class ScenarioSimulator():
         event : :class:`~epyt_flow.simulation.events.leakages.Leakage`
             Leakage.
         """
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         if not isinstance(leakage_event, Leakage):
             raise TypeError("'leakage_event' must be an instance of " +
@@ -994,7 +1021,7 @@ class ScenarioSimulator():
         event : :class:`~epyt_flow.simulation.events.actuator_events.ActuatorEvent`
             Actuator event.
         """
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         if not isinstance(event, ActuatorEvent):
             raise TypeError("'event' must be an instance of " +
@@ -1015,7 +1042,7 @@ class ScenarioSimulator():
         if self.__running_simulation is True:
             raise RuntimeError("Can not add events when simulation is running.")
 
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         if not isinstance(event, SystemEvent):
             raise TypeError("'event' must be an instance of " +
@@ -1023,7 +1050,7 @@ class ScenarioSimulator():
 
         event.init(self.epanet_api)
 
-        self.__system_events.append(event)
+        self._system_events.append(event)
 
     def add_sensor_fault(self, sensor_fault_event: SensorFault) -> None:
         """
@@ -1037,16 +1064,16 @@ class ScenarioSimulator():
         if self.__running_simulation is True:
             raise RuntimeError("Can not add events when simulation is running.")
 
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
-        sensor_fault_event.validate(self.__sensor_config)
+        sensor_fault_event.validate(self._sensor_config)
 
         if not isinstance(sensor_fault_event, SensorFault):
             raise TypeError("'sensor_fault_event' must be an instance of " +
                             "'epyt_flow.simulation.events.SensorFault' not of " +
                             f"'{type(sensor_fault_event)}'")
 
-        self.__sensor_reading_events.append(sensor_fault_event)
+        self._sensor_reading_events.append(sensor_fault_event)
 
     def add_sensor_reading_attack(self, sensor_reading_attack: SensorReadingAttack) -> None:
         """
@@ -1060,16 +1087,16 @@ class ScenarioSimulator():
         if self.__running_simulation is True:
             raise RuntimeError("Can not add events when simulation is running.")
 
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
-        sensor_reading_attack.validate(self.__sensor_config)
+        sensor_reading_attack.validate(self._sensor_config)
 
         if not isinstance(sensor_reading_attack, SensorReadingAttack):
             raise TypeError("'sensor_reading_attack' must be an instance of " +
                             "'epyt_flow.simulation.events.SensorReadingAttack' not of " +
                             f"'{type(sensor_reading_attack)}'")
 
-        self.__sensor_reading_events.append(sensor_reading_attack)
+        self._sensor_reading_events.append(sensor_reading_attack)
 
     def add_sensor_reading_event(self, event: SensorReadingEvent) -> None:
         """
@@ -1083,16 +1110,16 @@ class ScenarioSimulator():
         if self.__running_simulation is True:
             raise RuntimeError("Can not add events when simulation is running.")
 
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
-        event.validate(self.__sensor_config)
+        event.validate(self._sensor_config)
 
         if not isinstance(event, SensorReadingEvent):
             raise TypeError("'event' must be an instance of " +
                             "'epyt_flow.simulation.events.SensorReadingEvent' not of " +
                             f"'{type(event)}'")
 
-        self.__sensor_reading_events.append(event)
+        self._sensor_reading_events.append(event)
 
     def set_sensors(self, sensor_type: int, sensor_locations: Union[list[str], dict]) -> None:
         """
@@ -1118,38 +1145,38 @@ class ScenarioSimulator():
             Locations (IDs) of sensors either as a list or as a dict in the case of
             bulk and surface species.
         """
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         if sensor_type == SENSOR_TYPE_NODE_PRESSURE:
-            self.__sensor_config.pressure_sensors = sensor_locations
+            self._sensor_config.pressure_sensors = sensor_locations
         elif sensor_type == SENSOR_TYPE_LINK_FLOW:
-            self.__sensor_config.flow_sensors = sensor_locations
+            self._sensor_config.flow_sensors = sensor_locations
         elif sensor_type == SENSOR_TYPE_NODE_DEMAND:
-            self.__sensor_config.demand_sensors = sensor_locations
+            self._sensor_config.demand_sensors = sensor_locations
         elif sensor_type == SENSOR_TYPE_NODE_QUALITY:
-            self.__sensor_config.quality_node_sensors = sensor_locations
+            self._sensor_config.quality_node_sensors = sensor_locations
         elif sensor_type == SENSOR_TYPE_LINK_QUALITY:
-            self.__sensor_config.quality_link_sensors = sensor_locations
+            self._sensor_config.quality_link_sensors = sensor_locations
         elif sensor_type == SENSOR_TYPE_VALVE_STATE:
-            self.__sensor_config.valve_state_sensors = sensor_locations
+            self._sensor_config.valve_state_sensors = sensor_locations
         elif sensor_type == SENSOR_TYPE_PUMP_STATE:
-            self.__sensor_config.pump_state_sensors = sensor_locations
+            self._sensor_config.pump_state_sensors = sensor_locations
         elif sensor_type == SENSOR_TYPE_PUMP_EFFICIENCY:
-            self.__sensor_config.pump_efficiency_sensors = sensor_locations
+            self._sensor_config.pump_efficiency_sensors = sensor_locations
         elif sensor_type == SENSOR_TYPE_PUMP_ENERGYCONSUMPTION:
-            self.__sensor_config.pump_energyconsumption_sensors = sensor_locations
+            self._sensor_config.pump_energyconsumption_sensors = sensor_locations
         elif sensor_type == SENSOR_TYPE_TANK_VOLUME:
-            self.__sensor_config.tank_volume_sensors = sensor_locations
+            self._sensor_config.tank_volume_sensors = sensor_locations
         elif sensor_type == SENSOR_TYPE_NODE_BULK_SPECIES:
-            self.__sensor_config.bulk_species_node_sensors = sensor_locations
+            self._sensor_config.bulk_species_node_sensors = sensor_locations
         elif sensor_type == SENSOR_TYPE_LINK_BULK_SPECIES:
-            self.__sensor_config.bulk_species_link_sensors = sensor_locations
+            self._sensor_config.bulk_species_link_sensors = sensor_locations
         elif sensor_type == SENSOR_TYPE_SURFACE_SPECIES:
-            self.__sensor_config.surface_species_sensors = sensor_locations
+            self._sensor_config.surface_species_sensors = sensor_locations
         else:
             raise ValueError(f"Unknown sensor type '{sensor_type}'")
 
-        self.__sensor_config.validate(self.epanet_api)
+        self._sensor_config.validate(self.epanet_api)
 
     def set_pressure_sensors(self, sensor_locations: list[str]) -> None:
         """
@@ -1176,7 +1203,7 @@ class ScenarioSimulator():
         if junctions_only is True:
             self.set_pressure_sensors(self.epanet_api.getNodeJunctionNameID())
         else:
-            self.set_pressure_sensors(self.__sensor_config.nodes)
+            self.set_pressure_sensors(self._sensor_config.nodes)
 
     def set_flow_sensors(self, sensor_locations: list[str]) -> None:
         """
@@ -1193,7 +1220,7 @@ class ScenarioSimulator():
         """
         Places a flow sensors at every link/pipe in the network.
         """
-        self.set_flow_sensors(self.__sensor_config.links)
+        self.set_flow_sensors(self._sensor_config.links)
 
     def set_demand_sensors(self, sensor_locations: list[str]) -> None:
         """
@@ -1210,7 +1237,7 @@ class ScenarioSimulator():
         """
         Places a demand sensor at every node in the network.
         """
-        self.set_demand_sensors(self.__sensor_config.nodes)
+        self.set_demand_sensors(self._sensor_config.nodes)
 
     def set_node_quality_sensors(self, sensor_locations: list[str]) -> None:
         """
@@ -1228,7 +1255,7 @@ class ScenarioSimulator():
         """
         Places a water quality sensor at every node in the network.
         """
-        self.set_node_quality_sensors(self.__sensor_config.nodes)
+        self.set_node_quality_sensors(self._sensor_config.nodes)
 
     def set_link_quality_sensors(self, sensor_locations: list[str]) -> None:
         """
@@ -1246,7 +1273,7 @@ class ScenarioSimulator():
         """
         Places a water quality sensor at every link/pipe in the network.
         """
-        self.set_link_quality_sensors(self.__sensor_config.links)
+        self.set_link_quality_sensors(self._sensor_config.links)
 
     def set_valve_sensors(self, sensor_locations: list[str]) -> None:
         """
@@ -1263,10 +1290,10 @@ class ScenarioSimulator():
         """
         Places a valve state sensor at every valve in the network.
         """
-        if len(self.__sensor_config.valves) == 0:
+        if len(self._sensor_config.valves) == 0:
             warnings.warn("Network does not contain any valves", UserWarning)
 
-        self.set_valve_sensors(self.__sensor_config.valves)
+        self.set_valve_sensors(self._sensor_config.valves)
 
     def set_pump_state_sensors(self, sensor_locations: list[str]) -> None:
         """
@@ -1283,10 +1310,10 @@ class ScenarioSimulator():
         """
         Places a pump state sensor at every pump in the network.
         """
-        if len(self.__sensor_config.pumps) == 0:
+        if len(self._sensor_config.pumps) == 0:
             warnings.warn("Network does not contain any pumps", UserWarning)
 
-        self.set_pump_state_sensors(self.__sensor_config.pumps)
+        self.set_pump_state_sensors(self._sensor_config.pumps)
 
     def set_pump_efficiency_sensors(self, sensor_locations: list[str]) -> None:
         """
@@ -1304,10 +1331,10 @@ class ScenarioSimulator():
         """
         Places a pump efficiency sensor at every pump in the network.
         """
-        if len(self.__sensor_config.pumps) == 0:
+        if len(self._sensor_config.pumps) == 0:
             warnings.warn("Network does not contain any pumps", UserWarning)
 
-        self.set_pump_efficiency_sensors(self.__sensor_config.pumps)
+        self.set_pump_efficiency_sensors(self._sensor_config.pumps)
 
     def set_pump_energyconsumption_sensors(self, sensor_locations: list[str]) -> None:
         """
@@ -1325,10 +1352,10 @@ class ScenarioSimulator():
         """
         Places a pump energy consumption sensor at every pump in the network.
         """
-        if len(self.__sensor_config.pumps) == 0:
+        if len(self._sensor_config.pumps) == 0:
             warnings.warn("Network does not contain any pumps", UserWarning)
 
-        self.set_pump_energyconsumption_sensors(self.__sensor_config.pumps)
+        self.set_pump_energyconsumption_sensors(self._sensor_config.pumps)
 
     def set_pump_sensors(self, sensor_locations: list[str]) -> None:
         """
@@ -1349,10 +1376,10 @@ class ScenarioSimulator():
         Palces pump sensors at every pump in the network -- i.e. retrieving the state, efficiency,
         and energy consumption of all pumps in the network.
         """
-        if len(self.__sensor_config.pumps) == 0:
+        if len(self._sensor_config.pumps) == 0:
             warnings.warn("Network does not contain any pumps", UserWarning)
 
-        self.set_pump_sensors(self.__sensor_config.pumps)
+        self.set_pump_sensors(self._sensor_config.pumps)
 
     def set_tank_sensors(self, sensor_locations: list[str]) -> None:
         """
@@ -1369,10 +1396,10 @@ class ScenarioSimulator():
         """
         Places a water tank volume sensor at every tank in the network.
         """
-        if len(self.__sensor_config.tanks) == 0:
+        if len(self._sensor_config.tanks) == 0:
             warnings.warn("Network does not contain any tanks", UserWarning)
 
-        self.set_tank_sensors(self.__sensor_config.tanks)
+        self.set_tank_sensors(self._sensor_config.tanks)
 
     def set_bulk_species_node_sensors(self, sensor_info: dict) -> None:
         """
@@ -1386,13 +1413,30 @@ class ScenarioSimulator():
         """
         self.set_sensors(SENSOR_TYPE_NODE_BULK_SPECIES, sensor_info)
 
-    def place_bulk_species_node_sensors_everywhere(self) -> None:
+    def place_bulk_species_node_sensors_everywhere(self, bulk_species: list[str] = None) -> None:
         """
         Places bulk species concentration sensors at every node in the network for
         every bulk species.
+
+        Parameters
+        ----------
+        bulk_species : `list[str]`, optional
+            List of bulk species IDs which we want to monitor at every node.
+            If None, every bulk species will be monitored at every node.
+
+            The default is None.
         """
-        self.set_bulk_species_node_sensors({species_id: self.__sensor_config.nodes
-                                            for species_id in self.__sensor_config.bulk_species})
+        if bulk_species is None:
+            self.set_bulk_species_node_sensors({species_id: self._sensor_config.nodes
+                                                for species_id in
+                                                    self._sensor_config.bulk_species})
+        else:
+            if any(species_id not in self._sensor_config.bulk_species
+                   for species_id in bulk_species):
+                raise ValueError("Invalid bulk species ID in 'bulk_species'")
+
+            self.set_bulk_species_node_sensors({species_id: self._sensor_config.nodes
+                                                for species_id in bulk_species})
 
     def set_bulk_species_link_sensors(self, sensor_info: dict) -> None:
         """
@@ -1406,13 +1450,30 @@ class ScenarioSimulator():
         """
         self.set_sensors(SENSOR_TYPE_LINK_BULK_SPECIES, sensor_info)
 
-    def place_bulk_species_link_sensors_everywhere(self) -> None:
+    def place_bulk_species_link_sensors_everywhere(self, bulk_species: list[str] = None) -> None:
         """
         Places bulk species concentration sensors at every link/pipe in the network
         for every bulk species.
+
+        Parameters
+        ----------
+        bulk_species : `list[str]`, optional
+            List of bulk species IDs which we want to monitor at every link/pipe.
+            If None, every bulk species will be monitored at every link/pipe.
+
+            The default is None.
         """
-        self.set_bulk_species_link_sensors({species_id: self.__sensor_config.links
-                                            for species_id in self.__sensor_config.bulk_species})
+        if bulk_species is None:
+            self.set_bulk_species_link_sensors({species_id: self._sensor_config.links
+                                                for species_id in
+                                                self._sensor_config.bulk_species})
+        else:
+            if any(species_id not in self._sensor_config.bulk_species
+                   for species_id in bulk_species):
+                raise ValueError("Invalid bulk species ID in 'bulk_species'")
+
+            self.set_bulk_species_link_sensors({species_id: self._sensor_config.links
+                                                for species_id in bulk_species})
 
     def set_surface_species_sensors(self, sensor_info: dict) -> None:
         """
@@ -1426,33 +1487,50 @@ class ScenarioSimulator():
         """
         self.set_sensors(SENSOR_TYPE_SURFACE_SPECIES, sensor_info)
 
-    def place_surface_species_sensors_everywhere(self) -> None:
+    def place_surface_species_sensors_everywhere(self, surface_species_id: list[str] = None
+                                                 ) -> None:
         """
         Places surface species concentration sensors at every link/pipe in the network
         for every surface species.
+
+        Parameters
+        ----------
+        surface_species_id : `list[str]`, optional
+            List of surface species IDs which we want to monitor at every link/pipe.
+            If None, every surface species will be monitored at every link/pipe.
+
+            The default is None.
         """
-        self.set_bulk_species_node_sensors({species_id: self.__sensor_config.links
-                                            for species_id in
-                                            self.__sensor_config.surface_species})
+        if surface_species_id is None:
+            self.set_bulk_species_node_sensors({species_id: self._sensor_config.links
+                                                for species_id in
+                                                self._sensor_config.surface_species})
+        else:
+            if any(species_id not in self._sensor_config.surface_species
+                   for species_id in surface_species_id):
+                raise ValueError("Invalid surface species ID in 'surface_species_id'")
+
+            self.set_bulk_species_node_sensors({species_id: self._sensor_config.links
+                                                for species_id in surface_species_id})
 
     def place_sensors_everywhere(self) -> None:
         """
         Places sensors everywhere -- i.e. every possible quantity is monitored
         at every position in the network.
         """
-        self.__sensor_config.place_sensors_everywhere()
+        self._sensor_config.place_sensors_everywhere()
 
-    def __prepare_simulation(self) -> None:
-        self.__adapt_to_network_changes()
+    def _prepare_simulation(self) -> None:
+        self._adapt_to_network_changes()
 
-        if self.__model_uncertainty is not None:
-            self.__model_uncertainty.apply(self.epanet_api)
+        if self._model_uncertainty is not None:
+            self._model_uncertainty.apply(self.epanet_api)
 
-        for event in self.__system_events:
+        for event in self._system_events:
             event.reset()
 
-        if self.__controls is not None:
-            for c in self.__controls:
+        if self._controls is not None:
+            for c in self._controls:
                 c.init(self.epanet_api)
 
     def run_advanced_quality_simulation(self, hyd_file_in: str, verbose: bool = False,
@@ -1509,9 +1587,9 @@ class ScenarioSimulator():
                 result[data_type] = None
 
         return ScadaData(**result,
-                         sensor_config=self.__sensor_config,
-                         sensor_reading_events=self.__sensor_reading_events,
-                         sensor_noise=self.__sensor_noise,
+                         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,
@@ -1568,9 +1646,9 @@ class ScenarioSimulator():
 
         self.__running_simulation = True
 
-        bulk_species_idx = self.epanet_api.getMSXSpeciesIndex(self.__sensor_config.bulk_species)
+        bulk_species_idx = self.epanet_api.getMSXSpeciesIndex(self._sensor_config.bulk_species)
         surface_species_idx = self.epanet_api.getMSXSpeciesIndex(
-            self.__sensor_config.surface_species)
+            self._sensor_config.surface_species)
 
         if verbose is True:
             print("Running EPANET-MSX ...")
@@ -1649,13 +1727,13 @@ class ScenarioSimulator():
                         "surface_species_concentration_raw": surface_species_concentrations,
                         "sensor_readings_time": np.array([0])}
             else:
-                data = ScadaData(sensor_config=self.__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,
+                                 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.
@@ -1693,7 +1771,7 @@ class ScenarioSimulator():
                                 "surface_species_concentration_raw": surface_species_concentrations,
                                 "sensor_readings_time": np.array([total_time])}
                     else:
-                        data = ScadaData(sensor_config=self.__sensor_config,
+                        data = ScadaData(sensor_config=self._sensor_config,
                                          bulk_species_node_concentration_raw=
                                             bulk_species_node_concentrations,
                                          bulk_species_link_concentration_raw=
@@ -1701,8 +1779,8 @@ class ScenarioSimulator():
                                          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,
+                                         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.
@@ -1763,9 +1841,9 @@ class ScenarioSimulator():
             result[data_type] = np.concatenate(result[data_type], axis=0)
 
         return ScadaData(**result,
-                         sensor_config=self.__sensor_config,
-                         sensor_reading_events=self.__sensor_reading_events,
-                         sensor_noise=self.__sensor_noise,
+                         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_basic_quality_simulation_as_generator(self, hyd_file_in: str, verbose: bool = False,
@@ -1851,12 +1929,12 @@ class ScenarioSimulator():
                             "link_quality_data_raw": quality_link_data,
                             "sensor_readings_time": np.array([total_time])}
                 else:
-                    data = ScadaData(sensor_config=self.__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,
+                                     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.
@@ -1905,7 +1983,7 @@ class ScenarioSimulator():
         if self.__running_simulation is True:
             raise RuntimeError("A simulation is already running.")
 
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         result = None
 
@@ -1927,9 +2005,9 @@ class ScenarioSimulator():
             result[data_type] = np.concatenate(result[data_type], axis=0)
 
         result = ScadaData(**result,
-                           sensor_config=self.__sensor_config,
-                           sensor_reading_events=self.__sensor_reading_events,
-                           sensor_noise=self.__sensor_noise,
+                           sensor_config=self._sensor_config,
+                           sensor_reading_events=self._sensor_reading_events,
+                           sensor_noise=self._sensor_noise,
                            frozen_sensor_config=frozen_sensor_config)
 
         return result
@@ -1984,9 +2062,9 @@ class ScenarioSimulator():
         if self.__running_simulation is True:
             raise RuntimeError("A simulation is already running.")
 
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
-        self.__prepare_simulation()
+        self._prepare_simulation()
 
         self.__running_simulation = True
 
@@ -2024,7 +2102,7 @@ class ScenarioSimulator():
 
                 # Apply system events in a regular time interval only!
                 if (total_time + tstep) % requested_time_step == 0:
-                    for event in self.__system_events:
+                    for event in self._system_events:
                         event.step(total_time + tstep)
 
                 # Compute current time step
@@ -2048,7 +2126,7 @@ class ScenarioSimulator():
                 link_valve_idx = self.epanet_api.getLinkValveIndex()
                 valves_state_data = self.epanet_api.getLinkStatus(link_valve_idx).reshape(1, -1)
 
-                scada_data = ScadaData(sensor_config=self.__sensor_config,
+                scada_data = ScadaData(sensor_config=self._sensor_config,
                                        pressure_data_raw=pressure_data,
                                        flow_data_raw=flow_data,
                                        demand_data_raw=demand_data,
@@ -2060,8 +2138,8 @@ class ScenarioSimulator():
                                        pumps_energy_usage_data_raw=pumps_energy_usage_data,
                                        pumps_efficiency_data_raw=pumps_efficiency_data,
                                        sensor_readings_time=np.array([total_time]),
-                                       sensor_reading_events=self.__sensor_reading_events,
-                                       sensor_noise=self.__sensor_noise,
+                                       sensor_reading_events=self._sensor_reading_events,
+                                       sensor_noise=self._sensor_noise,
                                        frozen_sensor_config=frozen_sensor_config)
 
                 # Yield results in a regular time interval only!
@@ -2089,7 +2167,7 @@ class ScenarioSimulator():
                     yield data
 
                 # Apply control modules
-                for control in self.__controls:
+                for control in self._controls:
                     control.step(scada_data)
 
                 # Next
@@ -2107,6 +2185,16 @@ class ScenarioSimulator():
             self.__running_simulation = False
             raise ex
 
+    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]:
+        warnings.warn("'run_simulation_as_generator' is deprecated and will be removed in " +
+                      "future releases -- use 'run_hydraulic_simulation_as_generator' instead")
+        return self.run_hydraulic_simulation_as_generator(hyd_export, verbose, support_abort,
+                                                          return_as_dict, frozen_sensor_config)
+
     def run_simulation(self, hyd_export: str = None, verbose: bool = False,
                        frozen_sensor_config: bool = False) -> ScadaData:
         """
@@ -2139,7 +2227,7 @@ class ScenarioSimulator():
         if self.__running_simulation is True:
             raise RuntimeError("A simulation is already running.")
 
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         result = None
 
@@ -2182,14 +2270,14 @@ class ScenarioSimulator():
         if self.__running_simulation is True:
             raise RuntimeError("Can not set uncertainties when simulation is running.")
 
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         if not isinstance(model_uncertainty, ModelUncertainty):
             raise TypeError("'model_uncertainty' must be an instance of " +
                             "'epyt_flow.uncertainty.ModelUncertainty' but not of " +
                             f"'{type(model_uncertainty)}'")
 
-        self.__model_uncertainty = model_uncertainty
+        self._model_uncertainty = model_uncertainty
 
     def set_sensor_noise(self, sensor_noise: SensorNoise) -> None:
         """
@@ -2203,14 +2291,14 @@ class ScenarioSimulator():
         if self.__running_simulation is True:
             raise RuntimeError("Can not set sensor noise when simulation is running.")
 
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         if not isinstance(sensor_noise, SensorNoise):
             raise TypeError("'sensor_noise' must be an instance of " +
                             "'epyt_flow.uncertainties.SensorNoise' but not of " +
                             f"'{type(sensor_noise)}'")
 
-        self.__sensor_noise = sensor_noise
+        self._sensor_noise = sensor_noise
 
     def set_general_parameters(self, demand_model: dict = None, simulation_duration: int = None,
                                hydraulic_time_step: int = None, quality_time_step: int = None,
@@ -2288,7 +2376,7 @@ class ScenarioSimulator():
         if self.__running_simulation is True:
             raise RuntimeError("Can not change general parameters when simulation is running.")
 
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         if flow_units_id is not None:
             if flow_units_id == ToolkitConstants.EN_CFS:
@@ -2329,7 +2417,7 @@ class ScenarioSimulator():
             if not isinstance(hydraulic_time_step, int) or hydraulic_time_step <= 0:
                 raise ValueError("'hydraulic_time_step' must be a positive integer specifying " +
                                  "the time steps of the hydraulic simulation")
-            if len(self.__system_events) != 0:
+            if len(self._system_events) != 0:
                 raise RuntimeError("Hydraulic time step cannot be changed after system events " +
                                    "such as leakages have been added to the scenario")
             self.epanet_api.setTimeHydraulicStep(hydraulic_time_step)
@@ -2391,10 +2479,10 @@ class ScenarioSimulator():
                 events_times.append(cur_time)
                 cur_time += hyd_time_step
 
-        for event in self.__sensor_reading_events:
+        for event in self._sensor_reading_events:
             __process_event(event)
 
-        for event in self.__system_events:
+        for event in self._system_events:
             __process_event(event)
 
         return list(set(events_times))
@@ -2413,7 +2501,7 @@ class ScenarioSimulator():
         if self.__running_simulation is True:
             raise RuntimeError("Can not change general parameters when simulation is running.")
 
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         self.__warn_if_quality_set()
         self.set_general_parameters(quality_model={"type": "AGE"})
@@ -2444,7 +2532,7 @@ class ScenarioSimulator():
         if self.__running_simulation is True:
             raise RuntimeError("Can not change general parameters when simulation is running.")
 
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         self.__warn_if_quality_set()
         self.set_general_parameters(quality_model={"type": "CHEM", "chemical_name": chemical_name,
@@ -2491,12 +2579,12 @@ class ScenarioSimulator():
         if self.__running_simulation is True:
             raise RuntimeError("Can not change general parameters when simulation is running.")
 
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
         if self.epanet_api.getQualityInfo().QualityCode != ToolkitConstants.EN_CHEM:
             raise RuntimeError("Chemical analysis is not enabled -- " +
                                "call 'enable_chemical_analysis()' before calling this function.")
-        if node_id not in self.__sensor_config.nodes:
+        if node_id not in self._sensor_config.nodes:
             raise ValueError(f"Unknown node '{node_id}'")
         if not isinstance(pattern, np.ndarray):
             raise TypeError("'pattern' must be an instance of 'numpy.ndarray' " +
@@ -2530,9 +2618,9 @@ class ScenarioSimulator():
         if self.__running_simulation is True:
             raise RuntimeError("Can not change general parameters when simulation is running.")
 
-        self.__adapt_to_network_changes()
+        self._adapt_to_network_changes()
 
-        if trace_node_id not in self.__sensor_config.nodes:
+        if trace_node_id not in self._sensor_config.nodes:
             raise ValueError(f"Invalid node ID '{trace_node_id}'")
 
         self.__warn_if_quality_set()