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

epyt_flow/VERSION

@@ -1 +1 @@
-0.14.1
+0.15.0b1

epyt_flow/__init__.py

@@ -1,42 +1,5 @@
-import subprocess
-import warnings
-import shutil
-import sys
 import os
 
 with open(os.path.join(os.path.dirname(__file__), 'VERSION'), encoding="utf-8") as f:
     VERSION = f.read().strip()
     __version__ = VERSION
-
-
-def compile_libraries_unix(lib_epanet_name: str, compile_script_name: str,
-                           gcc_name: str = "gcc") -> None:
-    """Compile EPANET and EPANET-MSX libraries if needed."""
-    path_to_custom_libs = os.path.join(os.path.dirname(__file__), "customlibs")
-    path_to_lib_epanet = os.path.join(path_to_custom_libs, lib_epanet_name)
-    path_to_epanet = os.path.join(os.path.dirname(__file__), "EPANET")
-
-    update = False
-    if os.path.isfile(path_to_lib_epanet):
-        if os.path.getmtime(__file__) > os.path.getmtime(path_to_lib_epanet):
-            update = True
-
-    if not os.path.isfile(path_to_lib_epanet) or update:
-        if shutil.which(gcc_name) is not None:
-            print("Compiling EPANET and EPANET-MSX...")
-            try:
-                subprocess.check_call(f"cd \"{path_to_epanet}\"; bash {compile_script_name}",
-                                      shell=True)
-                print("Done")
-            except subprocess.CalledProcessError as ex:
-                print(f"Compilation failed\n{ex}")
-                warnings.warn("Falling back to pre-compiled library shipped by EPyT.")
-        else:
-            warnings.warn("GCC is not available to compile the required libraries.\n" +
-                          "Falling back to pre-compiled library shipped by EPyT.")
-
-
-if sys.platform.startswith("linux"):
-    compile_libraries_unix("libepanet2_2.so", "compile_linux.sh")
-elif sys.platform.startswith("darwin"):
-    compile_libraries_unix("libepanet2_2.dylib", "compile_macos.sh", gcc_name="gcc-15")

epyt_flow/data/benchmarks/battledim.py

@@ -32,7 +32,7 @@ from .battledim_data import START_TIME_TEST, START_TIME_TRAIN, LEAKS_CONFIG_TEST
     LEAKS_CONFIG_TRAIN
 from ..networks import load_ltown
 from ...simulation.events import AbruptLeakage, IncipientLeakage, Leakage
-from ...simulation import ScenarioConfig
+from ...simulation import ScenarioConfig, EpanetConstants
 from ...topology import NetworkTopology
 from ...simulation.scada import ScadaData
 from ...utils import get_temp_folder, to_seconds, create_path_if_not_exist, download_if_necessary
