epyt-flow 0.1.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

epyt_flow/simulation/sensor_config.py

@@ -2,8 +2,11 @@
 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
 
@@ -20,6 +23,268 @@ SENSOR_TYPE_NODE_BULK_SPECIES = 9
 SENSOR_TYPE_LINK_BULK_SPECIES = 10
 SENSOR_TYPE_SURFACE_SPECIES   = 11
 
+AREA_UNIT_FT2 = 1
+AREA_UNIT_M2 = 2
+AREA_UNIT_CM2 = 3
+MASS_UNIT_MG = 4
+MASS_UNIT_UG = 5
+MASS_UNIT_MOL = 6
+MASS_UNIT_MMOL = 7
+TIME_UNIT_HRS = 8
+
+
+def areaunit_to_id(unit_desc: str) -> int:
+    """
+    Converts a given area units string to the corresponding ID.
+
+    Parameters
+    ----------
+    unit_desc : `str`
+        Area units string.
+
+    Returns
+    -------
+    `int`
+        Corresponding area unit ID.
+    """
+    return {"FT2": AREA_UNIT_FT2,
+            "M2": AREA_UNIT_M2,
+            "CM2": AREA_UNIT_CM2}[unit_desc]
+
+
+def massunit_to_id(unit_desc: str) -> int:
+    """
+    Converts a given mass units string to the corresponding ID.
+
+    Parameters
+    ----------
+    unit_desc : `str`
+        Mass units string.
+
+    Returns
+    -------
+    `int`
+        Corresponding mass unit ID.
+    """
+    return {"MG": MASS_UNIT_MG,
+            "UG": MASS_UNIT_UG,
+            "MOL": MASS_UNIT_MOL,
+            "MMOL": MASS_UNIT_MMOL}[unit_desc]
+
+
+def qualityunit_to_id(unit_desc: str) -> int:
+    """
+    Converts a given measurement unit description to the corresponding mass unit ID.
+
+    Parameters
+    ----------
+    unit_desc : `str`
+        Mass unit.
+
+    Returns
+    -------
+    `int`
+        Mass unit ID.
+
+        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)
+            - TIME_UNIT_HRS = 8  (hrs)
+    """
+    if unit_desc == "mg/L":
+        return MASS_UNIT_MG
+    elif unit_desc == "ug/L":
+        return MASS_UNIT_UG
+    elif unit_desc == "hrs":
+        return TIME_UNIT_HRS
+    else:
+        return None
+
+
+def massunit_to_str(unit_id: int) -> str:
+    """
+    Converts a given mass unit ID to the corresponding description.
+
+    Parameters
+    ----------
+    unit_id : `int`
+        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)
+            - TIME_UNIT_HRS = 8  (hrs)
+
+    Returns
+    -------
+    `str`
+        Mass unit description.
+    """
+    if unit_id is None:
+        return ""
+    elif unit_id == MASS_UNIT_MG:
+        return "mg/L"
+    elif unit_id == MASS_UNIT_UG:
+        return "ug/L"
+    elif unit_id == TIME_UNIT_HRS:
+        return "hrs"
+    else:
+        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):
@@ -39,7 +304,7 @@ class SensorConfig(JsonSerializable):
     tanks : `list[str]`
         List of all tanks (i.e. IDs) in the network.
     species : `list[str]`
-        List of all (EPANET-MSX) species (i.e. IDs) in the network    
+        List of all (EPANET-MSX) species (i.e. IDs) in the network
     pressure_sensors : `list[str]`, optional
         List of all nodes (i.e. IDs) at which a pressure sensor is placed.
 
@@ -131,9 +396,65 @@ class SensorConfig(JsonSerializable):
         sorted according to their EPANET index.
 
         The default is None.
