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

epyt_flow/simulation/sensor_config.py

@@ -3,8 +3,10 @@ Module provides a class for implementing sensor configurations.
 """
 from copy import deepcopy
 import warnings
+import itertools
 import numpy as np
 import epyt
+from epyt.epanet import ToolkitConstants
 
 from ..serialization import SENSOR_CONFIG_ID, JsonSerializable, serializable
 
@@ -70,7 +72,7 @@ def massunit_to_id(unit_desc: str) -> int:
             "MMOL": MASS_UNIT_MMOL}[unit_desc]
 
 
-def qualityunits_to_id(unit_desc: str) -> int:
+def qualityunit_to_id(unit_desc: str) -> int:
     """
     Converts a given measurement unit description to the corresponding mass unit ID.
 
@@ -87,8 +89,8 @@ def qualityunits_to_id(unit_desc: str) -> int:
         Will be either None (if no water quality analysis was set up) or
         one of the following constants:
 
-            - MASS_UNIT_MG = 4   (mg/L)
-            - MASS_UNIT_UG = 5   (ug/L)
+            - MASS_UNIT_MG  = 4   (mg/L)
+            - MASS_UNIT_UG  = 5   (ug/L)
             - TIME_UNIT_HRS = 8  (hrs)
     """
     if unit_desc == "mg/L":
@@ -101,19 +103,107 @@ def qualityunits_to_id(unit_desc: str) -> int:
         return None
 
 
-def qualityunits_to_str(unit_id: int) -> str:
+def massunit_to_str(unit_id: int) -> str:
     """
-    Converts a given measurement unit ID to the corresponding description.
+    Converts a given mass unit ID to the corresponding description.
 
     Parameters
     ----------
     unit_id : `int`
-        ID of the mass unit.
+        ID of the flow unit.
+
+        Must be one of the following constant:
+
+            - MASS_UNIT_MG   = 4
+            - MASS_UNIT_UG   = 5
+            - MASS_UNIT_MOL  = 6
+            - MASS_UNIT_MMOL = 7
+
+    Returns
+    -------
+    `str`
+        Mass unit description.
+    """
+    if unit_id is None:
+        return ""
+    elif unit_id == MASS_UNIT_MG:
+        return "MG"
+    elif unit_id == MASS_UNIT_UG:
+        return "UG"
+    elif unit_id == MASS_UNIT_MOL:
+        return "MOL"
+    elif unit_id == MASS_UNIT_MMOL:
+        return "MMOL"
+    else:
+        raise ValueError(f"Unknown mass unit ID '{unit_id}'")
+
+
+def flowunit_to_str(unit_id: int) -> str:
+    """
+    Converts a given flow unit ID to the corresponding description.
+
+    Parameters
+    ----------
+    unit_id : `int`
+        ID of the flow unit.
+
+        Must be one of the following EPANET toolkit constants:
+
+            - EN_CFS  = 0 (cubic foot/sec)
+            - EN_GPM  = 1 (gal/min)
+            - EN_MGD  = 2 (Million gal/day)
+            - EN_IMGD = 3 (Imperial MGD)
+            - EN_AFD  = 4 (ac-foot/day)
+            - EN_LPS  = 5 (liter/sec)
+            - EN_LPM  = 6 (liter/min)
+            - EN_MLD  = 7 (Megaliter/day)
+            - EN_CMH  = 8 (cubic meter/hr)
+            - EN_CMD  = 9 (cubic meter/day)
+
+    Returns
+    -------
+    `str`
+        Flow unit description.
+    """
+    if unit_id is None:
+        return ""
+    elif unit_id == ToolkitConstants.EN_CFS:
+        return "cubic foot/sec"
+    elif unit_id == ToolkitConstants.EN_GPM:
+        return "gal/min"
+    elif unit_id == ToolkitConstants.EN_MGD:
+        return "Million gal/day"
+    elif unit_id == ToolkitConstants.EN_IMGD:
+        return "Imperial MGD"
+    elif unit_id == ToolkitConstants.EN_AFD:
+        return "ac-foot/day"
+    elif unit_id == ToolkitConstants.EN_LPS:
+        return "liter/sec"
+    elif unit_id == ToolkitConstants.EN_LPM:
+        return "liter/min"
+    elif unit_id == ToolkitConstants.EN_MLD:
+        return "Megaliter/day"
+    elif unit_id == ToolkitConstants.EN_CMH:
+        return "cubic meter/hr"
+    elif unit_id == ToolkitConstants.EN_CMD:
+        return "cubic meter/day"
+    else:
+        raise ValueError(f"Unknown unit ID '{unit_id}'")
+
+
+def qualityunit_to_str(unit_id: int) -> str:
+    """
+    Converts a given quality measurement unit ID to the corresponding description.
+
+    Parameters
+    ----------
+    unit_id : `int`
+        ID of the quality unit.
 
         Must be one of the following constants:
 
-            - MASS_UNIT_MG = 4  (mg/L)
-            - MASS_UNIT_UG = 5  (ug/L)
+            - MASS_UNIT_MG  = 4  (mg/L)
+            - MASS_UNIT_UG  = 5  (ug/L)
             - TIME_UNIT_HRS = 8  (hrs)
 
     Returns
@@ -121,7 +211,9 @@ def qualityunits_to_str(unit_id: int) -> str:
     `str`
         Mass unit description.
     """
-    if unit_id == MASS_UNIT_MG:
+    if unit_id is None:
+        return ""
+    elif unit_id == MASS_UNIT_MG:
         return "mg/L"
     elif unit_id == MASS_UNIT_UG:
         return "ug/L"
@@ -131,6 +223,69 @@ def qualityunits_to_str(unit_id: int) -> str:
         raise ValueError(f"Unknown unit ID '{unit_id}'")
 
 
+def areaunit_to_str(unit_id: int) -> str:
+    """
+    Converts a given area measurement unit ID to the corresponding description.
+
+    Parameters
+    ----------
+    unit_id : `int`
+        ID of the area unit.
+
+        Must be one of the following constants:
+
+            - AREA_UNIT_FT2 = 1
+            - AREA_UNIT_M2  = 2
+            - AREA_UNIT_CM2 = 3
+
+    Returns
+    -------
+    `str`
+        Area unit description.
+    """
+    if unit_id is None:
+        return None
+    elif unit_id == AREA_UNIT_FT2:
+        return "FT2"
+    elif unit_id == AREA_UNIT_M2:
+        return "M2"
+    elif unit_id == AREA_UNIT_CM2:
+        return "CM2"
+    else:
+        raise ValueError(f"Unknown unit ID '{unit_id}'")
+
+
+def is_flowunit_simetric(unit_id: int) -> bool:
+    """
+    Checks if a given flow unit belongs to SI metric units.
+
+    Parameters
+    ----------
+    unit_id : `int`
+        ID of the flow unit.
+
+        Must be one of the following EPANET toolkit constants:
+
+            - EN_CFS  = 0 (cubic foot/sec)
+            - EN_GPM  = 1 (gal/min)
+            - EN_MGD  = 2 (Million gal/day)
+            - EN_IMGD = 3 (Imperial MGD)
+            - EN_AFD  = 4 (ac-foot/day)
+            - EN_LPS  = 5 (liter/sec)
+            - EN_LPM  = 6 (liter/min)
+            - EN_MLD  = 7 (Megaliter/day)
+            - EN_CMH  = 8 (cubic meter/hr)
+            - EN_CMD  = 9 (cubic meter/day)
+
+    Returns
+    -------
+    `bool`
+        True if the fiven unit is a SI metric unit, False otherwise.
+    """
+    return unit_id in [ToolkitConstants.EN_LPM, ToolkitConstants.EN_MLD,
+                       ToolkitConstants.EN_CMH, ToolkitConstants.EN_CMD]
+
+
 @serializable(SENSOR_CONFIG_ID, ".epytflow_sensor_config")
 class SensorConfig(JsonSerializable):
     """
@@ -247,7 +402,7 @@ class SensorConfig(JsonSerializable):
 
         Must be one of the following EPANET toolkit constants:
 
-            - EN_CFS = 0 (cu foot/sec)
+            - EN_CFS = 0 (cubic foot/sec)
             - EN_GPM = 1 (gal/min)
             - EN_MGD = 2 (Million gal/day)
             - EN_IMGD = 3 (Imperial MGD)
@@ -430,7 +585,8 @@ class SensorConfig(JsonSerializable):
         if any(bulk_species_id not in bulk_species
                for bulk_species_id in bulk_species_node_sensors.keys()):
             raise ValueError("Unknown bulk species ID in 'bulk_species_node_sensors'")
-        if any(node_id not in nodes for node_id in bulk_species_node_sensors.values()):
+        if any(node_id not in nodes for node_id in list(itertools.chain(
+                *bulk_species_node_sensors.values()))):
             raise ValueError("Unknown node ID in 'bulk_species_node_sensors'")
 
         if not isinstance(bulk_species_link_sensors, dict):
@@ -439,7 +595,8 @@ class SensorConfig(JsonSerializable):
         if any(bulk_species_id not in bulk_species
                for bulk_species_id in bulk_species_link_sensors.keys()):
             raise ValueError("Unknown bulk species ID in 'bulk_species_link_sensors'")
-        if any(link_id not in links for link_id in bulk_species_link_sensors.values()):
+        if any(link_id not in links for link_id in list(itertools.chain(
+                *bulk_species_link_sensors.values()))):
             raise ValueError("Unknown link/pipe ID in 'bulk_species_link_sensors'")
 
         if not isinstance(surface_species_sensors, dict):
@@ -448,7 +605,8 @@ class SensorConfig(JsonSerializable):
         if any(surface_species_id not in surface_species_sensors
                for surface_species_id in surface_species_sensors.keys()):
             raise ValueError("Unknown surface species ID in 'surface_species_sensors'")
-        if any(link_id not in links for link_id in surface_species_sensors.values()):
+        if any(link_id not in links for link_id in list(itertools.chain(
+                *surface_species_sensors.values()))):
             raise ValueError("Unknown link ID in 'surface_species_sensors'")
 
         if node_id_to_idx is not None:
@@ -585,7 +743,7 @@ class SensorConfig(JsonSerializable):
 
         Parameters
         ----------
-        sensor_config : :class:`epyt_flow.simulation.sensor_config.SensorConfig`
+        sensor_config : :class:`~epyt_flow.simulation.sensor_config.SensorConfig`
             Sensor configuration used as a basis.
 
         Returns
@@ -604,9 +762,128 @@ class SensorConfig(JsonSerializable):
                             surface_species=sensor_config.surface_species,
                             bulk_species_mass_unit=sensor_config.bulk_species_mass_unit,
                             surface_species_mass_unit=sensor_config.surface_species_mass_unit,
-                            surface_species_area_unit=sensor_config.surface_species_area_unit)
+                            surface_species_area_unit=sensor_config.surface_species_area_unit,
+                            node_id_to_idx=sensor_config.node_id_to_idx,
+                            link_id_to_idx=sensor_config.link_id_to_idx,
+                            valve_id_to_idx=sensor_config.valve_id_to_idx,
+                            pump_id_to_idx=sensor_config.pump_id_to_idx,
+                            tank_id_to_idx=sensor_config.tank_id_to_idx,
+                            bulkspecies_id_to_idx=sensor_config.bulkspecies_id_to_idx,
+                            surfacespecies_id_to_idx=sensor_config.surfacespecies_id_to_idx)
+
+    @property
+    def node_id_to_idx(self) -> dict:
+        """
+        Mapping of a surface node ID to the EPANET index
+        (i.e. position in the raw sensor reading data).
+
+        If None, it is assumed that the nodes (in 'nodes') are
+        sorted according to their EPANET index.
+
+        Returns
+        -------
+        `dict`
+            Node ID to index mapping.
+        """
+        return self.__node_id_to_idx
+
+    @property
+    def link_id_to_idx(self) -> dict:
+        """
+        Mapping of a link/pipe ID to the EPANET index
+        (i.e. position in the raw sensor reading data).
+
+        If None is given, it is assumed that the links/pipes (in 'links') are
+        sorted according to their EPANET index.
+
+        Returns
+        -------
+        `dict`
+            Link/Pipe ID to index mapping.
+        """
+        return self.__link_id_to_idx
+
+    @property
+    def valve_id_to_idx(self) -> dict:
+        """
+        Mapping of a valve ID to the EPANET index
+        (i.e. position in the raw sensor reading data).
+
+        If None, it is assumed that the valves (in 'valves') are
+        sorted according to their EPANET index.
+
+        Returns
+        -------
+        `dict`
+            Valve ID to index mapping.
+        """
+        return self.__valve_id_to_idx
+
+    @property
+    def pump_id_to_idx(self) -> dict:
+        """
+        Mapping of a pump ID to the EPANET index
+        (i.e. position in the raw sensor reading data).
+
+        If None, it is assumed that the pumps (in 'pumps') are
+        sorted according to their EPANET index.
+
+        Returns
+        -------
+        `dict`
+            Pump ID to index mapping.
+        """
+        return self.__pump_id_to_idx
+
+    @property
+    def tank_id_to_idx(self) -> dict:
+        """
+        Mapping of a tank ID to the EPANET index
+        (i.e. position in the raw sensor reading data).
+
+        If None, it is assumed that the tanks (in 'tanks') are
+        sorted according to their EPANET index.
+
+        Returns
+        -------
+        `dict`
+            Tank ID to index mapping.
+        """
+        return self.__tank_id_to_idx
+
+    @property
+    def bulkspecies_id_to_idx(self) -> dict:
+        """
+        Mapping of a bulk species ID to the EPANET index
+        (i.e. position in the raw sensor reading data).
+
+        If None, it is assumed that the bulk species (in 'bulk_species') are
+        sorted according to their EPANET index.
+
+        Returns
+        -------
+        `dict`
+            Bulk species ID to index mapping.
+        """
+        return self.__bulkspecies_id_to_idx
+
+    @property
+    def surfacespecies_id_to_idx(self) -> dict:
+        """
+        Mapping of a surface species ID to the EPANET index
+        (i.e. position in the raw sensor reading data).
+
+        If None, it is assumed that the surface species (in 'surface_species') are
+        sorted according to their EPANET index.
+
+        Returns
+        -------
+        `dict`
+            Surface species ID to index mapping.
+        """
+        return self.__surfacespecies_id_to_idx
 
-    def node_id_to_idx(self, node_id: str) -> int:
+    def map_node_id_to_idx(self, node_id: str) -> int:
         """
         Gets the index of a given node ID.
 
@@ -625,7 +902,7 @@ class SensorConfig(JsonSerializable):
         else:
             return self.__nodes.index(node_id)
 
-    def link_id_to_idx(self, link_id: str) -> int:
+    def map_link_id_to_idx(self, link_id: str) -> int:
         """
         Gets the index of a given link ID.
 
@@ -644,7 +921,7 @@ class SensorConfig(JsonSerializable):
         else:
             return self.__links.index(link_id)
 
-    def valve_id_to_idx(self, valve_id: str) -> int:
+    def map_valve_id_to_idx(self, valve_id: str) -> int:
         """
         Gets the index of a given valve ID.
 
@@ -663,7 +940,7 @@ class SensorConfig(JsonSerializable):
         else:
             return self.__valves.index(valve_id)
 
-    def pump_id_to_idx(self, pump_id: str) -> int:
+    def map_pump_id_to_idx(self, pump_id: str) -> int:
         """
         Gets the index of a given pump ID.
 
@@ -682,7 +959,7 @@ class SensorConfig(JsonSerializable):
         else:
             return self.__pumps.index(pump_id)
 
-    def tank_id_to_idx(self, tank_id: str) -> int:
+    def map_tank_id_to_idx(self, tank_id: str) -> int:
         """
         Gets the index of a given tank ID.
 
@@ -701,7 +978,7 @@ class SensorConfig(JsonSerializable):
         else:
             return self.__tanks.index(tank_id)
 
-    def bulkspecies_id_to_idx(self, bulk_species_id: str) -> int:
+    def map_bulkspecies_id_to_idx(self, bulk_species_id: str) -> int:
         """
         Gets the index of a given bulk species ID.
 
@@ -720,7 +997,7 @@ class SensorConfig(JsonSerializable):
         else:
             return self.__bulk_species.index(bulk_species_id)
 
