epyt-flow 0.14.2__tar.gz → 0.15.0__tar.gz

{epyt_flow-0.14.2 → epyt_flow-0.15.0}/MANIFEST.in

@@ -1,5 +1,4 @@
 include epyt_flow/VERSION
-recursive-include epyt_flow/EPANET *
 exclude .*
 exclude DEVELOPERS.md
 exclude REQUIREMENTS-DEV.txt
@@ -10,4 +9,4 @@ recursive-exclude examples/ *
 recursive-exclude paper/ *
 recursive-exclude docs/ *
 recursive-exclude tests/ *
-recursive-exclude .github/ *
+recursive-exclude .github/ *

{epyt_flow-0.14.2 → epyt_flow-0.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: epyt-flow
-Version: 0.14.2
+Version: 0.15.0
 Summary: EPyT-Flow -- EPANET Python Toolkit - Flow
 Author-email: André Artelt <aartelt@techfak.uni-bielefeld.de>, "Marios S. Kyriakou" <kiriakou.marios@ucy.ac.cy>, "Stelios G. Vrachimis" <vrachimis.stelios@ucy.ac.cy>
 License-Expression: MIT
@@ -17,10 +17,11 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: epyt>=1.2.2
+Requires-Dist: epanet-plus>=0.1.2
 Requires-Dist: requests>=2.31.0
 Requires-Dist: scipy>=1.11.4
 Requires-Dist: u-msgpack-python>=2.8.0
@@ -49,11 +50,13 @@ Dynamic: license-file
 
 <img src="https://github.com/WaterFutures/EPyT-Flow/blob/main/docs/_static/net1_plot.png?raw=true" align="right" height="230px"/>
 
-EPyT-Flow is a Python package building on top of [EPyT](https://github.com/OpenWaterAnalytics/EPyT) 
+EPyT-Flow is a Python package building on top of [EPANET-PLUS](https://github.com/WaterFutures/EPANET-PLUS) --
+an extension and interface of [EPANET](https://github.com/OpenWaterAnalytics/EPANET)
+and [EPANET-MSX](https://github.com/OpenWaterAnalytics/epanet-msx) -- 
 for providing easy access to water distribution network simulations.
 It aims to provide a high-level interface for the easy generation of hydraulic and water quality scenario data.
-However, it also provides access to low-level functions by [EPANET](https://github.com/USEPA/EPANET2.2) 
-and [EPANET-MSX](https://github.com/USEPA/EPANETMSX/).
+However, it also provides access to all functions of EPANET
+and EPANET-MSX.
 
 EPyT-Flow provides easy access to popular benchmark data sets for event detection and localization.
 Furthermore, it also provides an environment for developing and testing control algorithms.
@@ -77,21 +80,13 @@ Unique features of EPyT-Flow that make it superior to other (Python) toolboxes a
 
 ## Installation
 
-EPyT-Flow supports Python 3.9 - 3.13
+EPyT-Flow supports Python 3.9 - 3.14
 
-Note that [EPANET and EPANET-MSX sources](epyt_flow/EPANET/) are compiled and overwrite the binaries
-shipped by EPyT **IF** EPyT-Flow is installed on a Unix system and the *gcc* compiler is available.
-By this, we not only aim to achieve a better performance of the simulations but also avoid any
-compatibility issues of pre-compiled binaries.
-
-#### Prerequisites for macOS users
-The "true" *gcc* compiler (version 15) is needed which is not the
-*clang* compiler that is shipped with Xcode and is linked to gcc!
-
-The correct version of the "true" *gcc* can be installed via [brew](https://brew.sh/):
-```
-brew install gcc@15
-```
+Note that EPyT-Flow builds upon [EPANET-PLUS](https://github.com/WaterFutures/EPANET-PLUS) which
+constitutes a C extension and Python package.
+In the rare case that the pre-build package of EPANET-PLUS does not work on your system,
+you have to build and install it manually -- please follow the instructions provided
+[here](https://epanet-plus.readthedocs.io/en/stable/installation.html).
 
 ### PyPI
 

{epyt_flow-0.14.2 → epyt_flow-0.15.0}/README.md

@@ -11,11 +11,13 @@
 
 <img src="https://github.com/WaterFutures/EPyT-Flow/blob/main/docs/_static/net1_plot.png?raw=true" align="right" height="230px"/>
 
-EPyT-Flow is a Python package building on top of [EPyT](https://github.com/OpenWaterAnalytics/EPyT) 
+EPyT-Flow is a Python package building on top of [EPANET-PLUS](https://github.com/WaterFutures/EPANET-PLUS) --
+an extension and interface of [EPANET](https://github.com/OpenWaterAnalytics/EPANET)
+and [EPANET-MSX](https://github.com/OpenWaterAnalytics/epanet-msx) -- 
 for providing easy access to water distribution network simulations.
 It aims to provide a high-level interface for the easy generation of hydraulic and water quality scenario data.
-However, it also provides access to low-level functions by [EPANET](https://github.com/USEPA/EPANET2.2) 
-and [EPANET-MSX](https://github.com/USEPA/EPANETMSX/).
+However, it also provides access to all functions of EPANET
+and EPANET-MSX.
 
 EPyT-Flow provides easy access to popular benchmark data sets for event detection and localization.
 Furthermore, it also provides an environment for developing and testing control algorithms.
@@ -39,21 +41,13 @@ Unique features of EPyT-Flow that make it superior to other (Python) toolboxes a
 
 ## Installation
 
-EPyT-Flow supports Python 3.9 - 3.13
+EPyT-Flow supports Python 3.9 - 3.14
 
-Note that [EPANET and EPANET-MSX sources](epyt_flow/EPANET/) are compiled and overwrite the binaries
-shipped by EPyT **IF** EPyT-Flow is installed on a Unix system and the *gcc* compiler is available.
-By this, we not only aim to achieve a better performance of the simulations but also avoid any
-compatibility issues of pre-compiled binaries.
-
-#### Prerequisites for macOS users
-The "true" *gcc* compiler (version 15) is needed which is not the
-*clang* compiler that is shipped with Xcode and is linked to gcc!
-
-The correct version of the "true" *gcc* can be installed via [brew](https://brew.sh/):
-```
-brew install gcc@15
-```
+Note that EPyT-Flow builds upon [EPANET-PLUS](https://github.com/WaterFutures/EPANET-PLUS) which
+constitutes a C extension and Python package.
+In the rare case that the pre-build package of EPANET-PLUS does not work on your system,
+you have to build and install it manually -- please follow the instructions provided
+[here](https://epanet-plus.readthedocs.io/en/stable/installation.html).
 
 ### PyPI
 

{epyt_flow-0.14.2 → epyt_flow-0.15.0}/REQUIREMENTS.txt

@@ -1,4 +1,4 @@
-epyt>=1.2.2
+epanet-plus>=0.1.2
 requests>=2.31.0
 scipy>=1.11.4
 u-msgpack-python>=2.8.0

epyt_flow-0.15.0/epyt_flow/VERSION

@@ -0,0 +1 @@
+0.15.0

epyt_flow-0.15.0/epyt_flow/__init__.py

@@ -0,0 +1,5 @@
+import os
+
+with open(os.path.join(os.path.dirname(__file__), 'VERSION'), encoding="utf-8") as f:
+    VERSION = f.read().strip()
+    __version__ = VERSION

{epyt_flow-0.14.2 → epyt_flow-0.15.0}/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-0.14.2 → epyt_flow-0.15.0}/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-0.14.2 → epyt_flow-0.15.0}/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-0.14.2 → epyt_flow-0.15.0}/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-0.14.2 → epyt_flow-0.15.0}/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)