+    flow_unit : `int`
+        Specifies the flow units and consequently all other hydraulic units
+        (US CUSTOMARY or SI METRIC) as well.
+
+        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)
+    quality_unit : `str`, optional
+        Measurement unit (in a basic quality analysis) -- only relevant
+        if basic water quality is enabled.
+
+        Must be one of the following constants:
+
+            - MASS_UNIT_MG = 4     (mg/L)
+            - MASS_UNIT_UG = 5     (ug/L)
+            - TIME_UNIT_HRS = 8    (hrs)
+
+    bulk_species_mass_unit : `list[int]`, optional
+        Specifies the mass unit for each bulk species -- only relevant if EPANET-MSX is used.
+
+        Must be one of the following constants:
+
+            - MASS_UNIT_MG = 4      (milligram)
+            - MASS_UNIT_UG = 5      (microgram)
+            - MASS_UNIT_MOL = 6     (mole)
+            - MASS_UNIT_MMOL = 7    (millimole)
+
+        Note that the assumed ordering is the same as given in 'bulk_species'.
+    surface_species_mass_unit : `list[int]`, optional
+        Specifies the mass unit for each surface species -- only relevant if EPANET-MSX is used.
+
+        Must be one of the following constants:
+
+            - MASS_UNIT_MG = 4      (milligram)
+            - MASS_UNIT_UG = 5      (microgram)
+            - MASS_UNIT_MOL = 6     (mole)
+            - MASS_UNIT_MMOL = 7    (millimole)
+
+        Note that the assumed ordering is the same as given in 'surface_species'.
+    surface_species_area_unit : `int`, optional
+        Species the area unit of all surface species -- only relevant if EPANET-MSX is used.
+        Must be one of the following constants:
+
+            - AREA_UNIT_FT2 = 1     (square feet)
+            - AREA_UNIT_M2 = 2      (square meters)
+            - AREA_UNIT_CM2 = 3     (square centimeters)
     """
     def __init__(self, nodes: list[str], links: list[str], valves: list[str], pumps: list[str],
                  tanks: list[str], bulk_species: list[str], surface_species: list[str],
+                 flow_unit: int = None,
                  pressure_sensors: list[str] = [],
                  flow_sensors: list[str] = [],
                  demand_sensors: list[str] = [],
@@ -148,7 +469,12 @@ class SensorConfig(JsonSerializable):
                  node_id_to_idx: dict = None, link_id_to_idx: dict = None,
                  valve_id_to_idx: dict = None, pump_id_to_idx: dict = None,
                  tank_id_to_idx: dict = None, bulkspecies_id_to_idx: dict = None,
-                 surfacespecies_id_to_idx: dict = None, **kwds):
+                 surfacespecies_id_to_idx: dict = None,
+                 quality_unit: int = None,
+                 bulk_species_mass_unit : list[int] = [],
+                 surface_species_mass_unit : list[int] = [],
+                 surface_species_area_unit : int = None,
+                 **kwds):
         if not isinstance(nodes, list):
             raise TypeError("'nodes' must be an instance of 'list[str]' " +
                             f"but not of '{type(nodes)}'")
@@ -259,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):
@@ -268,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):
@@ -277,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:
@@ -329,6 +658,48 @@ class SensorConfig(JsonSerializable):
             if any(s not in surface_species for s in surfacespecies_id_to_idx.keys()):
                 raise ValueError("Unknown surface species ID in 'surfacespecies_id_to_idx'")
 
+        if flow_unit is not None:
+            if not isinstance(flow_unit, int):
+                raise TypeError("'flow_unit' must be a an instance of 'int' " +
+                                f"but not of '{type(flow_unit)}'")
+            if flow_unit not in range(10):
+                raise ValueError("Invalid value of 'flow_unit'")
+        else:
+            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 quality_unit is not None:
+            if not isinstance(quality_unit, int):
+                raise TypeError("'quality_mass_unit' must be an instance of 'int' " +
+                                f"but not of '{type(quality_unit)}'")
+            if quality_unit not in [MASS_UNIT_MG, MASS_UNIT_UG, TIME_UNIT_HRS]:
+                raise ValueError("Invalid value of 'quality_unit'")
+
+        if len(bulk_species_mass_unit) != len(bulk_species):
+            raise ValueError("Inconsistency between 'bulk_species_mass_unit' and 'bulk_species'")
+        if any(not isinstance(mass_unit, int) for mass_unit in bulk_species_mass_unit):
+            raise TypeError("All items in 'bulk_species_mass_unit' must be an instance of 'int'")
+        if any(mass_unit not in [MASS_UNIT_MG, MASS_UNIT_UG, MASS_UNIT_MOL, MASS_UNIT_MMOL]
+               for mass_unit in bulk_species_mass_unit):
+            raise ValueError("Invalid mass unit in 'bulk_species_mass_unit'")
+
+        if len(surface_species_mass_unit) != len(surface_species):
+            raise ValueError("Inconsistency between 'surface_species_mass_unit' " +
+                             "and 'surface_species'")
+        if any(not isinstance(mass_unit, int) for mass_unit in surface_species_mass_unit):
+            raise TypeError("All items in 'surface_species_mass_unit' must be an instance of 'int'")
+        if any(mass_unit not in [MASS_UNIT_MG, MASS_UNIT_UG, MASS_UNIT_MOL, MASS_UNIT_MMOL]
+               for mass_unit in surface_species_mass_unit):
+            raise ValueError("Invalid mass unit in 'surface_species_mass_unit'")
+
+        if surface_species_area_unit is not None:
+            if not isinstance(surface_species_area_unit, int):
+                raise TypeError("'surface_species_area_unit' must be a an instance of 'int' " +
+                                f"but not of '{type(surface_species_area_unit)}'")
+            if surface_species_area_unit not in [AREA_UNIT_FT2, AREA_UNIT_M2, AREA_UNIT_CM2]:
+                raise ValueError("Invalid area unit 'surface_species_area_unit'")
+
         self.__nodes = nodes
         self.__links = links
         self.__valves = valves
@@ -354,12 +725,165 @@ class SensorConfig(JsonSerializable):
         self.__tank_id_to_idx = tank_id_to_idx
         self.__bulkspecies_id_to_idx = bulkspecies_id_to_idx
         self.__surfacespecies_id_to_idx = surfacespecies_id_to_idx
+        self.__flow_unit = flow_unit
+        self.__quality_unit = quality_unit
+        self.__bulk_species_mass_unit = bulk_species_mass_unit
+        self.__surface_species_mass_unit = surface_species_mass_unit
+        self.__surface_species_area_unit = surface_species_area_unit
 
         self.__compute_indices()    # Compute indices
 
         super().__init__(**kwds)
 
-    def node_id_to_idx(self, node_id: str) -> int:
+    @staticmethod
+    def create_empty_sensor_config(sensor_config):
+        """
+        Creates an empty sensor configuration from a given sensor configuration
+        -- i.e. a clone of the given sensor configuration except that no sensors are set.
+
+        Parameters
+        ----------
+        sensor_config : :class:`~epyt_flow.simulation.sensor_config.SensorConfig`
+            Sensor configuration used as a basis.
+
+        Returns
+        -------
+        :class:`epyt_flow.simulation.sensor_config.SensorConfig`
+            Empty sensor configuration.
+        """
+        return SensorConfig(nodes=sensor_config.nodes,
+                            links=sensor_config.links,
+                            valves=sensor_config.valves,
+                            pumps=sensor_config.pumps,
+                            tanks=sensor_config.tanks,
+                            flow_unit=sensor_config.flow_unit,
+                            quality_unit=sensor_config.quality_unit,
+                            bulk_species=sensor_config.bulk_species,
+                            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,
+                            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 map_node_id_to_idx(self, node_id: str) -> int:
         """
         Gets the index of a given node ID.
 
