epyt-flow 0.14.2__py3-none-any.whl → 0.15.0__py3-none-any.whl

epyt_flow/uncertainty/model_uncertainty.py

@@ -4,8 +4,7 @@ Module provides a class for implementing model uncertainty.
 from typing import Optional
 from copy import deepcopy
 import warnings
-import epyt
-from epyt.epanet import ToolkitConstants
+from epanet_plus import EPyT, EpanetConstants
 import numpy as np
 
 from ..serialization import serializable, JsonSerializable, MODEL_UNCERTAINTY_ID
@@ -627,7 +626,7 @@ class ModelUncertainty(JsonSerializable):
             f"local_patterns: {self._local_patterns} " + \
             f"local_msx_patterns: {self._local_msx_patterns} + seed: {self.__seed}"
 
-    def undo(self, epanet_api: epyt.epanet) -> None:
+    def undo(self, epanet_api: EPyT) -> None:
         """
         Undo all applied uncertainties -- i.e, resets the properties to their original value.
 
@@ -636,278 +635,303 @@ class ModelUncertainty(JsonSerializable):
 
         Parameters
         ----------
-        epanet_api : `epyt.epanet <https://epanet-python-toolkit-epyt.readthedocs.io/en/stable/api.html#epyt.epanet.epanet>`_
+        epanet_api : `epanet_plus.EPyT <https://epanet-plus.readthedocs.io/en/stable/api.html#epanet_plus.epanet_toolkit.EPyT>`_
             Interface to EPANET and EPANET-MSX
         """
         if self.__cache_original is False:
             raise ValueError("Caching was disabled by the user")
 
         if self._cache_links_length is not None:
-            epanet_api.setLinkLength(self._cache_links_length)
+            for link_idx, link_len in zip(epanet_api.get_all_links_idx(),
+                                          self._cache_links_length):
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_LENGTH, link_len)
 
         if self._cache_links_diameter is not None:
-            epanet_api.setLinkDiameter(self._cache_links_diameter)
+            for link_idx, link_diam in zip(epanet_api.get_all_links_idx(),
+                                           self._cache_links_diameter):
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_DIAMETER, link_diam)
 
         if self._cache_links_roughness_coeff is not None:
-            epanet_api.setLinkRoughnessCoeff(self._cache_links_roughness_coeff)
+            for link_idx, link_roughness in zip(epanet_api.get_all_links_idx(),
+                                                self._cache_links_roughness_coeff):
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_ROUGHNESS, link_roughness)
 
         if self._cache_nodes_base_demand is not None:
             for node_idx in self._cache_nodes_base_demand.keys():
                 for demand_category, base_demand in self._cache_nodes_base_demand[node_idx].items():
-                    epanet_api.setNodeBaseDemands(node_idx, demand_category + 1, base_demand)
+                    epanet_api.setbasedemand(node_idx, demand_category + 1, base_demand)
 
         if self._cache_nodes_demand_pattern is not None:
-            for pattern_id, demand_pattern in self._cache_nodes_demand_pattern.items():
-                for t, v in enumerate(demand_pattern):
-                    epanet_api.setPatternValue(pattern_id, t+1, v)
+            for pattern_idx, demand_pattern in self._cache_nodes_demand_pattern.items():
+                epanet_api.set_pattern(pattern_idx, demand_pattern.tolist())
 
         if self._cache_nodes_elevation is not None:
-            epanet_api.setNodeElevations(self._cache_nodes_elevation)
+            for node_idx, node_elev in zip(epanet_api.get_all_nodes_idx(),
+                                           self._cache_nodes_elevation):
+                epanet_api.setnodevalue(node_idx, EpanetConstants.EN_ELEVATION, node_elev)
 
         if self._cache_patterns is not None:
             for pattern_idx, pattern in self._cache_patterns.items():
-                epanet_api.setPattern(pattern_idx, pattern)
+                epanet_api.set_pattern(pattern_idx, pattern.tolist())
 
         if self._cache_msx_constants is not None:
-            epanet_api.setMSXConstantsValue(self._cache_msx_constants)
+            for constant_idx, constant_value in enumerate(self._cache_msx_constants):
+                epanet_api.MSXsetconstant(constant_idx + 1, constant_value)
 
         if self._cache_msx_links_parameters is not None:
             for pipe_idx, parameters_pipes_val in self._cache_msx_links_parameters.items():
-                epanet_api.setMSXParametersPipesValue(pipe_idx, parameters_pipes_val)
+                for param_idx, param_value in enumerate(parameters_pipes_val):
+                    epanet_api.MSXsetparameter(EpanetConstants.MSX_LINK, pipe_idx,
+                                               param_idx + 1, param_value)
 
         if self._cache_msx_tanks_parameters is not None:
             for tank_idx, parameters_tanks_val in self._cache_msx_tanks_parameters.items():
