epyt-flow 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

epyt_flow/topology.py

@@ -3,9 +3,12 @@ Module provides a class for representing the topology of WDN.
 """
 from copy import deepcopy
 import warnings
+from typing import Any
 import numpy as np
 import networkx as nx
 from scipy.sparse import bsr_array
+from geopandas import GeoDataFrame
+from shapely.geometry import Point, LineString
 
 from .serialization import serializable, JsonSerializable, NETWORK_TOPOLOGY_ID
 
@@ -14,6 +17,35 @@ UNITS_USCUSTOM = 0
 UNITS_SIMETRIC = 1
 
 
+def unitscategoryid_to_str(unit_category_id: int) -> str:
+    """
+    Converts a given units category ID to the corresponding description.
+
+    Parameters
+    ----------
+    unit_category_id : `int`
+        ID of the units category.
+
+        Must be one of the following constants:
+
+            - UNITS_USCUSTOM = 0
+            - UNITS_SIMETRIC = 1
+
+    Returns
+    -------
+    `str`
+        Units category description.
+    """
+    if unit_category_id is None:
+        return ""
+    elif unit_category_id == UNITS_USCUSTOM:
+        return "US CUSTOMARY"
+    elif unit_category_id == UNITS_SIMETRIC:
+        return "SI METRIC"
+    else:
+        raise ValueError(f"Unknown units category ID '{unit_category_id}'")
+
+
 @serializable(NETWORK_TOPOLOGY_ID, ".epytflow_topology")
 class NetworkTopology(nx.Graph, JsonSerializable):
     """
@@ -25,11 +57,17 @@ class NetworkTopology(nx.Graph, JsonSerializable):
         Path to .inp file to which this topology belongs.
     nodes : `list[tuple[str, dict]]`
         List of all nodes -- i.e. node ID and node information such as type and elevation.
-    links : `list[tuple[tuple[str, str], dict]]`
+    links : `list[tuple[str, tuple[str, str], dict]]`
         List of all links/pipes -- i.e. link ID, ID of connecting nodes, and link information
         such as pipe diameter, length, etc.
+    pumps : `dict`
+        List of all pumps -- i.e. valve ID, and information such as
+        pump type and connecting nodes.
+    valves : `dict`
+        List of all valves -- i.e. valve ID, and information such as
+        valve type and connecting nodes.
     units : `int`
-        Measurement units category.
+        Measurement units category -- i.e. US Customary or SI Metric.
 
         Must be one of the following constants:
 
