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

epyt_flow/VERSION

@@ -1 +1 @@
-0.15.0b1
+0.16.0

epyt_flow/data/benchmarks/batadal.py

@@ -125,7 +125,7 @@ def load_data(download_dir: str = None, return_X_y: bool = False,
         del df_train_1["DATETIME"]
         X_train_1 = df_train_1.to_numpy()
 
-        y_train_2 = df_train_2[" ATT_FLAG"].to_numpy()
+        y_train_2 = df_train_2[" ATT_FLAG"].to_numpy(copy=True)
         idx = np.argwhere(y_train_2 == -999)
         y_train_2[idx] = 0
         y_train_2 = y_train_2.astype(np.int8)

epyt_flow/gym/scenario_control_env.py

@@ -218,18 +218,12 @@ class ScenarioControlEnv(ABC):
                                "when running EPANET-MSX")
 
         pump_idx = self._scenario_sim.epanet_api.get_link_idx(pump_id)
-        pattern_idx = int(self._scenario_sim.epanet_api.getlinkvalue(pump_idx,
-                                                                     EpanetConstants.EN_LINKPATTERN))
-
-        if pattern_idx == 0:
-            warnings.warn(f"No pattern for pump '{pump_id}' found -- a new pattern is created")
-            pattern_id = f"pump_speed_{pump_id}"
-            self._scenario_sim.epanet_api.add_pattern(pattern_id, [speed])
-            pattern_idx = self._scenario_sim.epanet_api.getpatternindex(pattern_id)
-            self._scenario_sim.epanet_api.setlinkvalue(pump_idx, EpanetConstants.EN_LINKPATTERN,
-                                                       pattern_idx)
-
-        self._scenario_sim.epanet_api.setpattern(pattern_idx, [speed], 1)
+        pattern_idx = self._scenario_sim.epanet_api.getlinkvalue(pump_idx,
+                                                                 EpanetConstants.EN_LINKPATTERN)
+        if pattern_idx != 0:
+            warnings.warn(f"Pump setting of pump {pump_id} will be multiplied with existing pump pattern")
+
+        self._scenario_sim.epanet_api.setlinkvalue(pump_idx, EpanetConstants.EN_SETTING, speed)
 
     def set_valve_status(self, valve_id: str, status: int) -> None:
         """

epyt_flow/serialization.py

@@ -111,6 +111,13 @@ class Serializable(ABC):
 
         super().__init__(**kwds)
 
+    def __eq__(self, other) -> bool:
+        return self._parent_path == other.parent_path
+
+    @property
+    def parent_path(self) -> str:
+        return self._parent_path
+
     @abstractmethod
     def get_attributes(self) -> dict:
         """