-                epanet_api.setMSXParametersTanksValue(tank_idx, parameters_tanks_val)
+                for param_idx, param_value in enumerate(parameters_tanks_val):
+                    epanet_api.MSXsetparameter(EpanetConstants.MSX_NODE, tank_idx,
+                                               param_idx + 1, param_value)
 
         if self._cache_msx_patterns is not None:
             for pattern_idx, pattern in self._cache_msx_patterns:
-                epanet_api.setMSXPattern(pattern_idx, pattern)
+                epanet_api.MSXsetpattern(pattern_idx, pattern.tolist(), len(pattern))
 
-    def apply(self, epanet_api: epyt.epanet) -> None:
+    def apply(self, epanet_api: EPyT) -> None:
         """
         Applies the specified model uncertainties to the scenario.
 
         Parameters
         ----------
-        epanet_api : `epyt.epanet <https://epanet-python-toolkit-epyt.readthedocs.io/en/stable/api.html#epyt.epanet.epanet>`_
+        epanet_api : `epanet_plus.EPyT <https://epanet-plus.readthedocs.io/en/stable/api.html#epanet_plus.epanet_toolkit.EPyT>`_
             Interface to EPANET and EPANET-MSX.
         """
         np_rand_gen = np.random.default_rng(seed=self.__seed)
 
+        all_links_idx = epanet_api.get_all_links_idx()
+        all_nodes_idx = epanet_api.get_all_nodes_idx()
+
         if self._global_pipe_length is not None:
             self._global_pipe_length.set_random_generator(np_rand_gen)
 
-            link_length = epanet_api.getLinkLength()
+            link_length = np.array([epanet_api.getlinkvalue(link_idx, EpanetConstants.EN_LENGTH)
+                                    for link_idx in all_links_idx])
             self._cache_links_length = np.copy(link_length)
 
             link_length = self._global_pipe_length.apply_batch(link_length)
-            epanet_api.setLinkLength(link_length)
+            for link_idx, link_value in zip(all_links_idx, link_length):
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_LENGTH, link_value)
 
         if self._local_pipe_length is not None:
             self._local_pipe_length.set_random_generator(np_rand_gen)
-            self._cache_links_length = epanet_api.getLinkLength()
+            self._cache_links_length = np.array([epanet_api.getlinkvalue(link_idx, EpanetConstants.EN_LENGTH)
+                                                 for link_idx in all_links_idx])
 
             for pipe_id, uncertainty in self._local_pipe_length.items():
-                link_idx = epanet_api.getLinkIndex(pipe_id)
-                link_length = epanet_api.getLinkLength(link_idx)
+                link_idx = epanet_api.get_link_idx(pipe_id)
+                link_length = epanet_api.getlinkvalue(link_idx, EpanetConstants.EN_LENGTH)
 
                 link_length = uncertainty.apply(link_length)
-                epanet_api.setLinkLength(link_idx, link_length)
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_LENGTH, link_length)
 
         if self._global_pipe_diameter is not None:
             self._global_pipe_diameter.set_random_generator(np_rand_gen)
 
-            link_diameters = epanet_api.getLinkDiameter()
+            link_diameters = np.array([epanet_api.getlinkvalue(link_idx, EpanetConstants.EN_DIAMETER)
+                                       for link_idx in all_links_idx])
             self._cache_links_diameter = np.copy(link_diameters)
 
             link_diameters = self._global_pipe_diameter.apply_batch(link_diameters)
-            epanet_api.setLinkDiameter(link_diameters)
+            for link_idx, link_value in zip(all_links_idx, link_diameters):
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_DIAMETER, link_value)
 
         if self._local_pipe_diameter is not None:
             self._local_pipe_diameter.set_random_generator(np_rand_gen)
-            self._cache_links_diameter = epanet_api.getLinkDiameter()
+            self._cache_links_diameter = np.array([epanet_api.getlinkvalue(link_idx,
+                                                                           EpanetConstants.EN_DIAMETER)
+                                                   for link_idx in all_links_idx])
 
             for pipe_id, uncertainty in self._local_pipe_diameter.items():
-                link_idx = epanet_api.getLinkIndex(pipe_id)
-                link_diameter = epanet_api.getLinkDiameter(link_idx)
+                link_idx = epanet_api.get_link_idx(pipe_id)
+                link_diameter = epanet_api.getlinkvalue(link_idx, EpanetConstants.EN_DIAMETER)
 
                 link_diameter = uncertainty.apply(link_diameter)
-                epanet_api.setLinkDiameter(link_idx, link_diameter)
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_DIAMETER, link_diameter)
 
         if self._global_pipe_roughness is not None:
             self._global_pipe_roughness.set_random_generator(np_rand_gen)
 
-            coeffs = epanet_api.getLinkRoughnessCoeff()
+            coeffs = np.array([epanet_api.getlinkvalue(link_idx, EpanetConstants.EN_ROUGHNESS)
+                               for link_idx in all_links_idx])
             self._cache_links_roughness_coeff = np.copy(coeffs)
 
             coeffs = self._global_pipe_roughness.apply_batch(coeffs)
-            epanet_api.setLinkRoughnessCoeff(coeffs)
+            for link_idx, link_value in zip(all_links_idx, coeffs):
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_ROUGHNESS, link_value)
 
         if self._local_pipe_roughness is not None:
             self._local_pipe_roughness.set_random_generator(np_rand_gen)
-            self._cache_links_roughness_coeff = epanet_api.getLinkRoughnessCoeff()
+            self._cache_links_roughness_coeff = \
+                np.array([epanet_api.getlinkvalue(link_idx, EpanetConstants.EN_ROUGHNESS)
+                          for link_idx in all_links_idx])
 
             for pipe_id, uncertainty in self._local_pipe_roughness.items():
-                link_idx = epanet_api.getLinkIndex(pipe_id)
-                link_roughness_coeff = epanet_api.getLinkRoughnessCoeff(link_idx)
+                link_idx = epanet_api.get_link_idx(pipe_id)
+                link_roughness_coeff = epanet_api.getlinkvalue(link_idx,
+                                                               EpanetConstants.EN_ROUGHNESS)
 
                 link_roughness_coeff = uncertainty.apply(link_roughness_coeff)
-                epanet_api.setLinkRoughnessCoeff(link_idx, link_roughness_coeff)
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_ROUGHNESS,
+                                        link_roughness_coeff)
 
         if self._global_base_demand is not None:
             self._global_base_demand.set_random_generator(np_rand_gen)
 
             self._cache_nodes_base_demand = {}
-            all_nodes_idx = epanet_api.getNodeIndex()
             for node_idx in all_nodes_idx:
                 self._cache_nodes_base_demand[node_idx] = {}
-                n_demand_categories = epanet_api.getNodeDemandCategoriesNumber(node_idx)
-                for demand_category in range(n_demand_categories):
-                    base_demand = epanet_api.getNodeBaseDemands(node_idx)[demand_category + 1]
-                    self._cache_nodes_base_demand[node_idx][demand_category] = base_demand
+                n_demand_categories = epanet_api.getnumdemands(node_idx)
+                for demand_idx in range(n_demand_categories):
+                    base_demand = epanet_api.getbasedemand(node_idx, demand_idx + 1)
+                    self._cache_nodes_base_demand[node_idx][demand_idx] = base_demand
 
                     base_demand = self._global_base_demand.apply(base_demand)
-                    epanet_api.setNodeBaseDemands(node_idx, demand_category + 1, base_demand)
+                    epanet_api.setbasedemand(node_idx, demand_idx + 1, base_demand)
 
         if self._local_base_demand is not None:
             self._local_base_demand.set_random_generator(np_rand_gen)
 
             self._cache_nodes_base_demand = {}
             for node_id, uncertainty in self._local_base_demand.items():
-                node_idx = epanet_api.getNodeIndex(node_id)
+                node_idx = epanet_api.get_node_idx(node_id)
                 self._cache_nodes_base_demand[node_idx] = {}
-                n_demand_categories = epanet_api.getNodeDemandCategoriesNumber(node_idx)
-                for demand_category in range(n_demand_categories):
-                    base_demand = epanet_api.getNodeBaseDemands(node_idx)[demand_category + 1]
-                    self._cache_nodes_base_demand[node_idx][demand_category] = base_demand
+                n_demand_categories = epanet_api.getnumdemands(node_idx)
+                for demand_idx in range(n_demand_categories):
+                    base_demand = epanet_api.getbasedemand(node_idx, demand_idx + 1)
+                    self._cache_nodes_base_demand[node_idx][demand_idx] = base_demand
 
                     base_demand = uncertainty.apply(base_demand)
-                    epanet_api.setNodeBaseDemands(node_idx, demand_category + 1, base_demand)
+                    epanet_api.setbasedemand(node_idx, demand_idx + 1, base_demand)
 
         if self._global_demand_pattern is not None:
             self._global_demand_pattern.set_random_generator(np_rand_gen)
 
             self._cache_nodes_demand_pattern = {}
-            demand_patterns_idx = epanet_api.getNodeDemandPatternIndex()
-            demand_patterns_id = np.unique([demand_patterns_idx[k]
-                                            for k in demand_patterns_idx.keys()])
-            for pattern_id in demand_patterns_id:
-                if pattern_id == 0:
-                    continue
-
-                pattern_length = epanet_api.getPatternLengths(pattern_id)
-                demand_pattern = np.zeros(pattern_length)
-
-                for t in range(pattern_length):
-                    v = epanet_api.getPatternValue(pattern_id, t+1)
-                    demand_pattern[t] = v
+            demand_patterns_idx = np.array([epanet_api.getdemandpattern(node_idx, demand_idx + 1)
+                                            for node_idx in epanet_api.get_all_nodes_idx()
+                                            for demand_idx in range(epanet_api.getnumdemands(node_idx))])
 