@@ -38,12 +76,16 @@ class NetworkTopology(nx.Graph, JsonSerializable):
     """
     def __init__(self, f_inp: str, nodes: list[tuple[str, dict]],
                  links: list[tuple[str, tuple[str, str], dict]],
+                 pumps: dict,
+                 valves: dict,
                  units: int = None,
                  **kwds):
         super().__init__(name=f_inp, **kwds)
 
         self.__nodes = nodes
         self.__links = links
+        self.__pumps = pumps
+        self.__valves = valves
         self.__units = units
 
         if units is None:
@@ -57,11 +99,83 @@ class NetworkTopology(nx.Graph, JsonSerializable):
             self.add_node(node_id, info={"elevation": node_elevation, "type": node_type})
 
         for link_id, link, link_info in links:
+            link_type = link_info["type"]
             link_diameter = link_info["diameter"]
             link_length = link_info["length"]
             self.add_edge(link[0], link[1], length=link_length,
-                          info={"id": link_id, "nodes": link, "diameter": link_diameter,
-                                "length": link_length})
+                          info={"id": link_id, "type": link_type, "nodes": link,
+                                "diameter": link_diameter, "length": link_length})
+
+    def convert_units(self, units: int) -> Any:
+        """
+        Converts this instance to a :class:`epyt_flow.topology.NetworkTopology` instance
+        where everything is measured in given measurement units category
+        (US Customary or SI Metric).
+
+        Parameters
+        ----------
+        units : `int`
+            Measurement units category.
+
+            Must be one of the following constants:
+
+                - UNITS_USCUSTOM = 0  (US Customary)
+                - UNITS_SIMETRIC = 1  (SI Metric)
+
+        Returns
+        -------
+        :class:`epyt_flow.topology.NetworkTopology`
+            Network topology with the new measurements units.
+        """
+        if self.__units is None:
+            raise ValueError("This instance does not contain any units!")
+
+        if not isinstance(units, int):
+            raise TypeError(f"'units' must be an instance of 'int' but not of '{type(units)}'")
+        if units not in [UNITS_SIMETRIC, UNITS_USCUSTOM]:
+            raise ValueError(f"Invalid units '{units}'")
+
+        if units == self.__units:
+            warnings.warn("Units already set in this NetworkTopology instance -- nothing to do!")
+            return deepcopy(self)
+
+        # Get all data and convert units
+        inch_to_millimeter = 25.4
+        feet_to_meter = 0.3048
+
+        nodes = []
+        for node_id in self.get_all_nodes():
+            node_info = self.get_node_info(node_id)
+            if units == UNITS_USCUSTOM:
+                conv_factor = 1. / feet_to_meter
+            else:
+                conv_factor = feet_to_meter
+            node_info["elevation"] *= conv_factor
+            if "diameter" in node_info:
+                node_info["diameter"] *= conv_factor
+
+            nodes.append((node_id, node_info))
+
+        links = []
+        for link_id, link_nodes in self.get_all_links():
+            link_info = self.get_link_info(link_id)
+
+            if units == UNITS_USCUSTOM:
+                conv_factor = 1. / feet_to_meter
+            else:
+                conv_factor = feet_to_meter
+            link_info["length"] *= conv_factor
+
+            if units == UNITS_USCUSTOM:
+                conv_factor = 1. / inch_to_millimeter
+            else:
+                conv_factor = inch_to_millimeter
+            link_info["diameter"] *= conv_factor
+
+            links.append((link_id, link_nodes, link_info))
+
+        return NetworkTopology(f_inp=self.name, nodes=nodes, links=links, pumps=self.pumps,
+                               valves=self.valves, units=units)
 
     def get_all_nodes(self) -> list[str]:
         """
@@ -85,7 +199,29 @@ class NetworkTopology(nx.Graph, JsonSerializable):
         """
         return [(link_id, end_points) for link_id, end_points, _ in self.__links]
 
-    def get_node_info(self, node_id) -> dict:
+    def get_all_pumps(self) -> list[str]:
+        """
+        Gets the IDs of all pumps.
+
+        Returns
+        -------
+        `list[str]`
+            Pump IDs.
+        """
+        return self.__pumps.keys()
+
+    def get_all_valves(self) -> list[str]:
+        """
+        Gets the IDs of all valves.
+
+        Returns
+        -------
+        `list[str]`
+            Valve IDs.
+        """
+        return self.__valves.keys()
+
+    def get_node_info(self, node_id: str) -> dict:
         """
         Gets all information (e.g. elevation, type, etc.) associated with a given node.
 
@@ -105,19 +241,21 @@ class NetworkTopology(nx.Graph, JsonSerializable):
 
         raise ValueError(f"Unknown node '{node_id}'")
 
-    def get_link_info(self, link_id) -> dict:
+    def get_link_info(self, link_id: str) -> dict:
         """
-        Gets all information (e.g. diameter, length, etc.) associated with a given link/pipe.
+        Gets all information (e.g. diameter, length, etc.) associated with a given link.
+
+        Note that links can be pipes, pumps, or valves.
 
         Parameters
         ----------
         link_id : `str`
-            ID of the link/pipe.
+            ID of the link.
 
         Returns
         -------
         `dict`
-            Information associated with the given link/pipe.
+            Information associated with the given link.
         """
         for link_id_, link_nodes, link_info in self.__links:
             if link_id_ == link_id:
@@ -125,6 +263,68 @@ class NetworkTopology(nx.Graph, JsonSerializable):
 
         raise ValueError(f"Unknown link '{link_id}'")
 