@@ -480,16 +487,25 @@ def __decode_bsr_array(ext_data: tuple[tuple[int, int],
     return scipy.sparse.bsr_array((data[0], (data[1][0], data[1][1])), shape=(shape[0], shape[1]))
 
 
+def __encode_numpy_array(array: np.ndarray) -> tuple[str, list[int], bytes]:
+    return array.dtype.descr[0][1], array.shape, array.tobytes()
+
+
+def __decode_numpy_array(ext_data: tuple[str, list[int], bytes]) -> np.ndarray:
+    dtype_descr, shape, buffer = ext_data
+    return np.frombuffer(buffer, dtype=np.dtype(dtype_descr)).reshape(shape)
+
+
 ext_handler_pack = {np.ndarray:
-                    lambda arr: umsgpack.Ext(NUMPY_ARRAY_ID, umsgpack.packb(arr.tolist())),
+                    lambda arr: umsgpack.Ext(NUMPY_ARRAY_ID, umsgpack.packb(__encode_numpy_array(arr))),
                     networkx.Graph:
                         lambda graph:
                             umsgpack.Ext(NETWORKX_GRAPH_ID,
-                                         umsgpack.packb(networkx.node_link_data(graph))),
+                                         umsgpack.packb(networkx.edges(graph))),
                     scipy.sparse.bsr_array:
                     lambda arr: umsgpack.Ext(SCIPY_BSRARRAY_ID,
                                              umsgpack.packb(__encode_bsr_array(arr)))}
-ext_handler_unpack = {NUMPY_ARRAY_ID: lambda ext: np.array(umsgpack.unpackb(ext.data)),
+ext_handler_unpack = {NUMPY_ARRAY_ID: lambda ext: __decode_numpy_array(umsgpack.unpackb(ext.data)),
                       NETWORKX_GRAPH_ID:
                       lambda ext: networkx.node_link_graph(umsgpack.unpackb(ext.data)),
                       SCIPY_BSRARRAY_ID: lambda ext: __decode_bsr_array(umsgpack.unpackb(ext.data))}

epyt_flow/simulation/events/actuator_events.py

@@ -60,18 +60,18 @@ class PumpEvent(ActuatorEvent):
         ID of the pump that is affected by this event.
     """
     def __init__(self, pump_id: str, **kwds):
-        self.__pump_id = pump_id
+        self._pump_id = pump_id
 
         super().__init__(**kwds)
 
     def init(self, epanet_api: EPyT) -> None:
-        if self.__pump_id not in epanet_api.get_all_pumps_id():
-            raise ValueError(f"Invalid pump ID '{self.__pump_id}'")
+        if self._pump_id not in epanet_api.get_all_pumps_id():
+            raise ValueError(f"Invalid pump ID '{self._pump_id}'")
 
         super().init(epanet_api)
 
     def get_attributes(self) -> dict:
-        return super().get_attributes() | {"pump_id": self.__pump_id}
+        return super().get_attributes() | {"pump_id": self._pump_id}
 
     @property
     def pump_id(self) -> str:
@@ -83,7 +83,7 @@ class PumpEvent(ActuatorEvent):
         `str`
             Pump ID.
         """
-        return self.__pump_id
+        return self._pump_id
 
 
 @serializable(PUMP_STATE_EVENT_ID, ".epytflow_pump_state_event")
@@ -111,12 +111,12 @@ class PumpStateEvent(PumpEvent, JsonSerializable):
             raise ValueError(f"Invalid pump state '{pump_state}' -- " +
                              "must be either EN_CLOSED (0) or EN_OPEN (1)")
 
-        self.__pump_state = pump_state
+        self._pump_state = pump_state
 
         super().__init__(**kwds)
 
     def get_attributes(self) -> dict:
-        return super().get_attributes() | {"pump_state": self.__pump_state}
+        return super().get_attributes() | {"pump_state": self._pump_state}
 
     @property
     def pump_state(self) -> int:
@@ -134,7 +134,7 @@ class PumpStateEvent(PumpEvent, JsonSerializable):
                 - EN_CLOSED  = 0
                 - EN_OPEN    = 1
         """
-        return self.__pump_state
+        return self._pump_state
 
     def apply(self, cur_time: int) -> None:
         pump_link_idx = self._epanet_api.getlinkindex(self.pump_id)
@@ -145,7 +145,7 @@ class PumpStateEvent(PumpEvent, JsonSerializable):
                           "because a pump pattern exists")
         else:
             self._epanet_api.setlinkvalue(pump_link_idx, EpanetConstants.EN_STATUS,
-                                          self.__pump_state)
+                                          self._pump_state)
 
 
 @serializable(PUMP_SPEED_EVENT_ID, ".epytflow_pump_speed_event")
@@ -165,12 +165,12 @@ class PumpSpeedEvent(PumpEvent, JsonSerializable):
         if pump_speed <= 0:
             raise ValueError("Pump speed must be positive")
 
-        self.__pump_speed = pump_speed
+        self._pump_speed = pump_speed
 
         super().__init__(**kwds)
 
     def get_attributes(self) -> dict:
-        return super().get_attributes() | {"pump_speed": self.__pump_speed}
+        return super().get_attributes() | {"pump_speed": self._pump_speed}
 
     @property
     def pump_speed(self) -> float:
@@ -182,7 +182,7 @@ class PumpSpeedEvent(PumpEvent, JsonSerializable):
         `float`
             New pump speed.
         """
-        return self.__pump_speed
+        return self._pump_speed
 
     def apply(self, cur_time: int) -> None:
         pump_idx = self._epanet_api.get_link_idx(self.pump_id)
@@ -191,11 +191,11 @@ class PumpSpeedEvent(PumpEvent, JsonSerializable):
         if pattern_idx == 0:
             warnings.warn(f"No pattern for pump '{self.pump_id}' found -- a new pattern is created")
             pattern_id = f"pump_speed_{self.pump_id}"
-            self._epanet_api.add_pattern(pattern_id, [self.__pump_speed])
+            self._epanet_api.add_pattern(pattern_id, [self._pump_speed])
             pattern_idx = self._epanet_api.getpatternindex(pattern_id)
             self._epanet_api.setlinkvalue(pump_idx, EpanetConstants.EN_LINKPATTERN, pattern_idx)
 
-        self._epanet_api.setpattern(pattern_idx, [self.__pump_speed], 1)
+        self._epanet_api.setpattern(pattern_idx, [self._pump_speed], 1)
 
 
 @serializable(VALVE_STATE_EVENT_ID, ".epytflow_valve_state_event")
@@ -224,20 +224,20 @@ class ValveStateEvent(ActuatorEvent, JsonSerializable):
             raise ValueError(f"Invalid valve state '{valve_state}' -- " +
                              "must be either EN_CLOSED (0) or EN_OPEN (1)")
 
-        self.__valve_id = valve_id
-        self.__valve_state = valve_state
+        self._valve_id = valve_id
+        self._valve_state = valve_state
 
         super().__init__(**kwds)
 
     def init(self, epanet_api: EPyT) -> None:
-        if self.__valve_id not in epanet_api.get_all_valves_id():
-            raise ValueError(f"Invalid valve ID '{self.__valve_id}'")
+        if self._valve_id not in epanet_api.get_all_valves_id():
+            raise ValueError(f"Invalid valve ID '{self._valve_id}'")
 
         super().init(epanet_api)
 
     def get_attributes(self) -> dict:
-        return super().get_attributes() | {"valve_id": self.__valve_id,
-                                           "valve_state": self.__valve_state}
+        return super().get_attributes() | {"valve_id": self._valve_id,
+                                           "valve_state": self._valve_state}
 
     @property
     def valve_id(self) -> str:
@@ -249,7 +249,7 @@ class ValveStateEvent(ActuatorEvent, JsonSerializable):
         `str`
             Valve ID.
         """
-        return self.__valve_id
+        return self._valve_id
 
     @property
     def valve_state(self) -> int:
@@ -264,8 +264,8 @@ class ValveStateEvent(ActuatorEvent, JsonSerializable):
             One of the following constants defined in
             :class:`~epyt_flow.simulation.events.actuator_events.ActuatorConstants`:
         """
-        return self.__valve_state
+        return self._valve_state
 
     def apply(self, cur_time: int) -> None:
-        valve_link_idx = self._epanet_api.get_link_idx(self.__valve_id)
-        self._epanet_api.setlinkvalue(valve_link_idx, EpanetConstants.EN_STATUS, self.__valve_state)
+        valve_link_idx = self._epanet_api.get_link_idx(self._valve_id)
+        self._epanet_api.setlinkvalue(valve_link_idx, EpanetConstants.EN_STATUS, self._valve_state)

epyt_flow/simulation/events/leakages.py

@@ -85,15 +85,15 @@ class Leakage(SystemEvent, JsonSerializable):
                 raise TypeError("'node_id' must be an instance of 'str' " +
                                 f"but not of '{type(node_id)}'")
 
-        self.__link_id = link_id
-        self.__node_id = node_id
-        self.__diameter = diameter
-        self.__area = area
-        self.__profile = profile
+        self._link_id = link_id
+        self._node_id = node_id
+        self._diameter = diameter
+        self._area = area
+        self._profile = profile
 
-        self.__leaky_node_idx = None
-        self.__leak_emitter_coef = None
-        self.__time_pattern_idx = 0
+        self._leaky_node_idx = None
+        self._leak_emitter_coef = None
+        self._time_pattern_idx = 0
 
         super().__init__(**kwds)
 
@@ -107,7 +107,7 @@ class Leakage(SystemEvent, JsonSerializable):
         `str`
             ID of the link at which the leak is placed.
         """
-        return self.__link_id
+        return self._link_id
 
     @property
     def node_id(self) -> str:
@@ -119,7 +119,7 @@ class Leakage(SystemEvent, JsonSerializable):
         `str`
             ID of the node at which the leak is placed.
         """
-        return self.__node_id
+        return self._node_id
 
     @property
     def diameter(self) -> float:
@@ -132,7 +132,7 @@ class Leakage(SystemEvent, JsonSerializable):
         `float`
             Diameter (*foot* or *meter*) of the leak.
         """
-        return self.__diameter
+        return self._diameter
 
     @property
     def area(self) -> float:
@@ -145,7 +145,7 @@ class Leakage(SystemEvent, JsonSerializable):
         `float`
             Area of the leak.
         """
-        return self.__area if self.__area is not None else self.compute_leak_area(self.__diameter)
+        return self._area if self._area is not None else self.compute_leak_area(self._diameter)
 
     @property
     def profile(self) -> np.ndarray:
@@ -157,7 +157,7 @@ class Leakage(SystemEvent, JsonSerializable):
         `numpy.ndarray`
             Pattern of the leak.
         """
-        return deepcopy(self.__profile)
+        return deepcopy(self._profile)
 
     @profile.setter
     def profile(self, pattern: np.ndarray):
@@ -168,25 +168,25 @@ class Leakage(SystemEvent, JsonSerializable):
             raise ValueError("'profile' must be a one-dimensional array " +
                              f"but not of shape '{pattern.shape}'")
 
-        self.__profile = pattern
+        self._profile = pattern
 
     def get_attributes(self) -> dict:
-        return super().get_attributes() | {"link_id": self.__link_id, "diameter": self.__diameter,
-                                           "area": self.__area, "profile": self.__profile,
-                                           "node_id": self.__node_id
-                                           if self.__link_id is None else None}
+        return super().get_attributes() | {"link_id": self._link_id, "diameter": self._diameter,
+                                           "area": self._area, "profile": self._profile,
+                                           "node_id": self._node_id
+                                           if self._link_id is None else None}
 
     def __eq__(self, other) -> bool:
         if not isinstance(other, Leakage):
             raise TypeError(f"Can not compare 'Leakage' instance with '{type(other)}' instance")
 
-        return super().__eq__(other) and self.__link_id == other.link_id \
-            and self.__diameter == other.diameter and np.all(self.__profile == other.profile) \
-            and self.__node_id == other.node_id and self.area == other.area
+        return super().__eq__(other) and self._link_id == other.link_id \
+            and self._diameter == other.diameter and np.all(self._profile == other.profile) \
+            and self._node_id == other.node_id and self.area == other.area
 
     def __str__(self) -> str:
-        return f"{super().__str__()} link_id: {self.__link_id} diameter: {self.__diameter} " +\
-            f"area: {self.__area} profile: {self.__profile} node_id: {self.__node_id}"
+        return f"{super().__str__()} link_id: {self._link_id} diameter: {self._diameter} " +\
+            f"area: {self._area} profile: {self._profile} node_id: {self._node_id}"
 
     def compute_leak_area(self, diameter: float) -> float:
         """
@@ -242,18 +242,18 @@ class Leakage(SystemEvent, JsonSerializable):
         return discharge_coef * area * np.sqrt(2. * g)
 
     def _get_new_link_id(self) -> str:
-        return f"leak_pipe_{self.__link_id}"
+        return f"leak_pipe_{self._link_id}"
 
     def _get_new_node_id(self) -> str:
-        return f"leak_node_{self.__link_id}"
+        return f"leak_node_{self._link_id}"
 
     def init(self, epanet_api: EPyT) -> None:
         super().init(epanet_api)
 
         # Split pipe if leak is placed at a link/pipe
-        if self.__link_id is not None:
-            if self.__link_id not in self._epanet_api.get_all_links_id():
-                raise ValueError(f"Unknown link/pipe '{self.__link_id}'")
+        if self._link_id is not None:
+            if self._link_id not in self._epanet_api.get_all_links_id():
+                raise ValueError(f"Unknown link/pipe '{self._link_id}'")
 
             new_link_id = self._get_new_link_id()
             new_node_id = self._get_new_node_id()
@@ -263,22 +263,22 @@ class Leakage(SystemEvent, JsonSerializable):
                 raise ValueError(f"There is already a leak at pipe {self.link_id}")
 
             self._epanet_api.split_pipe(self.link_id, new_link_id, new_node_id)
-            self.__leaky_node_idx = self._epanet_api.get_node_idx(new_node_id)
+            self._leaky_node_idx = self._epanet_api.get_node_idx(new_node_id)
         else:
-            if self.__node_id not in self._epanet_api.get_all_nodes_id():
-                raise ValueError(f"Unknown node '{self.__node_id}'")
+            if self._node_id not in self._epanet_api.get_all_nodes_id():
+                raise ValueError(f"Unknown node '{self._node_id}'")
 
-            self.__leaky_node_idx = self._epanet_api.get_node_idx(self.__node_id)
+            self._leaky_node_idx = self._epanet_api.get_node_idx(self._node_id)
 
-        self._epanet_api.setnodevalue(self.__leaky_node_idx, EpanetConstants.EN_EMITTER, 0.)
+        self._epanet_api.setnodevalue(self._leaky_node_idx, EpanetConstants.EN_EMITTER, 0.)
 
         # Compute leak emitter coefficient
-        self.__leak_emitter_coef = self.compute_leak_emitter_coefficient(
+        self._leak_emitter_coef = self.compute_leak_emitter_coefficient(
             self.compute_leak_area(self.area))
 
     def cleanup(self) -> None:
-        if self.__link_id is not None:
-            pipe_idx = self._epanet_api.get_link_idx(self.__link_id)
+        if self._link_id is not None:
+            pipe_idx = self._epanet_api.get_link_idx(self._link_id)
             link_diameter = self._epanet_api.get_link_diameter(pipe_idx)
             link_length = self._epanet_api.get_link_length(pipe_idx)
             link_roughness_coeff = self._epanet_api.get_link_roughness(pipe_idx)
@@ -293,15 +293,15 @@ class Leakage(SystemEvent, JsonSerializable):
 
             self._epanet_api.deletelink(self._epanet_api.get_link_idx(self._get_new_link_id()),
                                         EpanetConstants.EN_UNCONDITIONAL)
-            self._epanet_api.deletelink(self._epanet_api.get_link_idx(self.__link_id),
+            self._epanet_api.deletelink(self._epanet_api.get_link_idx(self._link_id),
                                         EpanetConstants.EN_UNCONDITIONAL)
             self._epanet_api.deletenode(self._epanet_api.get_node_idx(self._get_new_node_id()),
                                         EpanetConstants.EN_UNCONDITIONAL)
 
-            self._epanet_api.addlink(self.__link_id, EpanetConstants.EN_PIPE,
+            self._epanet_api.addlink(self._link_id, EpanetConstants.EN_PIPE,
                                      self._epanet_api.get_node_id(node_a_idx),
                                      self._epanet_api.get_node_id(node_b_idx))
-            link_idx = self._epanet_api.get_link_idx(self.__link_id)
+            link_idx = self._epanet_api.get_link_idx(self._link_id)
             self._epanet_api.setlinknodes(link_idx, node_a_idx, node_b_idx)
             self._epanet_api.setlinktype(link_idx, EpanetConstants.EN_PIPE,
                                          EpanetConstants.EN_UNCONDITIONAL)
@@ -317,16 +317,16 @@ class Leakage(SystemEvent, JsonSerializable):
                                           link_wall_reaction_coeff)
 
     def reset(self) -> None:
-        self.__time_pattern_idx = 0
+        self._time_pattern_idx = 0
 
     def exit(self, cur_time) -> None:
-        self._epanet_api.setnodevalue(self.__leaky_node_idx, EpanetConstants.EN_EMITTER, 0.)
+        self._epanet_api.setnodevalue(self._leaky_node_idx, EpanetConstants.EN_EMITTER, 0.)
 
     def apply(self, cur_time: int) -> None:
-        self._epanet_api.setnodevalue(self.__leaky_node_idx, EpanetConstants.EN_EMITTER,
-                                      self.__leak_emitter_coef *
-                                      self.__profile[self.__time_pattern_idx])
-        self.__time_pattern_idx += 1
+        self._epanet_api.setnodevalue(self._leaky_node_idx, EpanetConstants.EN_EMITTER,
+                                      self._leak_emitter_coef *
+                                      self._profile[self._time_pattern_idx])
+        self._time_pattern_idx += 1
 
 
 @serializable(ABRUPT_LEAKAGE_ID, ".epytflow_leakage_abrupt")

epyt_flow/simulation/events/quality_events.py

@@ -61,10 +61,10 @@ class SpeciesInjectionEvent(SystemEvent, JsonSerializable):
         if not 0 <= source_type <= 3:
             raise ValueError("'source_tye' must be in [0, 3]")
 
-        self.__species_id = species_id
-        self.__node_id = node_id
+        self._species_id = species_id
+        self._node_id = node_id
         self._profile = profile
-        self.__source_type = source_type
+        self._source_type = source_type
 
         super().__init__(**kwds)
 
@@ -78,7 +78,7 @@ class SpeciesInjectionEvent(SystemEvent, JsonSerializable):
         `str`
             Bulk species ID.
         """
-        return self.__species_id
+        return self._species_id
 
     @property
     def node_id(self) -> str:
@@ -90,7 +90,7 @@ class SpeciesInjectionEvent(SystemEvent, JsonSerializable):
         `str`
             Node ID.
         """
-        return self.__node_id
+        return self._node_id
 
     @property
     def profile(self) -> np.ndarray:
@@ -120,33 +120,33 @@ class SpeciesInjectionEvent(SystemEvent, JsonSerializable):
         `int`
             Type of the injection source.
         """
-        return self.__source_type
+        return self._source_type
 
     def get_attributes(self) -> dict:
-        return super().get_attributes() | {"species_id": self.__species_id,
-                                           "node_id": self.__node_id, "profile": self._profile,
-                                           "source_type": self.__source_type}
+        return super().get_attributes() | {"species_id": self._species_id,
+                                           "node_id": self._node_id, "profile": self._profile,
+                                           "source_type": self._source_type}
 
     def __eq__(self, other) -> bool:
-        return super().__eq__(other) and self.__species_id == other.species_id and \
-            self.__node_id == other.node_id and np.all(self._profile == other.profile) and \
-            self.__source_type == other.source_type
+        return super().__eq__(other) and self._species_id == other.species_id and \
+            self._node_id == other.node_id and np.all(self._profile == other.profile) and \
+            self._source_type == other.source_type
 
     def __str__(self) -> str:
-        return f"{super().__str__()} species_id: {self.__species_id} " +\
-            f"node_id: {self.__node_id} profile: {self._profile} source_type: {self.__source_type}"
+        return f"{super().__str__()} species_id: {self._species_id} " +\
+            f"node_id: {self._node_id} profile: {self._profile} source_type: {self._source_type}"
 
     def _get_pattern_id(self) -> str:
-        return f"{self.__species_id}_{self.__node_id}"
+        return f"{self._species_id}_{self._node_id}"
 
     def init(self, epanet_api: EPyT) -> None:
         super().init(epanet_api)
 
         # Check parameters
-        if self.__species_id not in self._epanet_api.get_all_msx_species_id():
-            raise ValueError(f"Unknown species '{self.__species_id}'")
-        if self.__node_id not in self._epanet_api.get_all_nodes_id():
-            raise ValueError(f"Unknown node '{self.__node_id}'")
+        if self._species_id not in self._epanet_api.get_all_msx_species_id():
+            raise ValueError(f"Unknown species '{self._species_id}'")
+        if self._node_id not in self._epanet_api.get_all_nodes_id():
+            raise ValueError(f"Unknown node '{self._node_id}'")
 
         # Create final injection strength pattern
         total_sim_duration = self._epanet_api.get_simulation_duration()
@@ -173,10 +173,10 @@ class SpeciesInjectionEvent(SystemEvent, JsonSerializable):
         if pattern_id in [self._epanet_api.MSXgetID(EpanetConstants.MSX_PATTERN, pattern_idx + 1)
                           for pattern_idx in
                           range(self._epanet_api.MSXgetcount(EpanetConstants.MSX_PATTERN))]:
-            node_idx = self._epanet_api.get_node_idx(self.__node_id)
-            species_idx = self._epanet_api.get_msx_species_idx(self.__species_id)
+            node_idx = self._epanet_api.get_node_idx(self._node_id)
+            species_idx = self._epanet_api.get_msx_species_idx(self._species_id)
             cur_source_type = self._epanet_api.MSXgetsource(node_idx, species_idx)
-            if cur_source_type[0] != self.__source_type:
+            if cur_source_type[0] != self._source_type:
                 raise ValueError("Source type does not match existing source type")
 
             # Add new injection amount to existing injection --
@@ -187,7 +187,7 @@ class SpeciesInjectionEvent(SystemEvent, JsonSerializable):
             self._epanet_api.MSXsetpattern(pattern_idx, cur_pattern.tolist(), len(cur_pattern))
         else:
             self._epanet_api.add_msx_pattern(pattern_id, pattern.tolist())
-        self._epanet_api.set_msx_source(self.__node_id, self.__species_id, self.__source_type, 1,
+        self._epanet_api.set_msx_source(self._node_id, self._species_id, self._source_type, 1,
                                         pattern_id)
 
     def cleanup(self) -> None: