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

epyt_flow/simulation/scada/scada_data.py

@@ -10,7 +10,8 @@ import matplotlib
 import pandas as pd
 from epanet_plus import EpanetConstants
 
-from ..sensor_config import SensorConfig, is_flowunit_simetric, massunit_to_str, flowunit_to_str,\
+from ..sensor_config import SensorConfig, valid_sensor_types, \
+    is_flowunit_simetric, massunit_to_str, flowunit_to_str,\
     qualityunit_to_str, areaunit_to_str,\
     MASS_UNIT_MG, MASS_UNIT_UG, TIME_UNIT_HRS, MASS_UNIT_MOL, MASS_UNIT_MMOL, \
     AREA_UNIT_CM2, AREA_UNIT_FT2, AREA_UNIT_M2, \
@@ -22,7 +23,7 @@ from ..sensor_config import SensorConfig, is_flowunit_simetric, massunit_to_str,
 from ..events import SensorFault, SensorReadingAttack, SensorReadingEvent
 from ...uncertainty import SensorNoise
 from ...serialization import serializable, Serializable, SCADA_DATA_ID
-from ...topology import NetworkTopology
+from ...topology import NetworkTopology, UNITS_USCUSTOM, UNITS_SIMETRIC
 from ...utils import plot_timeseries_data
 
 
@@ -1056,7 +1057,15 @@ class ScadaData(Serializable):
                                      surface_species_mass_unit=new_surface_species_mass_unit,
                                      surface_species_area_unit=new_surface_species_area_unit)
 