+    def get_pump_info(self, pump_id: str) -> dict:
+        """
+        Gets all information associated with a given pump.
+
+        Parameters
+        ----------
+        pump_id : `str`
+            ID of the pump.
+
+        Returns
+        -------
+        `dict`
+            Pump information.
+        """
+        if pump_id in self.__pumps:
+            return self.__pumps[pump_id]
+        else:
+            raise ValueError(f"Unknown pump: '{pump_id}'")
+
+    def get_valve_info(self, valve_id: str) -> dict:
+        """
+        Gets all information associated with a given valve.
+
+        Parameters
+        ----------
+        valve_id : `str`
+            ID of the valve.
+
+        Returns
+        -------
+        `dict`
+            Valve information.
+        """
+        if valve_id in self.__valves:
+            return self.__valves[valve_id]
+        else:
+            raise ValueError(f"Unknown valve: '{valve_id}'")
+
+    @property
+    def pumps(self) -> dict:
+        """
+        Gets all pumps -- i.e. ID and associated information such as the pump type.
+
+        Returns
+        -------
+        `dict`
+            All pumps and their associated information.
+        """
+        return deepcopy(self.__pumps)
+
+    @property
+    def valves(self) -> dict:
+        """
+        Gets all valves -- i.e. ID and associated information such as the valve type.
+
+        Returns
+        -------
+        `dict`
+            All valves and their associated information.
+        """
+        return deepcopy(self.__valves)
+
     @property
     def units(self) -> int:
         """
@@ -151,18 +351,120 @@ class NetworkTopology(nx.Graph, JsonSerializable):
             self.get_all_nodes() == other.get_all_nodes() \
             and all(link_a[0] == link_b[0] and all(link_a[1] == link_b[1])
                     for link_a, link_b in zip(self.get_all_links(), other.get_all_links())) \
-            and self.__units == other.units
+            and self.__units == other.units \
+            and self.__pumps == other.pumps \
+            and self.__valves == other.valves
 
     def __str__(self) -> str:
         return f"f_inp: {self.name} nodes: {self.__nodes} links: {self.__links} " +\
-            f"units: {self.__units}"
+            f"pumps: {self.__pumps} valves: {self.__valves} " +\
+            f"units: {unitscategoryid_to_str(self.__units)}"
 
     def get_attributes(self) -> dict:
         return super().get_attributes() | {"f_inp": self.name,
                                            "nodes": self.__nodes,
                                            "links": self.__links,
+                                           "pumps": self.__pumps,
+                                           "valves": self.__valves,
                                            "units": self.__units}
 
+    def to_gis(self, coord_reference_system: str = None, pumps_as_points: bool = False,
+               valves_as_points: bool = False) -> dict:
+        """
+        Gets the network topology as a dictionary of `geopandas.GeoDataFrames` instances --
+        i.e. each quantity (nodes, links/pipes, valves, etc.) is represented by a
+        `geopandas.GeoDataFrames` instance.
+
+        Parameters
+        ----------
+        coord_reference_system : `str`, optional
+            Coordinate reference system.
+
+            The default is None.
+        pumps_as_points : `bool`, optional
+            If True, pumps are represented by points, otherwise by lines.
+
+            The default is False.
+
+        valves_as_points : `bool`, optional
+            If True, valves are represented by points, otherwise by lines.
+
+            The default is False.
+
+        Returns
+        -------
+        `dict`
+            Network topology as a dictionary of `geopandas.GeoDataFrames` instances.
+            If a quantity does not exist, the data frame will be None.
+        """
+        gis = {"nodes": None, "links": None,
+               "tanks": None, "reservoirs": None,
+               "valves": None, "pumps": None}
+
+        # Nodes
+        node_data = {"id": [], "type": [], "elevation": [], "geometry": []}
+        tank_data = {"id": [], "elevation": [], "diameter": [], "geometry": []}
+        reservoir_data = {"id": [], "elevation": [], "geometry": []}
+        for node_id in self.get_all_nodes():
+            node_info = self.get_node_info(node_id)
+
+            node_data["id"].append(node_id)
+            node_data["type"].append(node_info["type"])
+            node_data["elevation"].append(node_info["elevation"])
+            node_data["geometry"].append(Point(node_info["coord"]))
+
+            if node_info["type"] == "TANK":
+                tank_data["id"].append(node_id)
+                tank_data["elevation"].append(node_info["elevation"])
+                tank_data["diameter"].append(node_info["diameter"])
+                tank_data["geometry"].append(Point(node_info["coord"]))
+            elif node_info["type"] == "RESERVOIR":
+                reservoir_data["id"].append(node_id)
+                reservoir_data["elevation"].append(node_info["elevation"])
+                reservoir_data["geometry"].append(Point(node_info["coord"]))
+
+        gis["nodes"] = GeoDataFrame(node_data, crs=coord_reference_system)
+        gis["tanks"] = GeoDataFrame(tank_data, crs=coord_reference_system)
+        gis["reservoirs"] = GeoDataFrame(reservoir_data, crs=coord_reference_system)
+
+        # Links
+        pipe_data = {"id": [], "type": [], "end_point_a": [], "end_point_b": [],
+                     "length": [], "diameter": [], "geometry": []}
+        valve_data = {"id": [], "type": [], "geometry": []}
+        pump_data = {"id": [], "type": [], "geometry": []}
+        for link_id, link_nodes in self.get_all_links():
+            link_info = self.get_link_info(link_id)
+            end_points_coord = [self.get_node_info(n)["coord"] for n in link_nodes]
+
+            if link_info["type"] == "PIPE":
+                pipe_data["id"].append(link_id)
+                pipe_data["type"].append(link_info["type"])
+                pipe_data["end_point_a"].append(link_nodes[0])
+                pipe_data["end_point_b"].append(link_nodes[1])
+                pipe_data["length"].append(link_info["length"])
+                pipe_data["diameter"].append(link_info["diameter"])
+                pipe_data["geometry"].append(LineString(end_points_coord))
+            elif link_info["type"] == "PUMP":
+                pump_data["id"].append(link_id)
+                pump_data["type"].append(self.get_pump_info(link_id)["type"])
+                if pumps_as_points is True:
+                    pump_data["geometry"].append(Point(end_points_coord[0]))
+                else:
+                    pump_data["geometry"].append(LineString(end_points_coord))
+            else:   # Valve
+                valve_data["id"].append(link_id)
+                valve_data["type"].append(self.get_valve_info[link_id]["type"])
+                if valves_as_points is True:
+                    valve_data["geometry"].append(Point(end_points_coord[0]))
+                else:
+                    valve_data["geometry"].append(LineString(end_points_coord))
+
+        gis["pipes"] = GeoDataFrame(pipe_data, crs=coord_reference_system)
+        gis["valves"] = GeoDataFrame(valve_data, crs=coord_reference_system)
+        gis["pumps"] = GeoDataFrame(pump_data, crs=coord_reference_system)
+
+        return gis
+
     def get_adj_matrix(self) -> bsr_array:
         """
         Gets the adjacency matrix of this graph.