-                    v_ = self._global_demand_pattern.apply(v)
-                    epanet_api.setPatternValue(pattern_id, t+1, v_)
+            for pattern_idx in list(set(demand_patterns_idx)):
+                demand_pattern = np.array(epanet_api.get_pattern(pattern_idx))
+                self._cache_nodes_demand_pattern[pattern_idx] = np.copy(demand_pattern)
 
-                self._cache_nodes_demand_pattern[pattern_id] = demand_pattern
+                demand_pattern = self._global_demand_pattern.apply_batch(demand_pattern)
+                epanet_api.set_pattern(pattern_idx, demand_pattern.tolist())
 
         if self._local_demand_pattern is not None:
             self._local_demand_pattern.set_random_generator(np_rand_gen)
 
             self._cache_nodes_demand_pattern = {}
-            patterns_id = epanet_api.getPatternNameID()
-            paterns_idx = epanet_api.getPatternIndex()
 
             for pattern_id, uncertainty in self._local_demand_pattern.items():
-                pattern_idx = paterns_idx[patterns_id.index(pattern_id)]
-                pattern_length, = epanet_api.getPatternLengths(pattern_id)
-                demand_pattern = np.zeros(pattern_length)
-
-                for t in range(pattern_length):
-                    v = epanet_api.getPatternValue(pattern_idx, t+1)
-                    demand_pattern[t] = v
-
-                    v_ = uncertainty.apply(v)
-                    epanet_api.setPatternValue(pattern_idx, t+1, v_)
+                pattern_idx = epanet_api.getpatternindex(pattern_id)
+                demand_pattern = np.array(epanet_api.get_pattern(pattern_idx))
+                self._cache_nodes_demand_pattern[pattern_id] = np.copy(demand_pattern)
 
-                self._cache_nodes_demand_pattern[pattern_id] = demand_pattern
+                demand_pattern = uncertainty.apply_batch(demand_pattern)
+                epanet_api.set_pattern(pattern_idx, demand_pattern.tolist())
 
         if self._global_elevation is not None:
             self._global_elevation.set_random_generator(np_rand_gen)
 
-            elevations = epanet_api.getNodeElevations()
+            elevations = np.array([epanet_api.get_node_elevation(node_idx)
+                                   for node_idx in epanet_api.get_all_nodes_idx()])
             self._cache_nodes_elevation = np.copy(elevations)
 
             elevations = self._global_elevation.apply_batch(elevations)
-            epanet_api.setNodeElevations(elevations)
+            for node_idx, node_elev in enumerate(elevations):
+                epanet_api.setnodevalue(node_idx + 1, EpanetConstants.EN_ELEVATION, node_elev)
 
         if self._local_elevation is not None:
             self._local_elevation.set_random_generator(np_rand_gen)
-            self._cache_nodes_elevation = epanet_api.getNodeElevations()
+            self._cache_nodes_elevation = np.array([epanet_api.get_node_elevation(node_idx)
+                                                    for node_idx in epanet_api.get_all_nodes_idx()])
 
             for node_id, uncertainty in self._local_elevation.items():
-                node_idx = epanet_api.getNodeIndex(node_id)
-                elevation = epanet_api.getNodeElevations(node_idx)
+                node_idx = epanet_api.get_node_idx(node_id)
+                elevation = epanet_api.get_node_elevation(node_idx)
 
                 elevation = uncertainty.apply(elevation)
-                epanet_api.setNodeElevations(node_idx, elevation)
+                epanet_api.setnodevalue(node_idx, EpanetConstants.EN_ELEVATION, elevation)
 
         if self._local_patterns is not None:
             self._local_patterns.set_random_generator(np_rand_gen)
             self._cache_patterns = {}
 
             for pattern_id, uncertainty in self._local_patterns.items():
-                pattern_idx = epanet_api.getPatternIndex(pattern_id)
-                pattern_length = epanet_api.getPatternLengths(pattern_idx)
-                pattern = np.array([epanet_api.getPatternValue(pattern_idx, t+1)
-                                    for t in range(pattern_length)])
-                self._cache_patterns[pattern_idx] = pattern
+                pattern_idx = epanet_api.getpatternindex(pattern_id)
+                pattern = np.array(epanet_api.get_pattern(pattern_idx))
+                self._cache_patterns[pattern_idx] = np.copy(pattern)
 
                 pattern = uncertainty.apply_batch(pattern)
-                epanet_api.setPattern(pattern_idx, pattern)
+                epanet_api.set_pattern(pattern_idx, pattern.tolist())
 
