epyt-flow 0.1.0__py3-none-any.whl

epyt_flow/topology.py

@@ -0,0 +1,290 @@
+"""
+Module provides a class for representing the topology of WDN.
+"""
+import numpy as np
+import networkx as nx
+from scipy.sparse import bsr_array
+
+from .serialization import serializable, JsonSerializable, NETWORK_TOPOLOGY_ID
+
+
+@serializable(NETWORK_TOPOLOGY_ID, ".epytflow_topology")
+class NetworkTopology(nx.Graph, JsonSerializable):
+    """
+    Class representing the topology of a WDN.
+
+    Parameters
+    ----------
+    f_inp : `str`
+        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]]`
+        List of all links/pipes -- i.e. link ID, ID of connecting nodes, and link information
+        such as pipe diameter, length, etc.
+    """
+    def __init__(self, f_inp: str, nodes: list[tuple[str, dict]],
+                 links: list[tuple[str, tuple[str, str], dict]], **kwds):
+        super().__init__(name=f_inp, **kwds)
+
+        self.__nodes = nodes
+        self.__links = links
+
+        for node_id, node_info in nodes:
+            node_elevation = node_info["elevation"]
+            node_type = node_info["type"]
+            self.add_node(node_id, info={"elevation": node_elevation, "type": node_type})
+
+        for link_id, link, link_info in links:
+            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})
+
+    def get_all_nodes(self) -> list[str]:
+        """
+        Gets a list of all nodes.
+
+        Returns
+        -------
+        `list[str]`
+            List of all nodes ID.
+        """
+        return [node_id for node_id, _ in self.__nodes]
+
+    def get_all_links(self) -> list[tuple[str, tuple[str, str]]]:
+        """
+        Gets a list of all links/pipes (incl. their end points).
+
+        Returns
+        -------
+        `list[tuple[str, tuple[str, str]]]`
+            List of links -- (link ID, (left node ID, right node ID)).
+        """
+        return [(link_id, end_points) for link_id, end_points, _ in self.__links]
+
+    def get_node_info(self, node_id) -> dict:
+        """
+        Gets all information (e.g. elevation, type, etc.) associated with a given node.
+
+        Parameters
+        ----------
+        node_id : `str`
+            ID of the node.
+
+        Returns
+        -------
+        `dict`
+            Information associated with the given node.
+        """
+        for node_id_, node_info in self.__nodes:
+            if node_id_ == node_id:
+                return node_info
+
+        raise ValueError(f"Unknown node '{node_id}'")
+
+    def get_link_info(self, link_id) -> dict:
+        """
+        Gets all information (e.g. diameter, length, etc.) associated with a given link/pipe.
+
+        Parameters
+        ----------
+        link_id : `str`
+            ID of the link/pipe.
+
+        Returns
+        -------
+        `dict`
+            Information associated with the given link/pipe.
+        """
+        for link_id_, link_nodes, link_info in self.__links:
+            if link_id_ == link_id:
+                return {"nodes": link_nodes} | link_info
+
+        raise ValueError(f"Unknown link '{link_id}'")
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, NetworkTopology):
+            raise TypeError("Can not compare 'NetworkTopology' instance to " +
+                            f"'{type(other)}' instance")
+
+        return super().__eq__(other) and \
+            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()))
+
+    def __str__(self) -> str:
+        return f"f_inp: {self.name} nodes: {self.__nodes} links: {self.__links}"
+
+    def get_attributes(self) -> dict:
+        return super().get_attributes() | {"f_inp": self.name,
+                                           "nodes": self.__nodes,
+                                           "links": self.__links}
+
+    def get_adj_matrix(self) -> bsr_array:
+        """
+        Gets the adjacency matrix of this graph.
+
+        Returns
+        -------
+        `scipy.bsr_array`
+            Adjacency matrix as a sparse array.
+        """
+        nodes_id = [node_id for node_id, _ in self.__nodes]
+        n_nodes = len(self.__nodes)
+
+        row = []
+        col = []
+        for _, link_end_points, _ in self.__links:
+            a = nodes_id.index(link_end_points[0])
+            b = nodes_id.index(link_end_points[1])
+
+            row.append(a)
+            col.append(b)
+
+            row.append(b)
+            col.append(a)
+
+        for i in range(n_nodes):
+            row.append(i)
+            col.append(i)
+
+        return bsr_array((np.ones(len(row)), (row, col)), shape=(n_nodes, n_nodes))
+
+    def get_neighbors(self, node_id: str) -> list[str]:
+        """
+        Gets all neighboring nodes of a given node.
+
+        Parameters
+        ----------
+        node_id : `str`
+            ID of the node.
+
+        Returns
+        -------
+        `list[str]`
+            IDs of neighboring nodes.
+        """
+        if node_id not in self.get_all_nodes():
+            raise ValueError(f"Unknown node '{node_id}'")
+
+        return list(self.neighbors(node_id))
+
+    def get_adjacent_links(self, node_id: str) -> list[tuple[str, tuple[str, str]]]:
+        """
+        Gets all adjacent links/pipes of a given node.
+
+        Parameters
+        ----------
+        node_id : `str`
+            ID of the node.
+
+        Returns
+        -------
+        `list[tuple[str, tuple[str, str]]]`
+            Adjacent links -- i.e. (link ID, IDs of node end points).
+        """
+        if node_id not in self.get_all_nodes():
+            raise ValueError(f"Unknown node '{node_id}'")
+
+        links = []
+
+        for link_id, nodes_id, _ in self.__links:
+            if node_id in nodes_id:
+                links.append((link_id, nodes_id))
+
+        return links
+
+    def get_shortest_path(self, start_node_id: str, end_node_id: str,
+                          use_pipe_length_as_weight: bool = True) -> list[str]:
+        """
+        Computes the shortest path between two nodes in this graph.
+
+        Parameters
+        ----------
+        start_node_id : `str`
+            ID of start node.
+        end_node_id : `str`
+            ID of end node.
+        use_pipe_length_as_weight : `bool`, optional
+            If True, pipe lengths are used for the edge weights -- otherwise,
+            each edge weight is set to one.
+
+            The default is True.
+        """
+        if start_node_id not in self.get_all_nodes():
+            raise ValueError(f"Unknown node '{start_node_id}'")
+        if end_node_id not in self.get_all_nodes():
+            raise ValueError(f"Unknown node '{end_node_id}'")
+
+        weight = "length" if use_pipe_length_as_weight is True else None
+        return nx.shortest_path(self, source=start_node_id, target=end_node_id, weight=weight)
+
+    def get_all_pairs_shortest_path(self, use_pipe_length_as_weight: bool = True) -> dict:
+        """
+        Computes the shortest path between all pairs of nodes in this graph.
+
+        Parameters
+        ----------
+        use_pipe_length_as_weight : `bool`, optional
+            If True, pipe lengths are used for the edge weights -- otherwise,
+            each edge weight is set to one.
+
+            The default is True.
+
+        Returns
+        -------
+        `dict`
+            Shortest paths between all pairs of nodes as nested dictionaries --
+            first key is the start node, second key is the end node.
+        """
+        weight = "length" if use_pipe_length_as_weight is True else None
+        return nx.shortest_path(self, weight=weight)
+
+    def get_shortest_path_length(self, start_node_id: str, end_node_id: str,
+                                 use_pipe_length_as_weight: bool = True) -> list[str]:
+        """
+        Computes the shortest path length between two nodes in this graph.
+
+        Parameters
+        ----------
+        start_node_id : `str`
+            ID of start node.
+        end_node_id : `str`
+            ID of end node.
+        use_pipe_length_as_weight : `bool`, optional
+            If True, pipe lengths are used for the edge weights -- otherwise,
+            each edge weight is set to one.
+
+            The default is True.
+        """
+        if start_node_id not in self.get_all_nodes():
+            raise ValueError(f"Unknown node '{start_node_id}'")
+        if end_node_id not in self.get_all_nodes():
+            raise ValueError(f"Unknown node '{end_node_id}'")
+
+        weight = "length" if use_pipe_length_as_weight is True else None
+        return nx.shortest_path_length(self, source=start_node_id, target=end_node_id,
+                                       weight=weight)
+
+    def get_all_pairs_shortest_path_length(self, use_pipe_length_as_weight: bool = True) -> dict:
+        """
+        Computes the shortest path length between all pairs of nodes in this graph.
+
+        Parameters
+        ----------
+        use_pipe_length_as_weight : `bool`, optional
+            If True, pipe lengths are used for the edge weights -- otherwise,
+            each edge weight is set to one.
+
+            The default is True.
+
+        Returns
+        -------
+        `dict`
+            Shortest paths between all pairs of nodes as nested dictionaries --
+            first key is the start node, second key is the end node.
+        """
+        weight = "length" if use_pipe_length_as_weight is True else None
+        return dict(nx.shortest_path_length(self, weight=weight))