@@ -463,7 +463,7 @@ def load_scenario(return_test_scenario: bool, download_dir: str = None,
     general_params = {"simulation_duration": to_seconds(days=365),    # One year
                       "hydraulic_time_step": to_seconds(minutes=5),   # 5min time steps
                       "reporting_time_step": to_seconds(minutes=5),
-                      "demand_model": {"type": "PDA", "pressure_min": 0,
+                      "demand_model": {"type": EpanetConstants.EN_PDA, "pressure_min": 0,
                                        "pressure_required": 0.1,
                                        "pressure_exponent": 0.5}
                       } | ltown_config.general_params

epyt_flow/data/benchmarks/leakdb.py

@@ -28,7 +28,7 @@ from ..networks import load_net1, load_hanoi
 from .leakdb_data import NET1_LEAKAGES, HANOI_LEAKAGES
 from ...utils import get_temp_folder, to_seconds, unpack_zip_archive, create_path_if_not_exist, \
     download_if_necessary
-from ...simulation import ScenarioSimulator, ToolkitConstants
+from ...simulation import ScenarioSimulator, EpanetConstants
 from ...simulation.events import AbruptLeakage, IncipientLeakage
 from ...simulation import ScenarioConfig
 from ...simulation.scada import ScadaData
@@ -275,6 +275,8 @@ def load_data(scenarios_id: list[int], use_net1: bool, download_dir: str = None,
         create_path_if_not_exist(scenario_data_folder_in)
         unpack_zip_archive(scenario_data_file_in, scenario_data_folder_in)
 
+        scenario_data_folder_in = os.path.join(scenario_data_folder_in, f"Scenario-{s_id}")
+
         # Load and parse data
         pressure_files = list(filter(lambda d: d.endswith(".csv"),
                                      os.listdir(os.path.join(scenario_data_folder_in,
@@ -464,8 +466,8 @@ def load_scenarios(scenarios_id: list[int], use_net1: bool = True,
     general_params = {"simulation_duration": to_seconds(days=365),   # One year
                       "hydraulic_time_step": hydraulic_time_step,
                       "reporting_time_step": hydraulic_time_step,
-                      "flow_units_id": ToolkitConstants.EN_CMH,
-                      "demand_model": {"type": "PDA", "pressure_min": 0,
+                      "flow_units_id": EpanetConstants.EN_CMH,
+                      "demand_model": {"type": EpanetConstants.EN_PDA, "pressure_min": 0,
                                        "pressure_required": 0.1,
                                        "pressure_exponent": 0.5}
                       } | network_config.general_params
@@ -544,18 +546,19 @@ def load_scenarios(scenarios_id: list[int], use_net1: bool = True,
         if not os.path.exists(f_inp_in):
             with ScenarioSimulator(f_inp_in=network_config.f_inp_in) as wdn:
                 wdn.set_general_parameters(**general_params)
-                wdn.epanet_api.setTimePatternStep(hydraulic_time_step)
+                wdn.epanet_api.set_hydraulic_time_step(hydraulic_time_step)
 
-                wdn.epanet_api.deletePatternsAll()
+                for idx in range(1, wdn.epanet_api.getcount(EpanetConstants.EN_PATCOUNT) + 1):
+                    wdn.epanet_api.deletepattern(idx)
 
-                reservoir_nodes_id = wdn.epanet_api.getNodeReservoirNameID()
+                reservoir_nodes_id = wdn.epanet_api.get_all_reservoirs_id()
                 for node_id in network_config.sensor_config.nodes:
                     if node_id in network_config.sensor_config.tanks or\
                             node_id in reservoir_nodes_id:
                         continue
 
-                    node_idx = wdn.epanet_api.getNodeIndex(node_id)
-                    base_demand = wdn.epanet_api.getNodeBaseDemands(node_idx)[1][0]
+                    node_idx = wdn.epanet_api.get_node_idx(node_id)
+                    base_demand = wdn.epanet_api.get_node_base_demand(node_idx)
 
                     my_demand_pattern = np.array(gen_dem(download_dir))
 
@@ -563,7 +566,7 @@ def load_scenarios(scenarios_id: list[int], use_net1: bool = True,
                                                 demand_pattern_id=f"demand_{node_id}",
                                                 demand_pattern=my_demand_pattern)
 
-                wdn.epanet_api.saveInputFile(f_inp_in)
+                wdn.epanet_api.saveinpfile(f_inp_in)
 
     # Create uncertainties
     class MyUniformUncertainty(UniformUncertainty):

epyt_flow/gym/scenario_control_env.py

@@ -6,9 +6,9 @@ import uuid
 from abc import abstractmethod, ABC
 from typing import Union
 import warnings
-import numpy as np
+from epanet_plus import EpanetConstants
 
-from ..simulation import ScenarioSimulator, ScenarioConfig, ScadaData, ToolkitConstants
+from ..simulation import ScenarioSimulator, ScenarioConfig, ScadaData
 from ..utils import get_temp_folder
 
 
@@ -193,14 +193,14 @@ class ScenarioControlEnv(ABC):
             raise RuntimeError("Can not execute actions affecting the hydraulics "+
                                "when running EPANET-MSX")
 
-        pump_idx = self._scenario_sim.epanet_api.getLinkPumpNameID().index(pump_id) + 1
-        pump_link_idx = self._scenario_sim.epanet_api.getLinkPumpIndex(pump_idx)
-
-        pattern_idx = self._scenario_sim.epanet_api.getLinkPumpPatternIndex(pump_idx)
+        pump_link_idx = self._scenario_sim.epanet_api.get_link_idx(pump_id)
+        pattern_idx = self._scenario_sim.epanet_api.getlinkvalue(pump_link_idx,
+                                                                 EpanetConstants.EN_LINKPATTERN)
         if pattern_idx != 0:
             warnings.warn(f"Can not set pump state of pump {pump_id} because a pump pattern exists")
         else:
-            self._scenario_sim.epanet_api.setLinkStatus(pump_link_idx, status)
+            self._scenario_sim.epanet_api.setlinkvalue(pump_link_idx, EpanetConstants.EN_STATUS,
+                                                       status)
 
     def set_pump_speed(self, pump_id: str, speed: float) -> None:
         """
@@ -217,15 +217,19 @@ class ScenarioControlEnv(ABC):
             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)
+        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_idx = self._scenario_sim.epanet_api.addPattern(f"pump_speed_{pump_id}")
-            self._scenario_sim.epanet_api.setLinkPumpPatternIndex(pump_idx + 1, pattern_idx)
+            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, np.array([speed]))
+        self._scenario_sim.epanet_api.setpattern(pattern_idx, [speed], 1)
 
     def set_valve_status(self, valve_id: str, status: int) -> None:
         """
@@ -248,9 +252,9 @@ class ScenarioControlEnv(ABC):
             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)
+        valve_link_idx = self._scenario_sim.epanet_api.get_link_idx(valve_id)
+        self._scenario_sim.epanet_api.setlinkvalue(valve_link_idx, EpanetConstants.EN_STATUS,
+                                                   status)
 
     def set_node_quality_source_value(self, node_id: str, pattern_id: str,
                                       qual_value: float) -> None:
@@ -271,10 +275,10 @@ class ScenarioControlEnv(ABC):
             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]))
+        node_idx = self._scenario_sim.epanet_api.get_node_idx(node_id)
+        pattern_idx = self._scenario_sim.epanet_api.getpatternindex(pattern_id)
+        self._scenario_sim.epanet_api.setnodevalue(node_idx, EpanetConstants.EN_SOURCEQUAL, 1)
+        self._scenario_sim.epanet_api.set_pattern(pattern_idx, [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:
@@ -290,7 +294,7 @@ class ScenarioControlEnv(ABC):
             ID of the node.
         source_type : `int`
             Type of the external species injection source -- must be one of
-            the following EPANET toolkit constants:
+            the following EPANET constants:
 
                 - EN_CONCEN     = 0
                 - EN_MASS       = 1
@@ -312,19 +316,14 @@ class ScenarioControlEnv(ABC):
         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)
+        pattern_idx = self._scenario_sim.epanet_api.MSXgetindex(EpanetConstants.MSX_PATTERN,
+                                                                pattern_id)
+        self._scenario_sim.epanet_api.MSXsetpattern(pattern_idx, [1], 1)
+
+        node_idx = self._scenario_sim.epanet_api.get_node_idx(node_id)
+        species_idx = self._scenario_sim.epanet_api.get_msx_species_idx(species_id)
+        self._scenario_sim.epanet_api.MSXsetsource(node_idx, species_idx, source_type,
+                                                   source_strength, pattern_idx)
 
     @abstractmethod
     def step(self, *actions) -> Union[tuple[ScadaData, float, bool], tuple[ScadaData, float]]:

epyt_flow/simulation/events/actuator_events.py

@@ -2,8 +2,7 @@
 Module provides implementations of different types of actuator events.
 """
 import warnings
-from epyt.epanet import epanet
-import numpy as np
+from epanet_plus import EPyT, EpanetConstants
 
 from .system_event import SystemEvent
 from ...serialization import serializable, JsonSerializable, PUMP_STATE_EVENT_ID, \
@@ -20,9 +19,15 @@ class ActuatorConstants:
         Valve or pump is closed.
     EN_OPEN
         Valve or pump is open -- i.e. active.
+    EN_SET_CLOSED
+        Link set closed indicator
+    EN_SET_OPEN
+        Link set open indicator
     """
     EN_CLOSED       = 0
     EN_OPEN         = 1
+    EN_SET_CLOSED   = -1e10
+    EN_SET_OPEN     = 1e10
 
 
 class ActuatorEvent(SystemEvent):
@@ -59,8 +64,8 @@ class PumpEvent(ActuatorEvent):
 
         super().__init__(**kwds)
 
-    def init(self, epanet_api: epanet) -> None:
-        if self.__pump_id not in epanet_api.getLinkPumpNameID():
+    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}'")
 
         super().init(epanet_api)
@@ -132,15 +137,15 @@ class PumpStateEvent(PumpEvent, JsonSerializable):
         return self.__pump_state
 
     def apply(self, cur_time: int) -> None:
-        pump_idx = self._epanet_api.getLinkPumpNameID().index(self.pump_id) + 1
-        pump_link_idx = self._epanet_api.getLinkPumpIndex(pump_idx)
+        pump_link_idx = self._epanet_api.getlinkindex(self.pump_id)
 
-        pattern_idx = self._epanet_api.getLinkPumpPatternIndex(pump_idx)
+        pattern_idx = self._epanet_api.getlinkvalue(pump_link_idx, EpanetConstants.EN_LINKPATTERN)
         if pattern_idx != 0:
             warnings.warn(f"Can not set pump state of pump {self.pump_id} " +
                           "because a pump pattern exists")
         else:
-            self._epanet_api.setLinkStatus(pump_link_idx, self.__pump_state)
+            self._epanet_api.setlinkvalue(pump_link_idx, EpanetConstants.EN_STATUS,
+                                          self.__pump_state)
 
 
 @serializable(PUMP_SPEED_EVENT_ID, ".epytflow_pump_speed_event")
@@ -180,15 +185,17 @@ class PumpSpeedEvent(PumpEvent, JsonSerializable):
         return self.__pump_speed
 
     def apply(self, cur_time: int) -> None:
-        pump_idx = self._epanet_api.getLinkPumpNameID().index(self.pump_id) + 1
-        pattern_idx = self._epanet_api.getLinkPumpPatternIndex(pump_idx)
+        pump_idx = self._epanet_api.get_link_idx(self.pump_id)
+        pattern_idx = self._epanet_api.getlinkvalue(pump_idx, EpanetConstants.EN_LINKPATTERN)
 
         if pattern_idx == 0:
             warnings.warn(f"No pattern for pump '{self.pump_id}' found -- a new pattern is created")
-            pattern_idx = self._epanet_api.addPattern(f"pump_speed_{self.pump_id}")
-            self._epanet_api.setLinkPumpPatternIndex(pump_idx, pattern_idx)
+            pattern_id = f"pump_speed_{self.pump_id}"
+            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, np.array([self.__pump_speed]))
+        self._epanet_api.setpattern(pattern_idx, [self.__pump_speed], 1)
 
 
 @serializable(VALVE_STATE_EVENT_ID, ".epytflow_valve_state_event")
@@ -222,8 +229,8 @@ class ValveStateEvent(ActuatorEvent, JsonSerializable):
 
         super().__init__(**kwds)
 
-    def init(self, epanet_api: epanet) -> None:
-        if self.__valve_id not in epanet_api.getLinkValveNameID():
+    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}'")
 
         super().init(epanet_api)
@@ -260,6 +267,5 @@ class ValveStateEvent(ActuatorEvent, JsonSerializable):
         return self.__valve_state
 
     def apply(self, cur_time: int) -> None:
-        valve_idx = self._epanet_api.getLinkValveNameID().index(self.__valve_id) + 1
-        valve_link_idx = self._epanet_api.getLinkValveIndex(valve_idx)
-        self._epanet_api.setLinkStatus(valve_link_idx, 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

@@ -4,8 +4,7 @@ Module provides classes for implementing leakages.
 from copy import deepcopy
 import math
 import numpy as np
-import epyt
-from epyt.epanet import ToolkitConstants
+from epanet_plus import EPyT, EpanetConstants
 
 from .system_event import SystemEvent
 from ...serialization import serializable, JsonSerializable, \
@@ -231,10 +230,10 @@ class Leakage(SystemEvent, JsonSerializable):
         `float`
             Leak emitter coefficient.
         """
-        flow_unit = self._epanet_api.api.ENgetflowunits()
-        if flow_unit == ToolkitConstants.EN_CMH:
+        flow_unit = self._epanet_api.getflowunits()
+        if flow_unit == EpanetConstants.EN_CMH:
             g = 127137600   # m/h^2
-        elif flow_unit == ToolkitConstants.EN_CFS:
+        elif flow_unit == EpanetConstants.EN_CFS:
             g = 32.17405    # feet/s^2
         else:
             raise ValueError("Leakages are only implemented for the following flow units:\n" +
@@ -248,30 +247,30 @@ class Leakage(SystemEvent, JsonSerializable):
     def _get_new_node_id(self) -> str:
         return f"leak_node_{self.__link_id}"
 
-    def init(self, epanet_api: epyt.epanet) -> None:
+    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.getLinkNameID():
+            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()
 
-            all_nodes_id = self._epanet_api.getNodeNameID()
+            all_nodes_id = self._epanet_api.get_all_nodes_id()
             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_idx = self._epanet_api.getNodeIndex(new_node_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)
         else:
-            if self.__node_id not in self._epanet_api.getNodeNameID():
+            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.getNodeIndex(self.__node_id)
+            self.__leaky_node_idx = self._epanet_api.get_node_idx(self.__node_id)
 
-        self._epanet_api.setNodeEmitterCoeff(self.__leaky_node_idx, 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(
@@ -279,51 +278,54 @@ class Leakage(SystemEvent, JsonSerializable):
 
     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)
+            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)
+            link_minor_loss_coeff = self._epanet_api.get_link_minorloss(pipe_idx)
+            link_initial_status = self._epanet_api.get_link_init_status(pipe_idx)
+            link_initial_setting = self._epanet_api.get_link_init_setting(pipe_idx)
+            link_bulk_reaction_coeff = self._epanet_api.get_link_bulk_raction_coeff(pipe_idx)
+            link_wall_reaction_coeff = self._epanet_api.get_link_wall_raction_coeff(pipe_idx)
+
+            node_a_idx = int(self._epanet_api.getlinknodes(pipe_idx)[0])
+            node_b_idx = int(self._epanet_api.getlinknodes(self._epanet_api.get_link_idx(self._get_new_link_id()))[1])
+
+            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),
+                                        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.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)
+            self._epanet_api.setlinknodes(link_idx, node_a_idx, node_b_idx)
+            self._epanet_api.setlinktype(link_idx, EpanetConstants.EN_PIPE,
+                                         EpanetConstants.EN_UNCONDITIONAL)
+            self._epanet_api.setpipedata(link_idx, link_length, link_diameter, link_roughness_coeff,
+                                         link_minor_loss_coeff)
+            self._epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_INITSTATUS,
+                                          link_initial_status)
+            self._epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_INITSETTING,
+                                          link_initial_setting)
+            self._epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_KBULK,
+                                          link_bulk_reaction_coeff)
+            self._epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_KWALL,
+                                          link_wall_reaction_coeff)
 
     def reset(self) -> None:
         self.__time_pattern_idx = 0
 
     def exit(self, cur_time) -> None:
-        self._epanet_api.setNodeEmitterCoeff(self.__leaky_node_idx, 0.)
+        self._epanet_api.setnodevalue(self.__leaky_node_idx, EpanetConstants.EN_EMITTER, 0.)
 
     def apply(self, cur_time: int) -> None:
-        self._epanet_api.setNodeEmitterCoeff(self.__leaky_node_idx,
-                                             self.__leak_emitter_coef *
-                                             self.__profile[self.__time_pattern_idx])
+        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
 
 
@@ -357,12 +359,12 @@ class AbruptLeakage(Leakage):
         else:
             super().__init__(link_id=link_id, diameter=diameter, area=area, **kwds)
 
-    def init(self, epanet_api: epyt.epanet) -> None:
+    def init(self, epanet_api: EPyT) -> None:
         super().init(epanet_api)
 
         # Set pattern
-        total_sim_duration = self._epanet_api.getTimeSimulationDuration()
-        time_step = self._epanet_api.getTimeHydraulicStep()
+        total_sim_duration = self._epanet_api.get_simulation_duration()
+        time_step = self._epanet_api.get_hydraulic_time_step()
 
         if self.end_time is not None:
             n_leaky_time_points = math.ceil((self.end_time - self.start_time) / time_step)
@@ -436,12 +438,12 @@ class IncipientLeakage(Leakage):
     def __str__(self) -> str:
         return f"{super().__str__()} peak_time: {self.peak_time}"
 
-    def init(self, epanet_api: epyt.epanet) -> None:
+    def init(self, epanet_api: EPyT) -> None:
         super().init(epanet_api)
 
         # Set pattern
-        total_sim_duration = self._epanet_api.getTimeSimulationDuration()
-        time_step = self._epanet_api.getTimeHydraulicStep()
+        total_sim_duration = self._epanet_api.get_simulation_duration()
+        time_step = self._epanet_api.get_hydraulic_time_step()
 
         if self.end_time is not None:
             n_leaky_time_points = math.ceil((self.end_time - self.start_time) / time_step)

epyt_flow/simulation/events/quality_events.py

@@ -5,8 +5,7 @@ from copy import deepcopy
 import warnings
 import math
 import numpy as np
-import epyt
-from epyt.epanet import ToolkitConstants
+from epanet_plus import EPyT, EpanetConstants
 
 from .system_event import SystemEvent
 from ...serialization import serializable, JsonSerializable, \
@@ -31,7 +30,7 @@ class SpeciesInjectionEvent(SystemEvent, JsonSerializable):
         Note that the pattern time step is equivalent to the EPANET pattern time step.
     source_type : `int`
         Type of the bulk species injection source -- must be one of
-        the following EPANET toolkit constants:
+        the following EPANET constants:
 
             - EN_CONCEN     = 0
             - EN_MASS       = 1
@@ -140,18 +139,18 @@ class SpeciesInjectionEvent(SystemEvent, JsonSerializable):
     def _get_pattern_id(self) -> str:
         return f"{self.__species_id}_{self.__node_id}"
 
-    def init(self, epanet_api: epyt.epanet) -> None:
+    def init(self, epanet_api: EPyT) -> None:
         super().init(epanet_api)
 
         # Check parameters
-        if self.__species_id not in self._epanet_api.getMSXSpeciesNameID():
+        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.getNodeNameID():
+        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.getTimeSimulationDuration()
-        time_step = self._epanet_api.getTimeHydraulicStep()
+        total_sim_duration = self._epanet_api.get_simulation_duration()
+        time_step = self._epanet_api.get_hydraulic_time_step()
 
         pattern = np.zeros(math.ceil(total_sim_duration / time_step))
 
@@ -170,34 +169,26 @@ class SpeciesInjectionEvent(SystemEvent, JsonSerializable):
                 injection_time_start_idx + injection_pattern_length] = injection_pattern
 
         # Create injection
-        source_type_ = "None"
-        if self.__source_type == ToolkitConstants.EN_CONCEN:
-            source_type_ = "CONCEN"
-        elif self.__source_type == ToolkitConstants.EN_MASS:
-            source_type_ = "MASS"
-        elif self.__source_type == ToolkitConstants.EN_SETPOINT:
-            source_type_ = "SETPOINT"
-        elif self.__source_type == ToolkitConstants.EN_FLOWPACED:
-            source_type_ = "FLOWPACED"
-
         pattern_id = self._get_pattern_id()
-        if pattern_id in self._epanet_api.getMSXPatternsNameID():
-            node_idx = self._epanet_api.getNodeIndex(self.__node_id)
-            species_idx, = self._epanet_api.getMSXSpeciesIndex([self.__species_id])
-            cur_source_type = self._epanet_api.msx.MSXgetsource(node_idx, species_idx)
-            if cur_source_type[0] != source_type_:
+        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)
+            cur_source_type = self._epanet_api.MSXgetsource(node_idx, species_idx)
+            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 --
             # i.e. two injection events at the same node
-            pattern_idx, = self._epanet_api.getMSXPatternsIndex([pattern_id])
-            cur_pattern = self._epanet_api.getMSXPattern()[pattern_idx - 1]
-            cur_pattern += pattern
-            self._epanet_api.setMSXPattern(pattern_idx, cur_pattern)
+            pattern_idx = self._epanet_api.MSXgetindex(EpanetConstants.MSX_PATTERN, pattern_id)
+            cur_pattern = self._epanet_api.get_msx_pattern(pattern_idx)
+            cur_pattern = np.array(cur_pattern) + pattern
+            self._epanet_api.MSXsetpattern(pattern_idx, cur_pattern.tolist(), len(cur_pattern))
         else:
-            self._epanet_api.addMSXPattern(pattern_id, pattern)
-        self._epanet_api.setMSXSources(self.__node_id, self.__species_id, source_type_, 1,
-                                       pattern_id)
+            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,
+                                        pattern_id)
 
     def cleanup(self) -> None:
         warnings.warn("Can not undo SpeciesInjectionEvent -- " +