-        if epanet_api.MSXFile is not None:
+        if epanet_api.msx_file is not None:
             if self._global_constants is not None:
                 self._global_constants.set_random_generator(np_rand_gen)
 
-                constants = np.array(epanet_api.getMSXConstantsValue())
+                constants = np.array([epanet_api.MSXgetconstant(const_idx + 1)
+                                      for const_idx in range(epanet_api.MSXgetcount(EpanetConstants.MSX_CONSTANT))])
                 self._cache_msx_patterns = np.copy(constants)
 
                 constants = self._global_constants.apply_batch(constants)
-                epanet_api.setMSXConstantsValue(constants)
+                for const_idx, const_value in enumerate(constants):
+                    epanet_api.MSXsetconstant(const_idx + 1, const_value)
 
             if self._local_constants:
                 self._local_constants.set_random_generator(np_rand_gen)
 
-                self._cache_msx_patterns = np.array(epanet_api.getMSXConstantsValue())
+                self._cache_msx_patterns = np.array([epanet_api.MSXgetconstant(const_idx + 1)
+                                                     for const_idx in range(epanet_api.MSXgetcount(EpanetConstants.MSX_CONSTANT))])
 
                 for constant_id, uncertainty in self._local_constants.items():
-                    idx = epanet_api.MSXgetindex(ToolkitConstants.MSX_CONSTANT, constant_id)
-                    constant = epanet_api.msx.MSXgetconstant(idx)
+                    idx = epanet_api.MSXgetindex(EpanetConstants.MSX_CONSTANT, constant_id)
+                    constant = epanet_api.MSXgetconstant(idx)
 
                     constant = uncertainty.apply(constant)
-                    epanet_api.msx.MSXsetconstant(idx, constant)
+                    epanet_api.MSXsetconstant(idx, constant)
 
             if self._global_parameters is not None:
                 self._global_parameters.set_random_generator(np_rand_gen)
 
                 self._cache_msx_links_parameters = {}
-                parameters_pipes = epanet_api.getMSXParametersPipesValue()
-                for i, pipe_idx in enumerate(epanet_api.getLinkPipeIndex()):
+                num_params = epanet_api.MSXgetcount(EpanetConstants.MSX_PARAMETER)
+                parameters_pipes = [np.array([epanet_api.MSXgetparameter(EpanetConstants.MSX_LINK,
+                                                                         pipe_idx,
+                                                                         param_idx + 1)
+                                              for param_idx in range(num_params)])
+                                     for pipe_idx in epanet_api.get_all_pipes_idx()]
+                for i, pipe_idx in enumerate(epanet_api.get_all_pipes_idx()):
                     if len(parameters_pipes[i]) == 0:
                         continue
 
-                    self._cache_msx_links_parameters[pipe_idx] = np.array(parameters_pipes[i])
-                    parameters_pipes_val = self._global_parameters.apply_batch(
-                        np.array(parameters_pipes[i]))
-                    epanet_api.setMSXParametersPipesValue(pipe_idx, parameters_pipes_val)
+                    self._cache_msx_links_parameters[pipe_idx] = parameters_pipes[i]
+                    parameters_pipes_val = self._global_parameters.apply_batch(parameters_pipes[i])
+                    for param_idx, param_value in enumerate(parameters_pipes_val):
+                        epanet_api.MSXsetparameter(EpanetConstants.MSX_LINK, pipe_idx,
+                                                   param_idx + 1, param_value)
 
                 self._cache_msx_tanks_parameters = {}
-                parameters_tanks = epanet_api.getMSXParametersTanksValue()
-                for i, tank_idx in enumerate(epanet_api.getNodeTankIndex()):
+                num_params = epanet_api.MSXgetcount(EpanetConstants.MSX_PARAMETER)
+                parameters_tanks = [np.array([epanet_api.MSXgetparameter(EpanetConstants.MSX_NODE,
+                                                                         tank_idx + 1, param_idx + 1)
+                                              for param_idx in range(num_params)])
+                                     for tank_idx in range(epanet_api.get_num_tanks())]
+                for i, tank_idx in enumerate(epanet_api.get_all_tanks_idx()):
                     if parameters_tanks[i] is None or len(parameters_tanks[i]) == 0:
                         continue
 
-                    self._cache_msx_tanks_parameters[tank_idx] = np.array(parameters_tanks[i])
-                    parameters_tanks_val = self._global_parameters.apply_batch(
-                        np.array(parameters_tanks[i]))
-                    epanet_api.setMSXParametersTanksValue(tank_idx, parameters_tanks_val)
+                    self._cache_msx_tanks_parameters[tank_idx] = parameters_tanks[i]
+                    parameters_tanks_val = self._global_parameters.apply_batch(parameters_tanks[i])
+                    for idx, val in enumerate(parameters_tanks_val):
+                        epanet_api.MSXsetparameter(EpanetConstants.MSX_NODE, tank_idx, idx + 1, val)
 
             if self._local_parameters is not None:
                 self._local_parameters.set_random_generator(np_rand_gen)