epyt_flow/uncertainty/model_uncertainty.py

@@ -2,6 +2,7 @@
 Module provides a class for implementing model uncertainty.
 """
 from copy import deepcopy
+import warnings
 import epyt
 import numpy as np
 
@@ -29,7 +30,7 @@ class ModelUncertainty(JsonSerializable):
         Uncertainty of pipe diameters. None, in the case of no uncertainty.
 
         The default is None.
-    demand_base_uncertainty : :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`, optional
+    base_demand_uncertainty : :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`, optional
         Uncertainty of base demands. None, in the case of no uncertainty.
 
         The default is None.
@@ -53,11 +54,17 @@ class ModelUncertainty(JsonSerializable):
     def __init__(self, pipe_length_uncertainty: Uncertainty = None,
                  pipe_roughness_uncertainty: Uncertainty = None,
                  pipe_diameter_uncertainty: Uncertainty = None,
-                 demand_base_uncertainty: Uncertainty = None,
+                 base_demand_uncertainty: Uncertainty = None,
                  demand_pattern_uncertainty: Uncertainty = None,
                  elevation_uncertainty: Uncertainty = None,
                  constants_uncertainty: Uncertainty = None,
-                 parameters_uncertainty: Uncertainty = None, **kwds):
+                 parameters_uncertainty: Uncertainty = None,
+                 demand_base_uncertainty: Uncertainty = None, **kwds):
+        if demand_base_uncertainty is not None:
+            warnings.warn("Loading a file that was created with an outdated version of EPyT-Flow" +
+                          " -- support of such old files will be removed in the next release!",
+                          DeprecationWarning)
+
         if pipe_length_uncertainty is not None:
             if not isinstance(pipe_length_uncertainty, Uncertainty):
                 raise TypeError("'pipe_length_uncertainty' must be an instance of " +
@@ -73,11 +80,11 @@ class ModelUncertainty(JsonSerializable):
                 raise TypeError("'pipe_diameter_uncertainty' must be an instance of " +
                                 "'epyt_flow.uncertainty.Uncertainty' but not of " +
                                 f"'{type(pipe_diameter_uncertainty)}'")
-        if demand_base_uncertainty is not None:
-            if not isinstance(demand_base_uncertainty, Uncertainty):
-                raise TypeError("'demand_base_uncertainty' must be an instance of " +
+        if base_demand_uncertainty is not None:
+            if not isinstance(base_demand_uncertainty, Uncertainty):
+                raise TypeError("'base_demand_uncertainty' must be an instance of " +
                                 "'epyt_flow.uncertainty.Uncertainty' but not of " +
-                                f"'{type(demand_base_uncertainty)}'")
+                                f"'{type(base_demand_uncertainty)}'")
         if demand_pattern_uncertainty is not None:
             if not isinstance(demand_pattern_uncertainty, Uncertainty):
                 raise TypeError("'demand_pattern_uncertainty' must be an instance of " +
@@ -102,7 +109,7 @@ class ModelUncertainty(JsonSerializable):
         self.__pipe_length = pipe_length_uncertainty
         self.__pipe_roughness = pipe_roughness_uncertainty
         self.__pipe_diameter = pipe_diameter_uncertainty
-        self.__demand_base = demand_base_uncertainty
+        self.__base_demand = base_demand_uncertainty
         self.__demand_pattern = demand_pattern_uncertainty
         self.__elevation = elevation_uncertainty
         self.__constants = constants_uncertainty
@@ -147,16 +154,16 @@ class ModelUncertainty(JsonSerializable):
         return deepcopy(self.__pipe_diameter)
 
     @property
-    def demand_base(self) -> Uncertainty:
+    def base_demand(self) -> Uncertainty:
         """
