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

epyt_flow/VERSION

@@ -1 +1 @@
-0.7.3
+0.8.1

epyt_flow/data/benchmarks/leakdb.py

@@ -491,9 +491,9 @@ def load_scenarios(scenarios_id: list[int], use_net1: bool = True,
 
         return dem_final
 
-    week_pattern_url = "https://github.com/KIOS-Research/LeakDB/raw/master/CCWI-WDSA2018/" +\
+    week_pattern_url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/CCWI-WDSA2018/" +\
         "Dataset_Generator_Py3/weekPat_30min.mat"
-    year_offset_url = "https://github.com/KIOS-Research/LeakDB/raw/master/CCWI-WDSA2018/" +\
+    year_offset_url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/CCWI-WDSA2018/" +\
         "Dataset_Generator_Py3/yearOffset_30min.mat"
 
     download_if_necessary(os.path.join(download_dir, "weekPat_30min.mat"),

epyt_flow/data/networks.py

@@ -153,8 +153,7 @@ def load_net1(download_dir: str = get_temp_folder(), verbose: bool = True,
         :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`.
     """
     f_in = os.path.join(download_dir, "Net1.inp")
-    url = "https://raw.githubusercontent.com/OpenWaterAnalytics/EPyT/main/epyt/networks/" + \
-          "asce-tf-wdst/Net1.inp"
+    url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/Net1.inp"
 
     download_if_necessary(f_in, url, verbose)
     return load_inp(f_in, flow_units_id=flow_units_id)
@@ -201,8 +200,7 @@ def load_net2(download_dir: str = get_temp_folder(), verbose: bool = True,
         :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`.
     """
     f_in = os.path.join(download_dir, "Net2.inp")
-    url = "https://raw.githubusercontent.com/OpenWaterAnalytics/EPyT/main/epyt/networks/" + \
-          "asce-tf-wdst/Net2.inp"
+    url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/Net2.inp"
 
     download_if_necessary(f_in, url, verbose)
     return load_inp(f_in, flow_units_id=flow_units_id)
@@ -249,8 +247,7 @@ def load_net3(download_dir: str = get_temp_folder(), verbose: bool = True,
         :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`.
     """
     f_in = os.path.join(download_dir, "Net3.inp")
-    url = "https://raw.githubusercontent.com/OpenWaterAnalytics/EPyT/main/epyt/networks/" + \
-          "asce-tf-wdst/Net3.inp"
+    url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/Net3.inp"
 
     download_if_necessary(f_in, url, verbose)
     return load_inp(f_in, flow_units_id=flow_units_id)
@@ -297,7 +294,7 @@ def load_net6(download_dir: str = get_temp_folder(), verbose: bool = True,
         :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`.
     """
     f_in = os.path.join(download_dir, "Net6.inp")
-    url = "https://github.com/OpenWaterAnalytics/WNTR/raw/main/examples/networks/Net6.inp"
+    url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/Net6.inp"
 
     download_if_necessary(f_in, url, verbose)
     return load_inp(f_in, flow_units_id=flow_units_id)
@@ -344,8 +341,7 @@ def load_richmond(download_dir: str = get_temp_folder(), verbose: bool = True,
         :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`.
     """
     f_in = os.path.join(download_dir, "Richmond_standard.inp")
-    url = "https://raw.githubusercontent.com/OpenWaterAnalytics/EPyT/main/epyt/networks/" + \
-          "exeter-benchmarks/Richmond_standard.inp"
+    url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/Richmond_standard.inp"
 
     download_if_necessary(f_in, url, verbose)
     return load_inp(f_in, flow_units_id=flow_units_id)
@@ -392,8 +388,7 @@ def load_micropolis(download_dir: str = get_temp_folder(), verbose: bool = True,
         :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`.
     """
     f_in = os.path.join(download_dir, "MICROPOLIS_v1.inp")
-    url = "https://github.com/OpenWaterAnalytics/EPyT/raw/main/epyt/networks/asce-tf-wdst/" + \
-          "MICROPOLIS_v1.inp"
+    url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/MICROPOLIS_v1.inp"
 
     download_if_necessary(f_in, url, verbose)
     return load_inp(f_in, flow_units_id=flow_units_id)
@@ -440,8 +435,7 @@ def load_balerma(download_dir: str = get_temp_folder(), verbose: bool = True,
         :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`.
     """
     f_in = os.path.join(download_dir, "Balerma.inp")
-    url = "https://github.com/OpenWaterAnalytics/EPyT/raw/main/epyt/networks/" + \
-          "asce-tf-wdst/Balerma.inp"
+    url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/Balerma.inp"
 
     download_if_necessary(f_in, url, verbose)
     return load_inp(f_in, flow_units_id=flow_units_id)
@@ -488,8 +482,7 @@ def load_rural(download_dir: str = get_temp_folder(), verbose: bool = True,
         :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`.
     """
     f_in = os.path.join(download_dir, "RuralNetwork.inp")
-    url = "https://github.com/OpenWaterAnalytics/EPyT/raw/main/epyt/networks/" + \
-          "asce-tf-wdst/RuralNetwork.inp"
+    url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/RuralNetwork.inp"
 
     download_if_necessary(f_in, url, verbose)
     return load_inp(f_in, flow_units_id=flow_units_id)
@@ -536,8 +529,7 @@ def load_bwsn1(download_dir: str = get_temp_folder(), verbose: bool = True,
         :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`.
     """
     f_in = os.path.join(download_dir, "BWSN_Network_1.inp")
-    url = "https://github.com/OpenWaterAnalytics/EPyT/raw/main/epyt/networks/" + \
-          "asce-tf-wdst/BWSN_Network_1.inp"
+    url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/BWSN_Network_1.inp"
 
     download_if_necessary(f_in, url, verbose)
     return load_inp(f_in, flow_units_id=flow_units_id)
@@ -584,8 +576,7 @@ def load_bwsn2(download_dir: str = get_temp_folder(), verbose: bool = True,
         :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`.
     """
     f_in = os.path.join(download_dir, "BWSN_Network_2.inp")
-    url = "https://github.com/OpenWaterAnalytics/EPyT/raw/main/epyt/networks/" + \
-          "asce-tf-wdst/BWSN_Network_2.inp"
+    url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/BWSN_Network_2.inp"
 
     download_if_necessary(f_in, url, verbose)
     return load_inp(f_in, flow_units_id=flow_units_id)
@@ -632,8 +623,7 @@ def load_anytown(download_dir: str = get_temp_folder(), verbose: bool = True,
         :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`.
     """
     f_in = os.path.join(download_dir, "Anytown.inp")
-    url = "https://raw.githubusercontent.com/OpenWaterAnalytics/EPyT/main/epyt/networks/" + \
-          "asce-tf-wdst/Anytown.inp"
+    url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/Anytown.inp"
 
     download_if_necessary(f_in, url, verbose)
     return load_inp(f_in, flow_units_id=flow_units_id)
@@ -727,7 +717,7 @@ def load_ctown(download_dir: str = get_temp_folder(), verbose: bool = True,
         :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`.
     """
     f_in = os.path.join(download_dir, "CTOWN.INP")
-    url = "https://github.com/scy-phy/www.batadal.net/raw/master/data/CTOWN.INP"
+    url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/CTOWN.INP"
 
     download_if_necessary(f_in, url, verbose)
     return load_inp(f_in, flow_units_id=flow_units_id)
@@ -783,8 +773,7 @@ def load_kentucky(wdn_id: int = 1, download_dir: str = get_temp_folder(),
         raise ValueError(f"Unknown network 'ky{wdn_id}.inp'")
 
     f_in = os.path.join(download_dir, f"ky{wdn_id}.inp")
-    url = "https://raw.githubusercontent.com/OpenWaterAnalytics/EPyT/main/epyt/networks/" + \
-          f"asce-tf-wdst/ky{wdn_id}.inp"
+    url = f"https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/ky{wdn_id}.inp"
 
     download_if_necessary(f_in, url, verbose)
     return load_inp(f_in, flow_units_id=flow_units_id)
@@ -836,8 +825,7 @@ def load_hanoi(download_dir: str = get_temp_folder(),
         :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`.
     """
     f_in = os.path.join(download_dir, "Hanoi.inp")
-    url = "https://raw.githubusercontent.com/OpenWaterAnalytics/EPyT/main/epyt/networks/" + \
-          "asce-tf-wdst/Hanoi.inp"
+    url = "https://filedn.com/lumBFq2P9S74PNoLPWtzxG4/EPyT-Flow/Networks/Hanoi.inp"
 
     download_if_necessary(f_in, url, verbose)
     config = load_inp(f_in, flow_units_id=flow_units_id)

epyt_flow/gym/scenario_control_env.py

@@ -1,12 +1,15 @@
 """
 Module provides a base class for control environments.
 """
+import os
+import uuid
 from abc import abstractmethod, ABC
 from typing import Union
 import warnings
 import numpy as np
 
-from ..simulation import ScenarioSimulator, ScenarioConfig, ScadaData
+from ..simulation import ScenarioSimulator, ScenarioConfig, ScadaData, ToolkitConstants
+from ..utils import get_temp_folder
 
 
 class ScenarioControlEnv(ABC):
@@ -21,12 +24,32 @@ class ScenarioControlEnv(ABC):
         If True, environment is automatically reset if terminated.
 
         The default is False.
+
+    Attributes
+    ----------
+    _scenario_sim : :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`, protected
+        Scenario simulator of the control scenario.
+    _scenario_config : :class:`~epyt_flow.simulation.scenario_config.ScenarioConfig`
+        Scenario configuration.
+    _sim_generator : Generator[Union[:class:`~epyt_flow.simulation.scada.scada_data.ScadaData`, dict], bool, None], protected
+        Generator for running the step-wise simulation.
+    _hydraulic_scada_data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData`, protected
+        SCADA data from the hydraulic simulation -- only used if EPANET-MSX is used in the control scenario.
     """
     def __init__(self, scenario_config: ScenarioConfig, autoreset: bool = False, **kwds):
-        self.__scenario_config = scenario_config
+        if not isinstance(scenario_config, ScenarioConfig):
+            raise TypeError("'scenario_config' must be an instance of " +
+                            "'epyt_flow.simulation.ScenarioConfig' " +
+                            "but not of '{type(scenario_config)}'")
+        if not isinstance(autoreset, bool):
+            raise TypeError("'autoreset' must be an instance of 'bool' " +
+                            f"but not of '{type(autoreset)}'")
+
+        self._scenario_config = scenario_config
         self._scenario_sim = None
         self._sim_generator = None
         self.__autoreset = autoreset
+        self._hydraulic_scada_data = None
 
         super().__init__(**kwds)
 
@@ -54,15 +77,27 @@ class ScenarioControlEnv(ABC):
         """
         try:
             if self._sim_generator is not None:
-                self._sim_generator.send(True)
                 next(self._sim_generator)
+                self._sim_generator.send(True)
         except StopIteration:
             pass
 
         if self._scenario_sim is not None:
             self._scenario_sim.close()
 
-    def reset(self) -> ScadaData:
+    def contains_events(self) -> bool:
+        """
+        Check if the scenario contains any events.
+
+        Returns
+        -------
+        `bool`
+            True is the scenario contains any events, False otherwise.
+        """
+        return len(self._scenario_config.system_events) != 0 or \
+            len(self._scenario_config.sensor_reading_events) != 0
+
+    def reset(self) -> Union[tuple[ScadaData, bool], ScadaData]:
         """
         Resets the environment (i.e. simulation).
 
@@ -75,20 +110,38 @@ class ScenarioControlEnv(ABC):
             self._scenario_sim.close()
 
         self._scenario_sim = ScenarioSimulator(
-            scenario_config=self.__scenario_config)
-        self._sim_generator = self._scenario_sim.run_simulation_as_generator(support_abort=True)
+            scenario_config=self._scenario_config)
+
+        if self._scenario_sim.f_msx_in is not None:
+            # Run hydraulic simulation first
+            hyd_export = os.path.join(get_temp_folder(), f"epytflow_env_MSX_{uuid.uuid4()}.hyd")
+            sim = self._scenario_sim.run_hydraulic_simulation
+            self._hydraulic_scada_data = sim(hyd_export=hyd_export)
+
+            # Run advanced quality analysis (EPANET-MSX) on top of the computed hydraulics
+            gen = self._scenario_sim.run_advanced_quality_simulation_as_generator
+            self._sim_generator = gen(hyd_export, support_abort=True)
+        else:
+            gen = self._scenario_sim.run_hydraulic_simulation_as_generator
+            self._sim_generator = gen(support_abort=True)
 
         return self._next_sim_itr()
 
-    def _next_sim_itr(self) -> ScadaData:
+    def _next_sim_itr(self) -> Union[tuple[ScadaData, bool], ScadaData]:
         try:
             next(self._sim_generator)
-            r = self._sim_generator.send(False)
+            scada_data = self._sim_generator.send(False)
+
+            if self._scenario_sim.f_msx_in is not None:
+                cur_time = int(scada_data.sensor_readings_time[0])
+                cur_hyd_scada_data = self._hydraulic_scada_data.\
+                    extract_time_window(cur_time, cur_time)
+                scada_data.join(cur_hyd_scada_data)
 
             if self.autoreset is True:
-                return r
+                return scada_data
             else:
-                return r, False
+                return scada_data, False
         except StopIteration:
             if self.__autoreset is True:
                 return self.reset()
@@ -112,6 +165,10 @@ class ScenarioControlEnv(ABC):
                 - EN_CLOSED  = 0
                 - EN_OPEN    = 1
         """
+        if self._scenario_sim.f_msx_in is not None:
+            raise RuntimeError("Can not execute actions affecting the hydraulics "+
+                               "when running EPANET-MSX")
+
         pump_idx = self._scenario_sim.epanet_api.getLinkPumpNameID().index(pump_id)
         pump_link_idx = self._scenario_sim.epanet_api.getLinkPumpIndex(pump_idx + 1)
         self._scenario_sim.epanet_api.setLinkStatus(pump_link_idx, status)
@@ -127,6 +184,10 @@ class ScenarioControlEnv(ABC):
         speed : `float`
             New pump speed.
         """
+        if self._scenario_sim.f_msx_in is not None:
+            raise RuntimeError("Can not execute actions affecting the hydraulics "+
+                               "when running EPANET-MSX")
+
         pump_idx = self._scenario_sim.epanet_api.getLinkPumpNameID().index(pump_id)
         pattern_idx = self._scenario_sim.epanet_api.getLinkPumpPatternIndex(pump_idx + 1)
 
@@ -154,6 +215,10 @@ class ScenarioControlEnv(ABC):
                 - EN_CLOSED  = 0
                 - EN_OPEN    = 1
         """
+        if self._scenario_sim.f_msx_in is not None:
+            raise RuntimeError("Can not execute actions affecting the hydraulics "+
+                               "when running EPANET-MSX")
+
         valve_idx = self._scenario_sim.epanet_api.getLinkValveNameID().index(valve_id)
         valve_link_idx = self._scenario_sim.epanet_api.getLinkValveIndex()[valve_idx]
         self._scenario_sim.epanet_api.setLinkStatus(valve_link_idx, status)
@@ -173,11 +238,65 @@ class ScenarioControlEnv(ABC):
         qual_value : `float`
             New quality source value.
         """
+        if self._scenario_sim.f_msx_in is not None:
+            raise RuntimeError("Can not execute actions affecting the hydraulics "+
+                               "when running EPANET-MSX")
+
         node_idx = self._scenario_sim.epanet_api.getNodeIndex(node_id)
         pattern_idx = self._scenario_sim.epanet_api.getPatternIndex(pattern_id)
         self._scenario_sim.epanet_api.setNodeSourceQuality(node_idx, 1)
         self._scenario_sim.epanet_api.setPattern(pattern_idx, np.array([qual_value]))
 
+    def set_node_species_source_value(self, species_id: str, node_id: str, source_type: int,
+                                      pattern_id: str, source_strength: float) -> None:
+        """
+        Sets the species source at a particular node to a specific value -- i.e.
+        setting the species injection amount at a particular location.
+
+        Parameters
+        ----------
+        species_id : `str`
+            ID of the species.
+        node_id : `str`
+            ID of the node.
+        source_type : `int`
+            Type of the external 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`
+            ID of the source pattern.
+        source_strength : `float`
+            Amount of the injected species (source strength) --
+            i.e. interpreation of this number depends on `source_type`
+        """
+        if self._scenario_sim.f_msx_in is None:
+            raise RuntimeError("You are not running EPANET-MSX")
+
+        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"
+
+        self._scenario_sim.epanet_api.setMSXPattern(pattern_id, [1])
+        self._scenario_sim.epanet_api.setMSXSources(node_id, species_id, source_type_,
+                                                    source_strength, pattern_id)
+
     @abstractmethod
     def step(self, *actions) -> Union[tuple[ScadaData, float, bool], tuple[ScadaData, float]]:
         """

epyt_flow/serialization.py

@@ -47,6 +47,7 @@ NETWORK_TOPOLOGY_ID                     = 26
 PUMP_STATE_EVENT_ID                     = 28
 PUMP_SPEED_EVENT_ID                     = 29
 VALVE_STATE_EVENT_ID                    = 30
+SPECIESINJECTION_EVENT_ID               = 31
 
 
 def my_packb(data: Any) -> bytes:
@@ -452,9 +453,15 @@ def save_to_file(f_out: str, data: Any, use_compression: bool = True) -> None:
 def __encode_bsr_array(array: scipy.sparse.bsr_array
                        ) -> tuple[tuple[int, int], tuple[list[float], tuple[list[int], list[int]]]]:
     shape = array.shape
-    data = array.data.flatten().tolist()
-    rows = array.nonzero()[0].tolist()
-    cols = array.nonzero()[1].tolist()
+    data = []
+    rows = []
+    cols = []
+
+    array_ = array.tocsr()   # Bug workaround: BSR arrays do not implement __getitem__
+    for i, j in zip(*array_.nonzero()):
+        rows.append(int(i))
+        cols.append(int(j))
+        data.append(float(array_[i, j]))
 
     return shape, (data, (rows, cols))
 

epyt_flow/simulation/events/__init__.py

@@ -1,5 +1,6 @@
 from .system_event import *
 from .leakages import *
+from .quality_events import *
 from .sensor_reading_event import *
 from .sensor_faults import *
 from .sensor_reading_attack import *

epyt_flow/simulation/events/leakages.py

@@ -60,8 +60,8 @@ class Leakage(SystemEvent, JsonSerializable):
         if area is None and diameter is None:
             raise ValueError("Either 'diameter' or 'area' must be given")
         if area is not None and diameter is not None:
-                raise ValueError("Either 'diameter' or 'area' must be given, " +
-                                 "but not both at the same time")
+            raise ValueError("Either 'diameter' or 'area' must be given, " +
+                             "but not both at the same time")
         if diameter is not None:
             if not isinstance(diameter, float):
                 raise TypeError("'diameter must be an instance of 'float' but " +
@@ -92,7 +92,7 @@ class Leakage(SystemEvent, JsonSerializable):
         self.__area = area
         self.__profile = profile
 
-        self.__leaky_node_id = None
+        self.__leaky_node_idx = None
         self.__leak_emitter_coef = None
         self.__time_pattern_idx = 0
 
@@ -174,7 +174,7 @@ class Leakage(SystemEvent, JsonSerializable):
     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.__leaky_node_id
+                                           "node_id": self.__node_id
                                            if self.__link_id is None else None}
 
     def __eq__(self, other) -> bool:
@@ -238,10 +238,16 @@ class Leakage(SystemEvent, JsonSerializable):
             g = 32.17405    # feet/s^2
         else:
             raise ValueError("Leakages are only implemented for the following flow units:\n" +
-                             " EN_CMH (cubic foot/sec)\n EN_CFS (cubic meter/hr)")
+                             " EN_CMH (cubic meter/hr)\n EN_CFS (foot/sec)")
 
         return discharge_coef * area * np.sqrt(2. * g)
 
+    def _get_new_link_id(self) -> str:
+        return f"leak_pipe_{self.__link_id}"
+
+    def _get_new_node_id(self) -> str:
+        return f"leak_node_{self.__link_id}"
+
     def init(self, epanet_api: epyt.epanet) -> None:
         super().init(epanet_api)
 
@@ -250,35 +256,72 @@ class Leakage(SystemEvent, JsonSerializable):
             if self.__link_id not in self._epanet_api.getLinkNameID():
                 raise ValueError(f"Unknown link/pipe '{self.__link_id}'")
 
-            new_link_id = f"leak_pipe_{self.link_id}"
-            new_node_id = f"leak_node_{self.link_id}"
+            new_link_id = self._get_new_link_id()
+            new_node_id = self._get_new_node_id()
 
             all_nodes_id = self._epanet_api.getNodeNameID()
             if new_node_id in all_nodes_id:
                 raise ValueError(f"There is already a leak at pipe {self.link_id}")
 
             self._epanet_api.splitPipe(self.link_id, new_link_id, new_node_id)
-            self.__leaky_node_id = self._epanet_api.getNodeIndex(new_node_id)
+            self.__leaky_node_idx = self._epanet_api.getNodeIndex(new_node_id)
         else:
             if self.__node_id not in self._epanet_api.getNodeNameID():
                 raise ValueError(f"Unknown node '{self.__node_id}'")
 
-            self.__leaky_node_id = self._epanet_api.getNodeIndex(self.__node_id)
+            self.__leaky_node_idx = self._epanet_api.getNodeIndex(self.__node_id)
 
-        self._epanet_api.setNodeEmitterCoeff(self.__leaky_node_id, 0.)
+        self._epanet_api.setNodeEmitterCoeff(self.__leaky_node_idx, 0.)
 
         # 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.getLinkIndex(self.__link_id)
+            link_prop = self._epanet_api.getLinksInfo()
+            link_diameter = link_prop.LinkDiameter[pipe_idx - 1]
+            link_length = link_prop.LinkLength[pipe_idx - 1] * 2.
+            link_roughness_coeff = link_prop.LinkRoughnessCoeff[pipe_idx - 1]
+            link_minor_loss_coeff = link_prop.LinkMinorLossCoeff[pipe_idx - 1]
+            link_initial_status = link_prop.LinkInitialStatus[pipe_idx - 1]
+            link_initial_setting = link_prop.LinkInitialSetting[pipe_idx - 1]
+            link_bulk_reaction_coeff = link_prop.LinkBulkReactionCoeff[pipe_idx - 1]
+            link_wall_reaction_coeff = link_prop.LinkWallReactionCoeff[pipe_idx - 1]
+
+            node_a_idx = int(self._epanet_api.getLinkNodesIndex(pipe_idx)[0])
+            node_b_idx = int(self._epanet_api.getLinkNodesIndex(self._get_new_link_id())[1])
+
+            self._epanet_api.deleteLink(self._get_new_link_id())
+            self._epanet_api.deleteLink(self.__link_id)
+            self._epanet_api.deleteNode(self._get_new_node_id())
+
+            self._epanet_api.addLinkPipe(self.__link_id,
+                                         self._epanet_api.getNodeNameID(node_a_idx),
+                                         self._epanet_api.getNodeNameID(node_b_idx))
+            link_idx = self._epanet_api.getLinkIndex(self.__link_id)
+            self._epanet_api.setLinkNodesIndex(link_idx,
+                                               node_a_idx, node_b_idx)
+            self._epanet_api.setLinkPipeData(link_idx, link_length, link_diameter,
+                                             link_roughness_coeff,
+                                             link_minor_loss_coeff)
+            if link_minor_loss_coeff != 0:
+                self._epanet_api.setLinklinkMinorLossCoeff(link_idx, link_minor_loss_coeff)
+            self._epanet_api.setLinkInitialStatus(link_idx, link_initial_status)
+            self._epanet_api.setLinkInitialSetting(link_idx, link_initial_setting)
+            self._epanet_api.setLinkBulkReactionCoeff(link_idx, link_bulk_reaction_coeff)
+            self._epanet_api.setLinkWallReactionCoeff(link_idx, link_wall_reaction_coeff)
+            self._epanet_api.setLinkTypePipe(link_idx)
+
     def reset(self) -> None:
         self.__time_pattern_idx = 0
 
     def exit(self, cur_time) -> None:
-        self._epanet_api.setNodeEmitterCoeff(self.__leaky_node_id, 0.)
+        self._epanet_api.setNodeEmitterCoeff(self.__leaky_node_idx, 0.)
 
     def apply(self, cur_time: int) -> None:
-        self._epanet_api.setNodeEmitterCoeff(self.__leaky_node_id,
+        self._epanet_api.setNodeEmitterCoeff(self.__leaky_node_idx,
                                              self.__leak_emitter_coef *
                                              self.__profile[self.__time_pattern_idx])
         self.__time_pattern_idx += 1