@@ -915,36 +939,36 @@ class ModelUncertainty(JsonSerializable):
                 self._cache_msx_tanks_parameters = {}
 
                 for (param_id, item_type, item_id), uncertainty in self._local_parameters.items():
-                    idx, = epanet_api.getMSXParametersIndex([param_id])
+                    idx, = epanet_api.MSXgetindex(EpanetConstants.MSX_PARAMETER, param_id)
 
-                    if item_type == ToolkitConstants.MSX_NODE:
-                        item_idx = epanet_api.getNodeIndex(item_id)
-                    elif item_type == ToolkitConstants.MSX_LINK:
-                        item_idx = epanet_api.getLinkIndex(item_id)
+                    if item_type == EpanetConstants.MSX_NODE:
+                        item_idx = epanet_api.get_node_idx(item_id)
+                    elif item_type == EpanetConstants.MSX_LINK:
+                        item_idx = epanet_api.get_link_idx(item_id)
                     else:
                         raise ValueError(f"Unknown item type '{item_type}' must be either " +
-                                         "ToolkitConstants.MSX_NODE or ToolkitConstants.MSX_LINK")
+                                         "EpanetConstants.MSX_NODE or EpanetConstants.MSX_LINK")
 
-                    parameter = epanet_api.msx.MSXgetparameter(item_type, item_idx, idx)
-                    if item_type == ToolkitConstants.MSX_NODE:
+                    parameter = epanet_api.MSXgetparameter(item_type, item_idx, idx)
+                    if item_type == EpanetConstants.MSX_NODE:
                         self._cache_msx_tanks_parameters[item_idx] = parameter
-                    elif item_type == ToolkitConstants.MSX_LINK:
+                    elif item_type == EpanetConstants.MSX_LINK:
                         self._cache_msx_links_parameters[item_idx] = parameter
 
                     parameter = uncertainty.apply(parameter)
-                    epanet_api.msx.MSXsetparameter(item_type, item_idx, idx, parameter)
+                    epanet_api.MSXsetparameter(item_type, item_idx, idx, parameter)
 
             if self._local_msx_patterns is not None:
                 self._local_msx_patterns.set_random_generator(np_rand_gen)
                 self._cache_msx_patterns = {}
 
                 for pattern_id, uncertainty in self._local_msx_patterns.items():
-                    pattern_idx, = epanet_api.getMSXPatternsIndex([pattern_id])
-                    pattern = epanet_api.getMSXConstantsValue([pattern_idx])
+                    pattern_idx = epanet_api.MSXgetindex(EpanetConstants.MSX_PATTERN, pattern_id)
+                    pattern = np.array(epanet_api.get_msx_pattern(pattern_idx))
                     self._cache_msx_patterns[pattern_idx] = np.copy(pattern)
 
                     pattern = uncertainty.apply_batch(pattern)
-                    epanet_api.setMSXPattern(pattern_idx, pattern)
+                    epanet_api.MSXsetpattern(pattern_idx, pattern.tolist(), len(pattern))
         else:
             if self._local_msx_patterns is not None or self._local_parameters is not None or \
                     self._local_constants is not None or self._global_constants is not None or \

{epyt_flow-0.14.2.dist-info → epyt_flow-0.15.0.dist-info}/METADATA

@@ -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.15.0.dist-info/RECORD