@@ -378,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.
 
@@ -397,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.
 
@@ -416,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.
 
@@ -435,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.
 
@@ -454,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.
 
@@ -473,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.
 
@@ -493,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)
@@ -534,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
@@ -701,6 +1227,50 @@ class SensorConfig(JsonSerializable):
         """
         return self.__tanks.copy()
 
+    @property
+    def flow_unit(self) -> int:
+        """
+        Gets the flow units.
+        Note that this specifies all other hydraulic units as well.
+
+        Will 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
+        -------
+        `int`
+            Flow unit ID.
+        """
+        return self.__flow_unit
+
+    @property
+    def quality_unit(self) -> int:
+        """
+        Gets the measurement unit ID used in the basic quality analysis.
+
+        Will be one of the following constants:
+
+            - MASS_UNIT_MG = 4      (milligram)
+            - MASS_UNIT_UG = 5      (microgram)
+            - TIME_UNIT_HRS = 6     (hours)
+
+        Returns
+        -------
+        `int`
+            Mass unit ID.
+        """
+        return self.__quality_unit
+
     @property
     def bulk_species(self) -> list[str]:
         """
@@ -725,6 +1295,62 @@ class SensorConfig(JsonSerializable):
         """
         return self.__surface_species.copy()
 
+    @property
+    def bulk_species_mass_unit(self) -> list[int]:
+        """
+        Gets the mass unit of each bulk species.
+
+        Will be one of the following constants:
+
+            - MASS_UNIT_MG = 4      (milligram)
+            - MASS_UNIT_UG = 5      (microgram)
+            - MASS_UNIT_MOL = 6     (mole)
+            - MASS_UNIT_MMOL = 7    (millimole)
+
+        Returns
+        -------
+        `int`
+            Mass unit ID.
+        """
+        return self.__bulk_species_mass_unit
+
+    @property
+    def surface_species_mass_unit(self) -> list[int]:
+        """
+        Gets the mass unit of each surface species.
+
+        Will be one of the following constants:
+
+            - MASS_UNIT_MG = 4      (milligram)
+            - MASS_UNIT_UG = 5      (microgram)
+            - MASS_UNIT_MOL = 6     (mole)
+            - MASS_UNIT_MMOL = 7    (millimole)
+
+        Returns
+        -------
+        `int`
+            Mass unit ID.
+        """
+        return self.__surface_species_mass_unit
+
+    @property
+    def surface_species_area_unit(self) -> int:
+        """
+        Gets the surface species area unit.
+
+        Will be one of the following constants:
+
+            - AREA_UNIT_FT2 = 1     (square feet)
+            - AREA_UNIT_M2 = 2      (square meters)
+            - AREA_UNIT_CM2 = 3     (square centimeters)
+
+        Returns
+        -------
+        `int`
+            Area unit ID.
+        """
+        return self.__surface_species_area_unit
+
     @property
     def pressure_sensors(self) -> list[str]:
         """