-        return ScadaData(network_topo=self.network_topo,
+        if flow_unit is not None:
+            if is_flowunit_simetric(flow_unit):
+                network_topo = self.network_topo.convert_units(UNITS_SIMETRIC)
+            else:
+                network_topo = self.network_topo.convert_units(UNITS_USCUSTOM)
+        else:
+            network_topo = self.network_topo
+
+        return ScadaData(network_topo=network_topo,
                          warnings_code=self.warnings_code,
                          sensor_config=sensor_config,
                          sensor_readings_time=self.sensor_readings_time,
@@ -2141,33 +2150,52 @@ class ScadaData(Serializable):
         else:
             data = []
 
-            if self.__pressure_data_raw is not None:
-                data.append(self.__pressure_data_raw)
-            if self.__flow_data_raw is not None:
-                data.append(self.__flow_data_raw)
-            if self.__demand_data_raw is not None:
-                data.append(self.__demand_data_raw)
-            if self.__node_quality_data_raw is not None:
-                data.append(self.__node_quality_data_raw)
-            if self.__link_quality_data_raw is not None:
-                data.append(self.__link_quality_data_raw)
-            if self.__valves_state_data_raw is not None:
-                data.append(self.__valves_state_data_raw)
-            if self.__pumps_state_data_raw is not None:
-                data.append(self.__pumps_state_data_raw)
-            if self.__pumps_efficiency_data_raw is not None:
-                data.append(self.__pumps_efficiency_data_raw)
-            if self.__pumps_energy_usage_data_raw is not None:
-                data.append(self.__pumps_energy_usage_data_raw)
-            if self.__tanks_volume_data_raw is not None:
-                data.append(self.__tanks_volume_data_raw)
-            if self.__surface_species_concentration_raw is not None:
-                data.append(self.__surface_species_concentration_raw)
-            if self.__bulk_species_node_concentration_raw is not None:
-                data.append(self.__bulk_species_node_concentration_raw)
-            if self.__bulk_species_link_concentration_raw is not None:
-                data.append(self.__bulk_species_link_concentration_raw)
-
+            for sensor_type in self.__sensor_config.sensor_ordering:
+                if sensor_type==SENSOR_TYPE_NODE_PRESSURE \
+                        and self.__pressure_data_raw is not None:
+                    data.append(self.__pressure_data_raw)
+                elif sensor_type==SENSOR_TYPE_NODE_QUALITY \
+                        and self.__node_quality_data_raw is not None:
+                    data.append(self.__node_quality_data_raw)
+                elif sensor_type==SENSOR_TYPE_NODE_DEMAND \
+                        and self.__demand_data_raw is not None:
+                    data.append(self.__demand_data_raw)
+                elif sensor_type==SENSOR_TYPE_LINK_FLOW \
+                        and self.__flow_data_raw is not None:
+                    data.append(self.__flow_data_raw)
+                elif sensor_type==SENSOR_TYPE_LINK_QUALITY \
+                        and self.__link_quality_data_raw is not None:
+                    data.append(self.__link_quality_data_raw)
+                elif sensor_type==SENSOR_TYPE_VALVE_STATE \
+                        and self.__valves_state_data_raw is not None:
+                    data.append(self.__valves_state_data_raw)
+                elif sensor_type==SENSOR_TYPE_PUMP_STATE \
+                        and self.__pumps_state_data_raw is not None:
+                    data.append(self.__pumps_state_data_raw)
+                elif sensor_type==SENSOR_TYPE_TANK_VOLUME \
+                        and self.__tanks_volume_data_raw is not None:
+                    data.append(self.__tanks_volume_data_raw)
+                elif sensor_type==SENSOR_TYPE_NODE_BULK_SPECIES \
+                        and self.__bulk_species_node_concentration_raw is not None:
+                    data.append(self.__bulk_species_node_concentration_raw)
+                elif sensor_type==SENSOR_TYPE_LINK_BULK_SPECIES \
+                        and self.__bulk_species_link_concentration_raw is not None:
+                    data.append(self.__bulk_species_link_concentration_raw)
+                elif sensor_type==SENSOR_TYPE_SURFACE_SPECIES \
+                        and self.__surface_species_concentration_raw is not None:
+                    data.append(self.__surface_species_concentration_raw)
+                elif sensor_type==SENSOR_TYPE_PUMP_EFFICIENCY \
+                        and self.__pumps_efficiency_data_raw is not None:
+                    data.append(self.__pumps_efficiency_data_raw)
+                elif sensor_type==SENSOR_TYPE_PUMP_ENERGYCONSUMPTION \
+                        and self.__pumps_energy_usage_data_raw is not None:
+                    data.append(self.__pumps_energy_usage_data_raw)
+                elif sensor_type not in range(1,14):
+                    raise ValueError(
+                        f"Unknown sensor type '{sensor_type}' found in "
+                        f"'sensor_ordering'. Valid sensor types are:\n"
+                        f"{valid_sensor_types()}"
+                    )
             sensor_readings = np.concatenate(data, axis=1)
 
         # Apply sensor uncertainties

epyt_flow/simulation/scada/simple_control.py

@@ -93,11 +93,11 @@ class SimpleControlModule(JsonSerializable):
             if cond_comp_value < 0:
                 raise ValueError("'cond_comp_value' can not be negative")
 
-        self.__link_id = link_id
-        self.__link_status = link_status
-        self.__cond_type = cond_type
-        self.__cond_var_value = cond_var_value
-        self.__cond_comp_value = cond_comp_value
+        self._link_id = link_id
+        self._link_status = link_status
+        self._cond_type = cond_type
+        self._cond_var_value = cond_var_value
+        self._cond_comp_value = cond_comp_value
 
         super().__init__(**kwds)
 
@@ -111,7 +111,7 @@ class SimpleControlModule(JsonSerializable):
         `str`
             Link ID.
         """
-        return self.__link_id
+        return self._link_id
 
     @property
     def link_status(self) -> Union[int, float]:
@@ -130,7 +130,7 @@ class SimpleControlModule(JsonSerializable):
                 - EN_SET_OPEN     = 1e10
 
         """
-        return self.__link_status
+        return self._link_status
 
     @property
     def cond_type(self) -> int:
@@ -147,7 +147,7 @@ class SimpleControlModule(JsonSerializable):
                 - EN_TIMER     = 2
                 - EN_TIMEOFDAY = 3
         """
-        return self.__cond_type
+        return self._cond_type
 
     @property
     def cond_var_value(self) -> Union[str, int]:
@@ -163,7 +163,7 @@ class SimpleControlModule(JsonSerializable):
         `str` or `int`
             Condition/rule variable value.
         """
-        return self.__cond_var_value
+        return self._cond_var_value
 
     @property
     def cond_comp_value(self) -> float:
@@ -178,37 +178,37 @@ class SimpleControlModule(JsonSerializable):
         `float`
             Condition/Rule comparison value.
         """
-        return self.__cond_comp_value
+        return self._cond_comp_value
 
     def get_attributes(self) -> dict:
-        return super().get_attributes() | {"link_id": self.__link_id,
-                                           "link_status": self.__link_status,
-                                           "cond_type": self.__cond_type,
-                                           "cond_var_value": self.__cond_var_value,
-                                           "cond_comp_value": self.__cond_comp_value}
+        return super().get_attributes() | {"link_id": self._link_id,
+                                           "link_status": self._link_status,
+                                           "cond_type": self._cond_type,
+                                           "cond_var_value": self._cond_var_value,
+                                           "cond_comp_value": self._cond_comp_value}
 
     def __eq__(self, other) -> bool:
-        return super().__eq__(other) and self.__link_id == other.link_id and \
-            self.__link_status == other.link_status and self.__cond_type == other.cond_type and \
-            self.__cond_var_value == other.cond_var_value and \
-            self.__cond_comp_value == other.cond_comp_value
+        return super().__eq__(other) and self._link_id == other.link_id and \
+            self._link_status == other.link_status and self._cond_type == other.cond_type and \
+            self._cond_var_value == other.cond_var_value and \
+            self._cond_comp_value == other.cond_comp_value
 
     def __str__(self) -> str:
-        control_rule_str = f"LINK {self.__link_id} "
-        if isinstance(self.__link_status, int):
-            control_rule_str += "OPEN " if self.__link_status == ActuatorConstants.EN_OPEN or \
-                self.__link_status == ActuatorConstants.EN_SET_OPEN else "CLOSED "
+        control_rule_str = f"LINK {self._link_id} "
+        if isinstance(self._link_status, int):
+            control_rule_str += "OPEN " if self._link_status == ActuatorConstants.EN_OPEN or \
+                self._link_status == ActuatorConstants.EN_SET_OPEN else "CLOSED "
         else:
-            control_rule_str += f"{self.__link_status} "
-
-        if self.__cond_type == EpanetConstants.EN_TIMER:
-            control_rule_str += f"AT TIME {self.__cond_var_value}"
-        elif self.__cond_type == EpanetConstants.EN_TIMEOFDAY:
-            control_rule_str += f"AT CLOCKTIME {self.__cond_var_value}"
-        elif self.__cond_type == EpanetConstants.EN_LOWLEVEL:
-            control_rule_str += f"IF NODE {self.__cond_var_value} BELOW {self.__cond_comp_value}"
-        elif self.__cond_type == EpanetConstants.EN_HILEVEL:
-            control_rule_str += f"IF NODE {self.__cond_var_value} ABOVE {self.__cond_comp_value}"
+            control_rule_str += f"{self._link_status} "
+
+        if self._cond_type == EpanetConstants.EN_TIMER:
+            control_rule_str += f"AT TIME {self._cond_var_value}"
+        elif self._cond_type == EpanetConstants.EN_TIMEOFDAY:
+            control_rule_str += f"AT CLOCKTIME {self._cond_var_value}"
+        elif self._cond_type == EpanetConstants.EN_LOWLEVEL:
+            control_rule_str += f"IF NODE {self._cond_var_value} BELOW {self._cond_comp_value}"
+        elif self._cond_type == EpanetConstants.EN_HILEVEL:
+            control_rule_str += f"IF NODE {self._cond_var_value} ABOVE {self._cond_comp_value}"
 
         return control_rule_str
 

epyt_flow/simulation/scenario_config.py

@@ -18,6 +18,7 @@ from .events.sensor_faults import SensorFaultConstant, SensorFaultDrift, SensorF
     SensorFaultPercentage, SensorFaultStuckZero
 from .events.leakages import AbruptLeakage, IncipientLeakage
 from ..serialization import serializable, Serializable, SCENARIO_CONFIG_ID
+from ..topology import NetworkTopology
 
 
 @serializable(SCENARIO_CONFIG_ID, ".epytflow_scenario_config")
@@ -46,6 +47,11 @@ class ScenarioConfig(Serializable):
         Path to the .msx file -- optional, only necessary if EPANET-MSX is used.
 
         The default is None
+    network_topology : :class:`~epyt_flow.topology.NetworkTopology`, optional
+        Specification of the network topology -- necessary if .inp file does not exist
+        or is not shared.
+
+        The default is None.
     general_params : `dict`, optional
         General parameters such as the demand model, hydraulic time steps, etc.
 
@@ -88,6 +94,7 @@ class ScenarioConfig(Serializable):
     """
 
     def __init__(self, scenario_config: Any = None, f_inp_in: str = None, f_msx_in: str = None,
+                 network_topology: NetworkTopology = None,
                  general_params: dict = None, sensor_config: SensorConfig = None,
                  memory_consumption_estimate: float = None,
                  custom_controls: list[CustomControlModule] = [],
@@ -112,6 +119,10 @@ class ScenarioConfig(Serializable):
             if not isinstance(f_msx_in, str):
                 raise TypeError("'f_msx_in' must be an instance of 'str' " +
                                 f"but no of '{type(f_msx_in)}'")
+        if network_topology is not None:
+            if not isinstance(network_topology, NetworkTopology):
+                raise TypeError("'network_topology' msut be an instance of 'NetworkTopology' " +
+                                f"but not of '{type(network_topology)}'")
         if general_params is not None:
             if not isinstance(general_params, dict):
                 raise TypeError("'general_params' must be an instance of 'dict' " +
@@ -172,6 +183,11 @@ class ScenarioConfig(Serializable):
             self.__f_inp_in = scenario_config.f_inp_in
             self.__f_msx_in = scenario_config.f_msx_in if f_msx_in is None else f_msx_in
 
+            if network_topology is None:
+                self.__network_topology = scenario_config.network_topology
+            else:
+                self.__network_topology = network_topology
+
             if general_params is None:
                 self.__general_params = scenario_config.general_params
             else:
@@ -224,6 +240,7 @@ class ScenarioConfig(Serializable):
         else:
             self.__f_inp_in = f_inp_in
             self.__f_msx_in = f_msx_in
+            self.__network_topology = network_topology
             self.__general_params = general_params
             self.__sensor_config = sensor_config
             self.__memory_consumption_estimate = memory_consumption_estimate
@@ -278,6 +295,18 @@ class ScenarioConfig(Serializable):
             else:
                 return self.__f_msx_in
 
+    @property
+    def network_topology(self) -> NetworkTopology:
+        """
+        Returns the specification of the network topology.
+
+        Returns
+        -------
+        :class:`~epyt_flow.topology.NetworkTopology`
+            Network topology.
+        """
+        return deepcopy(self.__network_topology)
+
     @property
     def general_params(self) -> dict:
         """
@@ -402,6 +431,7 @@ class ScenarioConfig(Serializable):
 
     def get_attributes(self) -> dict:
         my_attributes = {"f_inp_in": self.__f_inp_in, "f_msx_in": self.__f_msx_in,
+                         "network_topology": self.__network_topology,
                          "general_params": self.__general_params,
                          "sensor_config": self.__sensor_config,
                          "memory_consumption_estimate": self.__memory_consumption_estimate,
@@ -421,6 +451,7 @@ class ScenarioConfig(Serializable):
                             f"with '{type(other)}' instance")
 
         return self.__f_inp_in == other.f_inp_in and self.__f_msx_in == other.f_msx_in \
+            and self.__network_topology == other.network_topology \
             and self.__general_params == other.general_params \
             and self.__memory_consumption_estimate == other.memory_consumption_estimate \
             and self.__sensor_config == other.sensor_config \