-        Gets the demand base uncertainty.
+        Gets the base demand uncertainty.
 
         Returns
         -------
         :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`
             Demand base uncertainty.
         """
-        return deepcopy(self.__demand_base)
+        return deepcopy(self.__base_demand)
 
     @property
     def demand_pattern(self) -> Uncertainty:
@@ -210,7 +217,7 @@ class ModelUncertainty(JsonSerializable):
         return super().get_attributes() | {"pipe_length_uncertainty": self.__pipe_length,
                                            "pipe_roughness_uncertainty": self.__pipe_roughness,
                                            "pipe_diameter_uncertainty": self.__pipe_diameter,
-                                           "demand_base_uncertainty": self.__demand_base,
+                                           "base_demand_uncertainty": self.__base_demand,
                                            "demand_pattern_uncertainty": self.__demand_pattern,
                                            "elevation_uncertainty": self.__elevation,
                                            "constants_uncertainty": self.__constants,
@@ -224,14 +231,14 @@ class ModelUncertainty(JsonSerializable):
         return self.__pipe_length == other.pipe_length \
             and self.__pipe_roughness == other.pipe_roughness \
             and self.__pipe_diameter == other.pipe_diameter \
-            and self.__demand_base == other.demand_base \
+            and self.__base_demand == other.base_demand \
             and self.__demand_pattern == other.demand_pattern \
             and self.__elevation == other.elevation \
             and self.__parameters == other.parameters and self.__constants == other.constants
 
     def __str__(self) -> str:
         return f"pipe_length: {self.__pipe_length} pipe_roughness: {self.__pipe_roughness} " + \
-            f"pipe_diameter: {self.__pipe_diameter} demand_base: {self.__demand_base} " + \
+            f"pipe_diameter: {self.__pipe_diameter} demand_base: {self.__base_demand} " + \
             f"demand_pattern: {self.__demand_pattern} elevation: {self.__elevation} " + \
             f"constants: {self.__constants} parameters: {self.__parameters}"
 
@@ -259,14 +266,14 @@ class ModelUncertainty(JsonSerializable):
             coeffs = self.__pipe_roughness.apply_batch(coeffs)
             epanet_api.setLinkRoughnessCoeff(coeffs)
 
-        if self.__demand_base is not None:
+        if self.__base_demand is not None:
             all_nodes_idx = epanet_api.getNodeIndex()
             for node_idx in all_nodes_idx:
                 n_demand_categories = epanet_api.getNodeDemandCategoriesNumber(node_idx)
-                for demand_category in range(1, n_demand_categories):
-                    base_demand = epanet_api.getNodeBaseDemands(node_idx)[demand_category]
-                    base_demand = self.__demand_base.apply(base_demand)
-                    epanet_api.setNodeBaseDemands(node_idx, demand_category, base_demand)
+                for demand_category in range(n_demand_categories):
+                    base_demand = epanet_api.getNodeBaseDemands(node_idx)[demand_category + 1]
+                    base_demand = self.__base_demand.apply(base_demand)
+                    epanet_api.setNodeBaseDemands(node_idx, demand_category + 1, base_demand)
 
         if self.__demand_pattern is not None:
             demand_patterns_idx = epanet_api.getNodeDemandPatternIndex()

epyt_flow/utils.py

@@ -214,8 +214,8 @@ def plot_timeseries_prediction(y: np.ndarray, y_pred: np.ndarray,
                         y_pred - confidence_interval[0],
                         y_pred + confidence_interval[1],
                         alpha=0.5)
-    ax.plot(y_pred, ".-", label="Prediction")
     ax.plot(y, ".-", label="Ground truth")
+    ax.plot(y_pred, ".-", label="Prediction")
     ax.legend()
 
     if show is True and fig is not None:

{epyt_flow-0.2.0.dist-info → epyt_flow-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: epyt-flow
-Version: 0.2.0
+Version: 0.4.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: MIT License
@@ -30,10 +30,12 @@ Requires-Dist: tqdm >=4.66.2
 Requires-Dist: openpyxl >=3.1.2
 Requires-Dist: falcon >=3.1.3
 Requires-Dist: multiprocess >=0.70.16
+Requires-Dist: geopandas >=0.14.4
 Requires-Dist: psutil
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![pypi](https://img.shields.io/pypi/v/epyt-flow.svg)](https://pypi.org/project/epyt-flow/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/epyt-flow)
 [![build](https://github.com/WaterFutures/EPyT-Flow/actions/workflows/build_tests.yml/badge.svg)](https://github.com/WaterFutures/EPyT-Flow/actions/workflows/build_tests.yml)
 [![Documentation Status](https://readthedocs.org/projects/epyt-flow/badge/?version=stable)](https://epyt-flow.readthedocs.io/en/stable/?badge=stable)
 [![Downloads](https://static.pepy.tech/badge/epyt-flow)](https://pepy.tech/project/epyt-flow)
@@ -41,6 +43,8 @@ Requires-Dist: psutil
 
 # EPyT-Flow -- EPANET Python Toolkit - Flow
 
+<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) 
 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.
@@ -50,8 +54,6 @@ and [EPANET-MSX](https://github.com/USEPA/EPANETMSX/).
 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.
 
-![](https://github.com/WaterFutures/EPyT-Flow/blob/main/docs/_static/net1_plot.png?raw=true)
-
 
 ## Unique Features
 
@@ -74,8 +76,18 @@ Unique features of EPyT-Flow that make it superior to other (Python) toolboxes a
 EPyT-Flow supports Python 3.9 - 3.12
 
 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 Linux system. By this we not only aim to achieve
-a better performance of the simulations but also avoid any compatibility problems of pre-compiled 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 12) 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@12
+```
 
 ### PyPI