-    def surfacespecies_id_to_idx(self, surface_species_id: str) -> int:
+    def map_surfacespecies_id_to_idx(self, surface_species_id: str) -> int:
         """
         Gets the index of a given surface species ID.
 
@@ -740,35 +1017,35 @@ class SensorConfig(JsonSerializable):
             return self.__surface_species.index(surface_species_id)
 
     def __compute_indices(self):
-        self.__pressure_idx = np.array([self.node_id_to_idx(n)
+        self.__pressure_idx = np.array([self.map_node_id_to_idx(n)
                                         for n in self.__pressure_sensors], dtype=np.int32)
-        self.__flow_idx = np.array([self.link_id_to_idx(link)
+        self.__flow_idx = np.array([self.map_link_id_to_idx(link)
                                     for link in self.__flow_sensors], dtype=np.int32)
-        self.__demand_idx = np.array([self.node_id_to_idx(n)
+        self.__demand_idx = np.array([self.map_node_id_to_idx(n)
                                       for n in self.__demand_sensors], dtype=np.int32)
-        self.__quality_node_idx = np.array([self.node_id_to_idx(n)
+        self.__quality_node_idx = np.array([self.map_node_id_to_idx(n)
                                             for n in self.__quality_node_sensors], dtype=np.int32)
-        self.__quality_link_idx = np.array([self.link_id_to_idx(link)
+        self.__quality_link_idx = np.array([self.map_link_id_to_idx(link)
                                             for link in self.__quality_link_sensors],
                                            dtype=np.int32)
-        self.__valve_state_idx = np.array([self.valve_id_to_idx(v)
+        self.__valve_state_idx = np.array([self.map_valve_id_to_idx(v)
                                            for v in self.__valve_state_sensors], dtype=np.int32)
-        self.__pump_state_idx = np.array([self.pump_id_to_idx(p)
+        self.__pump_state_idx = np.array([self.map_pump_id_to_idx(p)
                                           for p in self.__pump_state_sensors], dtype=np.int32)
-        self.__tank_volume_idx = np.array([self.tank_id_to_idx(t)
+        self.__tank_volume_idx = np.array([self.map_tank_id_to_idx(t)
                                            for t in self.__tank_volume_sensors], dtype=np.int32)
-        self.__bulk_species_node_idx = np.array([(self.bulkspecies_id_to_idx(s),
-                                                  [self.node_id_to_idx(node_id)
+        self.__bulk_species_node_idx = np.array([(self.map_bulkspecies_id_to_idx(s),
+                                                  [self.map_node_id_to_idx(node_id)
                                                 for node_id in self.__bulk_species_node_sensors[s]])
                                                 for s in self.__bulk_species_node_sensors.keys()],
                                                 dtype=object)
-        self.__bulk_species_link_idx = np.array([(self.bulkspecies_id_to_idx(s),
-                                                  [self.link_id_to_idx(link_id)
+        self.__bulk_species_link_idx = np.array([(self.map_bulkspecies_id_to_idx(s),
+                                                  [self.map_link_id_to_idx(link_id)
                                                 for link_id in self.__bulk_species_link_sensors[s]])
                                                 for s in self.__bulk_species_link_sensors.keys()],
                                                 dtype=object)
-        self.__surface_species_idx = np.array([(self.surfacespecies_id_to_idx(s),
-                                                [self.link_id_to_idx(link_id)
+        self.__surface_species_idx = np.array([(self.map_surfacespecies_id_to_idx(s),
+                                                [self.map_link_id_to_idx(link_id)
                                                  for link_id in self.__surface_species_sensors[s]])
                                                for s in self.__surface_species_sensors.keys()],
                                               dtype=object)
@@ -781,8 +1058,10 @@ class SensorConfig(JsonSerializable):
         n_valve_state_sensors = len(self.__valve_state_sensors)
         n_pump_state_sensors = len(self.__pump_state_sensors)
         n_tank_volume_sensors = len(self.__tank_volume_sensors)
-        n_bulk_species_node_sensors = len(self.__bulk_species_node_sensors.values())
-        n_bulk_species_link_sensors = len(self.__bulk_species_link_sensors.values())
+        n_bulk_species_node_sensors = len(list(itertools.chain(
+            *self.__bulk_species_node_sensors.values())))
+        n_bulk_species_link_sensors = len(list(itertools.chain(
+            *self.__bulk_species_link_sensors.values())))
 
         pressure_idx_shift = 0
         flow_idx_shift = pressure_idx_shift + n_pressure_sensors
@@ -956,7 +1235,7 @@ class SensorConfig(JsonSerializable):
 
         Will be one of the following EPANET toolkit constants:
 
-            - EN_CFS = 0 (cu foot/sec)
+            - EN_CFS = 0 (cubic foot/sec)
             - EN_GPM = 1 (gal/min)
             - EN_MGD = 2 (Million gal/day)
             - EN_IMGD = 3 (Imperial MGD)
@@ -1319,7 +1598,8 @@ class SensorConfig(JsonSerializable):
                             f"but not of '{type(bulk_species_sensors)}'")
         if any(species_id not in self.__bulk_species for species_id in bulk_species_sensors.keys()):
             raise ValueError("Unknown bulk species ID in 'bulk_species_sensors'")
-        if any(link_id not in self.__links for link_id in sum(bulk_species_sensors.values(), [])):
+        if any(link_id not in self.__links for link_id in list(itertools.chain(
+                *bulk_species_sensors.values()))):
             raise ValueError("Unknown link/pipe ID in 'bulk_species_sensors'")
 
         self.__bulk_species_link_sensors = bulk_species_sensors
@@ -1348,7 +1628,7 @@ class SensorConfig(JsonSerializable):
                for species_id in surface_species_sensors.keys()):
             raise ValueError("Unknown surface species ID in 'surface_species_sensors'")
         if any(link_id not in self.__links
-               for link_id in sum(surface_species_sensors.values(), [])):
+               for link_id in list(itertools.chain(*surface_species_sensors.values()))):
             raise ValueError("Unknown link/pipe ID in 'surface_species_sensors'")
 
         self.__surface_species_sensors = surface_species_sensors
@@ -1422,12 +1702,24 @@ class SensorConfig(JsonSerializable):
             and self.__quality_unit == other.quality_unit \
             and self.__bulk_species_mass_unit == other.bulk_species_mass_unit \
             and self.__surface_species_mass_unit == other.surface_species_mass_unit \
-            and self.__surface_species_area_unit == other.surface_species_area_unit
+            and self.__surface_species_area_unit == other.surface_species_area_unit \
+            and self.__node_id_to_idx == other.node_id_to_idx \
+            and self.__link_id_to_idx == other.link_id_to_idx \
+            and self.__valve_id_to_idx == other.valve_id_to_idx \
+            and self.__pump_id_to_idx == other.pump_id_to_idx \
+            and self.__tank_id_to_idx == other.tank_id_to_idx \
+            and self.__bulkspecies_id_to_idx == other.bulkspecies_id_to_idx \
+            and self.__surfacespecies_id_to_idx == other.surfacespecies_id_to_idx
 
     def __str__(self) -> str:
         return f"nodes: {self.__nodes} links: {self.__links} valves: {self.__valves} " +\
             f"pumps: {self.__pumps} tanks: {self.__tanks} bulk_species: {self.__bulk_species} " +\
-            f"surface_species: {self.__surface_species}" + \
+            f"surface_species: {self.__surface_species} " + \
+            f"node_id_to_idx: {self.__node_id_to_idx} link_id_to_idx: {self.__link_id_to_idx} " +\
+            f"pump_id_to_idx: {self.__pump_id_to_idx} tank_id_to_idx: {self.__tank_id_to_idx} " +\
+            f"valve_id_to_idx: {self.__valve_id_to_idx} " +\
+            f"bulkspecies_id_to_idx: {self.__bulkspecies_id_to_idx} " +\
+            f"surfacespecies_id_to_idx: {self.__surfacespecies_id_to_idx}" +\
             f"pressure_sensors: {self.__pressure_sensors} flow_sensors: {self.__flow_sensors} " +\
             f"demand_sensors: {self.__demand_sensors} " +\
             f"quality_node_sensors: {self.__quality_node_sensors} " +\
@@ -1438,10 +1730,13 @@ class SensorConfig(JsonSerializable):
             f"bulk_species_node_sensors: {self.__bulk_species_node_sensors} " +\
             f"bulk_species_link_sensors: {self.__bulk_species_link_sensors} " +\
             f"surface_species_sensors: {self.__surface_species_sensors} " +\
-            f"flow_unit: {self.__flow_unit} quality_unit: {self.__quality_unit}" +\
-            f"bulk_species_mass_unit: {self.__bulk_species_mass_unit} " +\
-            f"surface_species_mass_unit: {self.__surface_species_mass_unit} " +\
-            f"surface_species_area_unit: {self.__surface_species_area_unit}"
+            f"flow_unit: {flowunit_to_str(self.__flow_unit)} " +\
+            f"quality_unit: {qualityunit_to_str(self.__quality_unit)} " +\
+            "bulk_species_mass_unit: " +\
+            f"{list(map(massunit_to_str, self.__bulk_species_mass_unit))} " +\
+            "surface_species_mass_unit: " +\
+            f"{list(map(massunit_to_str, self.__surface_species_mass_unit))} " +\
+            f"surface_species_area_unit: {areaunit_to_str(self.__surface_species_area_unit)}"
 
     def compute_readings(self, pressures: np.ndarray, flows: np.ndarray, demands: np.ndarray,
                          nodes_quality: np.ndarray, links_quality: np.ndarray,