@@ -972,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
@@ -1001,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
@@ -1042,7 +1669,12 @@ class SensorConfig(JsonSerializable):
                 "pump_id_to_idx": self.__pump_id_to_idx,
                 "tank_id_to_idx": self.__tank_id_to_idx,
                 "bulkspecies_id_to_idx": self.__bulkspecies_id_to_idx,
-                "surfacespecies_id_to_idx": self.__surfacespecies_id_to_idx}
+                "surfacespecies_id_to_idx": self.__surfacespecies_id_to_idx,
+                "flow_unit": self.__flow_unit,
+                "quality_unit": self.__quality_unit,
+                "bulk_species_mass_unit": self.__bulk_species_mass_unit,
+                "surface_species_mass_unit": self.__surface_species_mass_unit,
+                "surface_species_area_unit": self.__surface_species_area_unit}
 
         return super().get_attributes() | attr
 
@@ -1065,22 +1697,46 @@ class SensorConfig(JsonSerializable):
             and self.__tank_volume_sensors == other.tank_volume_sensors \
             and self.__bulk_species_node_sensors == other.bulk_species_node_sensors \
             and self.__bulk_species_link_sensors == other.bulk_species_link_sensors \
-            and self.__surface_species_sensors == other.surface_species_sensors
+            and self.__surface_species_sensors == other.surface_species_sensors \
+            and self.__flow_unit == other.flow_unit \
+            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.__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} " +\
             f"quality_link_sensors: {self.__quality_link_sensors} " +\
             f"valve_state_sensors: {self.__valve_state_sensors} " +\
             f"pump_state_sensors: {self.__pump_state_sensors} " +\
-            f"tank_volume_sensors: {self.__tank_volume_sensors}" +\
-            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"tank_volume_sensors: {self.__tank_volume_sensors} " +\
+            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: {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,