@@ -0,0 +1,65 @@
+epyt_flow/VERSION,sha256=-EBaczDChwKNRww-41Bvh48a2F7XnB0a3BnfL_c5iRU,7
+epyt_flow/__init__.py,sha256=mXQNlqjdqYKRiKCYnSCflFAJFEVlke7o-_ln6wZPAmY,154
+epyt_flow/serialization.py,sha256=uGGN1iZ21ek1u6Xzs4z2xum5Qt8554Wem-wEMGEaa7I,14574
+epyt_flow/topology.py,sha256=GKWugRj386E-uYMwLDPxZtg5KD27-nkQArSAZEYhde4,26571
+epyt_flow/utils.py,sha256=dCEx7FwgTmU8T-ajI-abbrLzJu8llhgn0QDewfTuqHk,20074
+epyt_flow/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+epyt_flow/data/networks.py,sha256=fZLv3yv_iDS23H-7KNMxNhCvfvrr9WdO7VNR5K3e94U,39842
+epyt_flow/data/benchmarks/__init__.py,sha256=nJ6hqPaPNp8YMizniev3fwOWpzvvNUBMoRF16wACUkE,754
+epyt_flow/data/benchmarks/batadal.py,sha256=E9kl0gI5HyL6LZ9ZoLZwdQBNHXKblWW1QV4E8ucr99s,11247
+epyt_flow/data/benchmarks/batadal_data.py,sha256=oIzcysGivMPAgrfzrk5l8i-j6Ii96DPcFa6sL4TSaw8,880
+epyt_flow/data/benchmarks/battledim.py,sha256=sVV8w4ESjybD__jrmKFhQxuBjtmLoBQmSmU2Wp-v76w,20790
+epyt_flow/data/benchmarks/battledim_data.py,sha256=0vHm-2eAiLv6U-n5dqUUWS1o_szFRy9mVJ3eqDRp4PE,3373
+epyt_flow/data/benchmarks/gecco_water_quality.py,sha256=xYN-xrcx409IhTJjvaMbZABORru3XQNnble76aAOKQ8,11414
+epyt_flow/data/benchmarks/leakdb.py,sha256=1EtGshPwnAGJFRrd9B8RqRCnABsCtAoG2kvg1Q0xxic,26894
+epyt_flow/data/benchmarks/leakdb_data.py,sha256=FNssgMkC1wqWVlaOrrihr4Od9trEZY7KeK5KuBeRMvM,507058
+epyt_flow/data/benchmarks/water_usage.py,sha256=RiLGLof1HT0luwn7_dG11_nP5U5r9B3L8vDLuwsIKTM,4962
+epyt_flow/gym/__init__.py,sha256=gDIP9VGjKraajsJo6MnPN-TaEUTLnnJNj2c_7jrb8Bg,36
+epyt_flow/gym/scenario_control_env.py,sha256=LIU1NJ6lnrPeIA2daNJ-runiSLiyMreGLCObe1j3bk4,13909
+epyt_flow/rest_api/__init__.py,sha256=4HilmXhdh6H56UHJBB2WUSULlEBUDnI1FPTP11ft3HE,126
+epyt_flow/rest_api/base_handler.py,sha256=HDLXrMXqgWvxWAsB-3G4plyTyCv27_eBbq4eRl_FeBo,2609
+epyt_flow/rest_api/res_manager.py,sha256=j6-3FUBZNLKM9bCsIDZzSytfDYJbDLRwjn1mIPstTqI,2342
+epyt_flow/rest_api/server.py,sha256=cPQM17rdbXLFlPRePb0Y7OcCyfJUN9SX7cv0etHtfvo,8727
+epyt_flow/rest_api/scada_data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+epyt_flow/rest_api/scada_data/data_handlers.py,sha256=VGw3uakxhFgqLMYRC5OaAuCbp0SnGxdPXWruUVEBiJc,11895
+epyt_flow/rest_api/scada_data/export_handlers.py,sha256=W-T2WgPuG8cNVzA8h3e0lwi-nSKFi11PPyuNQWTMwzg,4624
+epyt_flow/rest_api/scada_data/handlers.py,sha256=jcGw91TjjhRQm_hJvjbWvSTBLpvMJDOA4bQw5iOpSUw,7673
+epyt_flow/rest_api/scenario/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+epyt_flow/rest_api/scenario/control_handlers.py,sha256=ouxc54V_yJyoO2yPJEJqcPbZs7CXgM_CWKGj5RvkABQ,4585
+epyt_flow/rest_api/scenario/event_handlers.py,sha256=wgKWFHJPwF4celetSb-_jTlrcicoxDbC7GpZ9uw-BJY,8969
+epyt_flow/rest_api/scenario/handlers.py,sha256=v1V6gsBh2HLtPTnl9_53W13Awo5YjG681Urp24yXelY,14993
+epyt_flow/rest_api/scenario/simulation_handlers.py,sha256=A59Iv-6k7SlGF_RDQgoFlvHWM1mScvfCobXBW4Rhh6E,6511
+epyt_flow/rest_api/scenario/uncertainty_handlers.py,sha256=Pdo2YmiawOqKXWcLs2P-lv5qN-OKHS3sDgkAFQeRzK8,4568
+epyt_flow/simulation/__init__.py,sha256=nihvZ8O2rJjYQkv7JhtVMqNacO5bA38VtS8Y_0BWrVQ,129
+epyt_flow/simulation/parallel_simulation.py,sha256=ph4KXw9jCt-hiJFJbmC6fNvEsrbQoWV-tFKE5-qSfoQ,6523
+epyt_flow/simulation/scenario_config.py,sha256=uHHwwzCRwooVdODxDNoCOUgfrlol1K-TS8P8_Ja9Coc,30435
+epyt_flow/simulation/scenario_simulator.py,sha256=OIkEjPIFXg16kGXRngzMVJrSQpuyfrOcDvpkEYrhzII,165937
+epyt_flow/simulation/sensor_config.py,sha256=5_KNgPMP-z176KeX2KBtTxrqhd8hzVYMH3AJxpBIXp4,94363
+epyt_flow/simulation/events/__init__.py,sha256=gv8ZcvwjJN0Z5MwRXEOVFRNq4X5NPyyqXIQnhBxszQ0,215
+epyt_flow/simulation/events/actuator_events.py,sha256=-WP8n8WOWJOJm2oz78HiwCZMQsyJ5dGS9ZvaeCnesi8,8405
+epyt_flow/simulation/events/event.py,sha256=kARPV20XCAl6zxnJwI9U7ICtZUPACO_rgAmtHm1mGCs,2603
+epyt_flow/simulation/events/leakages.py,sha256=tBgxKJGLbjEQ7TOSMjzVGF20-Z5qZAY104MP0AEZaWs,18297
+epyt_flow/simulation/events/quality_events.py,sha256=LA9KUlO5hJ1OuneNMsZu4Wl26U6ZiGmz7oUpWXVyvI4,7854
+epyt_flow/simulation/events/sensor_faults.py,sha256=RFR8LjePkDEkCgENHEgCGT7iKYYtr_qq87-IIwN6ezg,8423
+epyt_flow/simulation/events/sensor_reading_attack.py,sha256=2E8q6yWnLxeLgYxW0MHw0GSjlUDjIIZ2GybVRLA7FJQ,7967
+epyt_flow/simulation/events/sensor_reading_event.py,sha256=OWMRWPsvgMgaynMayJ-hQotP9zV5sDIYrOfY0fOCuvc,7586
+epyt_flow/simulation/events/system_event.py,sha256=kyj6--D457vlbiVyg0M9yAXMs7GFHpcY8YZns3Aeo8c,2616
+epyt_flow/simulation/scada/__init__.py,sha256=pfJhg-tM5DaiZTXs0_1qJsY2R6Py_LwSz6BUFJexfQM,150
+epyt_flow/simulation/scada/complex_control.py,sha256=06c_cPUetOso2SNDWXS-uhfqYeWtb1Or0U5B4e3dZtA,22132
+epyt_flow/simulation/scada/custom_control.py,sha256=HNO5WmRhN9BtMEzC82DKreAym1SC6xdLhNQ-cSOfU2c,4758
+epyt_flow/simulation/scada/scada_data.py,sha256=ufaxv_1bFg2WCYQ8IQt1duQ7_fuGINiIL53HYzVa9hM,203288
+epyt_flow/simulation/scada/scada_data_export.py,sha256=WNAFn_WNfzYAEFbl2Al-cOIx-A0ozY4AI60-i_qEHdc,11643
+epyt_flow/simulation/scada/simple_control.py,sha256=BO9u7gUYdNlGqkWdY_DIiGUWpfQZrL2blx0W805GvIo,12600
+epyt_flow/uncertainty/__init__.py,sha256=ZRjuJL9rDpWVSdPwObPxFpEmMTcgAl3VmPOsS6cIyGg,89
+epyt_flow/uncertainty/model_uncertainty.py,sha256=cqK9XGWcVL6uA-xG_r6rbyJgFkKdtrHhS8YyRicQrG8,50858
+epyt_flow/uncertainty/sensor_noise.py,sha256=-AnBfuW1VAx7Ya-q_gJ9bAr7Kx6pzP_y0PvNeuRjXIg,6477
+epyt_flow/uncertainty/uncertainties.py,sha256=QBRbI3zIzkeFScyYD5Dy0TBxuL9jPV4SnVU8QwOrJq8,20495
+epyt_flow/uncertainty/utils.py,sha256=K-ZhyO6Bg7UmNPgpfND0JLa_wRwyrtUUgGTWyWwy-fo,8029
+epyt_flow/visualization/__init__.py,sha256=uQ7lO6AsgLc88X48Te3QhBQY-iDKGvdPtxKCl4b-Mfw,70
+epyt_flow/visualization/scenario_visualizer.py,sha256=vkP0J_OfjvePUz_HehXJkH4CGKR3chAHe_UTx4hQ6XI,57860
+epyt_flow/visualization/visualization_utils.py,sha256=-_Hs3FKQz--iVJ10ZeEv1Co9OSbayZmHjxyhKsnzalE,27629
+epyt_flow-0.15.0.dist-info/licenses/LICENSE,sha256=YRJC2kcAhMlpEeHwUF0lzE-GRXLFyAjXNErI8L5UwYk,1071
+epyt_flow-0.15.0.dist-info/METADATA,sha256=aRbELLILtji0kntYVXehD_dYmGGxGkkdKb4v16RJtww,9615
+epyt_flow-0.15.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+epyt_flow-0.15.0.dist-info/top_level.txt,sha256=Wh_kd7TRL8ownCw3Y3dxx-9C0iTSk6wNauv_NX9JcrY,10
+epyt_flow-0.15.0.dist-info/RECORD,,