epyt_flow/uncertainty/__init__.py

@@ -0,0 +1,3 @@
+from .uncertainties import *
+from .sensor_noise import *
+from .model_uncertainty import *

epyt_flow/uncertainty/model_uncertainty.py

@@ -0,0 +1,302 @@
+"""
+Module provides a class for implementing model uncertainty.
+"""
+from copy import deepcopy
+import epyt
+import numpy as np
+
+from ..serialization import serializable, JsonSerializable, MODEL_UNCERTAINTY_ID
+from .uncertainties import Uncertainty
+
+
+@serializable(MODEL_UNCERTAINTY_ID, ".epytflow_uncertainty_model_uncertainty")
+class ModelUncertainty(JsonSerializable):
+    """
+    Class implementing model uncertainty -- i.e. uncertainties in pipe length, pipe roughness,
+    base demand, etc.
+
+    Parameters
+    ----------
+    pipe_length_uncertainty : :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`, optional
+        Uncertainty of pipe lengths. None, in the case of no uncertainty.
+
+        The default is None.
+    pipe_roughness_uncertainty : :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`, optional
+        Uncertainty of pipe roughness coefficients. None, in the case of no uncertainty.
+
+        The default is None.
+    pipe_diameter_uncertainty : :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`, optional
+        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
+        Uncertainty of base demands. None, in the case of no uncertainty.
+
+        The default is None.
+    demand_pattern_uncertainty : :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`, optional
+        Uncertainty of demand patterns. None, in the case of no uncertainty.
+
+        The default is None.
+    elevation_uncertainty : :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`, optional
+        Uncertainty of elevations. None, in the case of no uncertainty.
+
+        The default is None.
+    constants_uncertainty : :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`, optional
+        Uncertainty of MSX constants. None, in the case of no uncertainty.
+
+        The default is None.
+    parameters_uncertainty : :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`, optional
+        Uncertainty of MSX parameters. None, in the case of no uncertainty.
+
+        The default is None.
+    """
+    def __init__(self, pipe_length_uncertainty: Uncertainty = None,
+                 pipe_roughness_uncertainty: Uncertainty = None,
+                 pipe_diameter_uncertainty: Uncertainty = None,
+                 demand_base_uncertainty: Uncertainty = None,
+                 demand_pattern_uncertainty: Uncertainty = None,
+                 elevation_uncertainty: Uncertainty = None,
+                 constants_uncertainty: Uncertainty = None,
+                 parameters_uncertainty: Uncertainty = None, **kwds):
+        if pipe_length_uncertainty is not None:
+            if not isinstance(pipe_length_uncertainty, Uncertainty):
+                raise TypeError("'pipe_length_uncertainty' must be an instance of " +
+                                "'epyt_flow.uncertainty.Uncertainty' but not of " +
+                                f"'{type(pipe_length_uncertainty)}'")
+        if pipe_roughness_uncertainty is not None:
+            if not isinstance(pipe_roughness_uncertainty, Uncertainty):
+                raise TypeError("'pipe_roughness_uncertainty' must be an instance of " +
+                                "'epyt_flow.uncertainty.Uncertainty' but not of " +
+                                f"'{type(pipe_roughness_uncertainty)}'")
+        if pipe_diameter_uncertainty is not None:
+            if not isinstance(pipe_diameter_uncertainty, Uncertainty):
+                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 " +
+                                "'epyt_flow.uncertainty.Uncertainty' but not of " +
+                                f"'{type(demand_base_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 " +
+                                "'epyt_flow.uncertainty.Uncertainty' but not of " +
+                                f"'{type(demand_pattern_uncertainty)}'")
+        if elevation_uncertainty is not None:
+            if not isinstance(elevation_uncertainty, Uncertainty):
+                raise TypeError("'elevation_uncertainty' must be an instance of " +
+                                "'epyt_flow.uncertainty.Uncertainty' but not of " +
+                                f"'{type(elevation_uncertainty)}'")
+        if constants_uncertainty is not None:
+            if not isinstance(constants_uncertainty, Uncertainty):
+                raise TypeError("'constants_uncertainty' must be an instance of " +
+                                "'epyt_flow.uncertainty.Uncertainty' but not of " +
+                                f"'{type(constants_uncertainty)}'")
+        if parameters_uncertainty is not None:
+            if not isinstance(parameters_uncertainty, Uncertainty):
+                raise TypeError("'parameters_uncertainty' must be an instance of " +
+                                "'epyt_flow.uncertainty.Uncertainty' but not of " +
+                                f"'{type(parameters_uncertainty)}'")
+
+        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.__demand_pattern = demand_pattern_uncertainty
+        self.__elevation = elevation_uncertainty
+        self.__constants = constants_uncertainty
+        self.__parameters = parameters_uncertainty
+
+        super().__init__(**kwds)
+
+    @property
+    def pipe_length(self) -> Uncertainty:
+        """
+        Gets the pipe length uncertainty.
+
+        Returns
+        -------
+        :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`
+            Pipe length uncertainty.
+        """
+        return deepcopy(self.__pipe_length)
+
+    @property
+    def pipe_roughness(self) -> Uncertainty:
+        """
+        Gets the pipe roughness uncertainty.
+
+        Returns
+        -------
+        :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`
+            Pipe roughness uncertainty.
+        """
+        return deepcopy(self.__pipe_roughness)
+
+    @property
+    def pipe_diameter(self) -> Uncertainty:
+        """
+        Gets the pipe diameter uncertainty.
+
+        Returns
+        -------
+        :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`
+            Pipe diameter uncertainty.
+        """
+        return deepcopy(self.__pipe_diameter)
+
+    @property
+    def demand_base(self) -> Uncertainty:
+        """
+        Gets the demand base uncertainty.
+
+        Returns
+        -------
+        :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`
+            Demand base uncertainty.
+        """
+        return deepcopy(self.__demand_base)
+
+    @property
+    def demand_pattern(self) -> Uncertainty:
+        """
+        Gets the demand pattern uncertainty.
+
+        Returns
+        -------
+        :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`
+            Demand pattern uncertainty.
+        """
+        return deepcopy(self.__demand_pattern)
+
+    @property
+    def elevation(self) -> Uncertainty:
+        """
+        Gets the node elevation uncertainty.
+
+        Returns
+        -------
+        :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`
+            Node elevation uncertainty.
+        """
+        return deepcopy(self.__elevation)
+
+    @property
+    def constants(self) -> Uncertainty:
+        """
+        Gets the MSX constant uncertainty.
+
+        Returns
+        -------
+        :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`
+            MSX constant uncertainty.
+        """
+        return deepcopy(self.__constants)
+
+    @property
+    def parameters(self) -> Uncertainty:
+        """
+        Gets the MSX parameter uncertainty.
+
+        Returns
+        -------
+        :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`
+            MSX parameter uncertainty.
+        """
+        return deepcopy(self.__parameters)
+
+    def get_attributes(self) -> dict:
+        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,
+                                           "demand_pattern_uncertainty": self.__demand_pattern,
+                                           "elevation_uncertainty": self.__elevation,
+                                           "constants_uncertainty": self.__constants,
+                                           "parameters_uncertainty": self.__parameters}
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, ModelUncertainty):
+            raise TypeError("Can not compare 'ModelUncertainty' instance " +
+                            f"with '{type(other)}' instance")
+
+        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.__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"demand_pattern: {self.__demand_pattern} elevation: {self.__elevation} " + \
+            f"constants: {self.__constants} parameters: {self.__parameters}"
+
+    def apply(self, epanet_api: epyt.epanet) -> None:
+        """
+        Applies the specified model uncertainties to the scenario.
+
+        Parameters
+        ----------
+        epanet_api : `epyt.epanet`
+            Interface to EPANET and EPANET-MSX.
+        """
+        if self.__pipe_length is not None:
+            link_length = epanet_api.getLinkLength()
+            link_length = self.__pipe_length.apply_batch(link_length)
+            epanet_api.setLinkLength(link_length)
+
+        if self.__pipe_diameter is not None:
+            link_diameters = epanet_api.getLinkDiameter()
+            link_diameters = self.__pipe_diameter.apply_batch(link_diameters)
+            epanet_api.setLinkDiameter(link_diameters)
+
+        if self.__pipe_roughness is not None:
+            coeffs = epanet_api.getLinkRoughnessCoeff()
+            coeffs = self.__pipe_roughness.apply_batch(coeffs)
+            epanet_api.setLinkRoughnessCoeff(coeffs)
+
+        if self.__demand_base 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)
+
+        if self.__demand_pattern is not None:
+            demand_patterns_idx = epanet_api.getNodeDemandPatternIndex()
+            demand_patterns_id = np.unique([demand_patterns_idx[k]
+                                            for k in demand_patterns_idx.keys()])
+            for pattern_id in demand_patterns_id:
+                if pattern_id == 0:
+                    continue
+                pattern_length = epanet_api.getPatternLengths(pattern_id)
+                for t in range(pattern_length):
+                    v = epanet_api.getPatternValue(pattern_id, t+1)
+                    epanet_api.setPatternValue(pattern_id, t+1, self.__demand_pattern.apply(v))
+
+        if self.__elevation is not None:
+            elevations = epanet_api.getNodeElevations()
+            elevations = self.__elevation.apply_batch(elevations)
+            epanet_api.setNodeElevations(elevations)
+
+        if self.__constants is not None:
+            constants = epanet_api.getMSXConstantsValue()
+            constants = self.__constants.apply_batch(constants)
+            epanet_api.setMSXConstantsValue(constants)
+
+        if self.__parameters is not None:
+            parameters_pipes = epanet_api.getMSXParametersPipesValue()
+            for i, pipe_idx in enumerate(epanet_api.getLinkPipeIndex()):
+                parameters_pipes[i] = self.__parameters.apply_batch(parameters_pipes[i])
+                epanet_api.setMSXParametersPipesValue(pipe_idx, parameters_pipes[i])
+
+            parameters_tanks = epanet_api.getMSXParametersTanksValue()
+            for i, tank_idx in enumerate(epanet_api.getNodeTankIndex()):
+                parameters_tanks[i] = self.__parameters.apply_batch(parameters_tanks[i])
+                epanet_api.setMSXParametersTanksValue(tank_idx, parameters_tanks[i])

epyt_flow/uncertainty/sensor_noise.py

@@ -0,0 +1,73 @@
+"""
+Module provides a class for implementing sensor noise (e.g. uncertainty in sensor readings).
+"""
+from copy import deepcopy
+import numpy
+
+from .uncertainties import Uncertainty
+from ..serialization import serializable, JsonSerializable, SENSOR_NOISE_ID
+
+
+@serializable(SENSOR_NOISE_ID, ".epytflow_sensor_noise")
+class SensorNoise(JsonSerializable):
+    """
+    Class implementing sensor noise/uncertainty.
+
+    Parameters
+    ----------
+    uncertainty : :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`
+        Sensor uncertainty.
+    """
+    def __init__(self, uncertainty: Uncertainty, **kwds):
+        if not isinstance(uncertainty, Uncertainty):
+            raise TypeError("'uncertainty' must be an instance of " +
+                            f"'epyt_flow.uncertainty.Uncertainty' not of {type(uncertainty)}")
+
+        self.__uncertainty = uncertainty
+
+        super().__init__(**kwds)
+
+    @property
+    def uncertainty(self) -> Uncertainty:
+        """
+        Gets the Sensor readings uncertainty.
+
+        Returns
+        -------
+        :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`
+            Sensor readings uncertainty.
+        """
+        return deepcopy(self.__uncertainty)
+
+    def get_attributes(self) -> dict:
+        return super().get_attributes() | {"uncertainty": self.__uncertainty}
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, SensorNoise):
+            raise TypeError("Can not compare 'SensorNoise' instance " +
+                            f"with '{type(other)}' instance")
+
+        return self.__uncertainty == other.uncertainty
+
+    def __str__(self) -> str:
+        return f"uncertainty: {self.__uncertainty}"
+
+    def apply(self, sensor_readings: numpy.ndarray) -> numpy.ndarray:
+        """
+        Applies the sensor uncertainty to given sensor readings -- i.e. sensor readings
+        are perturbed according to the specified uncertainty.
+
+        .. note::
+            Note that state sensor readings such as valve states, pump states, etc.
+            are NOT affected by sensor noise!
+
+        Parameters
+        ----------
+        sensor_readings : `numpy.ndarray`
+
+        Returns
+        -------
+        `numpy.ndarray`
+            Perturbed sensor readings.
+        """
+        return self.__uncertainty.apply_batch(sensor_readings)