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

epyt_flow/topology.py

@@ -4,12 +4,13 @@ Module provides a class for representing the topology of WDN.
 from copy import deepcopy
 import warnings
 from typing import Any
+import math
 import numpy as np
 import networkx as nx
 from scipy.sparse import bsr_array
 from geopandas import GeoDataFrame
 from shapely.geometry import Point, LineString
-from epanet_plus import EpanetConstants
+from epanet_plus import EpanetConstants, EPyT
 
 from .serialization import serializable, JsonSerializable, NETWORK_TOPOLOGY_ID
 
@@ -67,6 +68,10 @@ class NetworkTopology(nx.Graph, JsonSerializable):
     valves : `dict`
         List of all valves -- i.e. valve ID, and information such as
         valve type and connecting nodes.
+    curves : `dict[str, tuple[int, list[tuple[float, float]]]]`
+        All curves -- i.e. curve ID, and list of points.
+    patterns : `dict[str, list[float]]`
+        All time patterns -- i.e., pattern ID and list of multipliers.
     units : `int`
         Measurement units category -- i.e. US Customary or SI Metric.
 
@@ -79,16 +84,25 @@ class NetworkTopology(nx.Graph, JsonSerializable):
                  links: list[tuple[str, tuple[str, str], dict]],
                  pumps: dict,
                  valves: dict,
+                 curves: dict[str, tuple[int, list[tuple[float, float]]]],
+                 patterns: dict[str, list[float]],
                  units: int,
                  **kwds):
-        super().__init__(name=f_inp, **kwds)
+        nx.Graph.__init__(self, name=f_inp, **kwds)
+        JsonSerializable.__init__(self)
 
         self.__nodes = nodes
         self.__links = links
         self.__pumps = pumps
         self.__valves = valves
+        self.__curves = curves
+        self.__patterns = patterns
         self.__units = units
 
+        for key in self.__curves.keys():    # Fix value types -- tuple gets converted to list when deserializing it
+            self.__curves[key] = (self.__curves[key][0],
+                                  [tuple(value) for value in self.__curves[key][1]])
+
         for node_id, node_info in nodes:
             node_elevation = node_info["elevation"]
             node_type = node_info["type"]
@@ -102,6 +116,141 @@ class NetworkTopology(nx.Graph, JsonSerializable):
                           info={"id": link_id, "type": link_type, "nodes": link,
                                 "diameter": link_diameter, "length": link_length})
 
+    def to_inp_file(self, inp_file_out: str) -> None:
+        """
+        Creates an .inp file with the network layout and parameters as specified in
+        this instance.
+        Note that no control rules are set!
+
+        Parameters
+        ----------
+        inp_file_out : `str`
+            Path to the .inp file.
+        """
+        with EPyT(inp_file_in=inp_file_out, use_project=False) as epanet_api:
+            if self.units == UNITS_SIMETRIC:
+                epanet_api.setflowunits(EpanetConstants.EN_CMH)
+            else:
+                epanet_api.setflowunits(EpanetConstants.EN_GPM)
+
+            for curve_id, (curve_type, curve_data) in self.__curves.items():
+                epanet_api.addcurve(curve_id)
+                curve_idx = epanet_api.getcurveindex(curve_id)
+                epanet_api.setcurvetype(curve_idx, curve_type)
+                for i, (x, y) in enumerate(curve_data):
+                    epanet_api.setcurvevalue(curve_idx, i+1, x, y)
+
+            for pattern_id, values in self.__patterns.items():
+                epanet_api.add_pattern(pattern_id, values)
+
+            for junc_id in self.get_all_junctions():
+                epanet_api.addnode(junc_id, EpanetConstants.EN_JUNCTION)
+
+                node_idx = epanet_api.get_node_idx(junc_id)
+                junc_info = self.get_node_info(junc_id)
+                epanet_api.setnodevalue(node_idx, EpanetConstants.EN_ELEVATION,
+                                        junc_info["elevation"])
+                epanet_api.setbasedemand(node_idx, 1, junc_info["base_demand"])
+                epanet_api.setcoord(node_idx, junc_info["coord"][0], junc_info["coord"][1])
+                epanet_api.setcomment(EpanetConstants.EN_NODE, node_idx, junc_info["comment"])
+                if "demand_patterns_id" in junc_info:
+                    for i, demand_pattern_id in enumerate(junc_info["demand_patterns_id"]):
+                        epanet_api.setdemandpattern(node_idx, i+1,
+                                                    epanet_api.getpatternindex(demand_pattern_id))
+
+            for reservoir_id in self.get_all_reservoirs():
+                epanet_api.addnode(reservoir_id, EpanetConstants.EN_RESERVOIR)
+
+                node_idx = epanet_api.get_node_idx(reservoir_id)
+                reservoir_info = self.get_node_info(reservoir_id)
+                epanet_api.setnodevalue(node_idx, EpanetConstants.EN_ELEVATION,
+                                        reservoir_info["elevation"])
+                epanet_api.setcoord(node_idx, reservoir_info["coord"][0],
+                                    reservoir_info["coord"][1])
+                epanet_api.setcomment(EpanetConstants.EN_NODE, node_idx,
+                                      reservoir_info["comment"])
+
+            for tank_id in self.get_all_tanks():
+                epanet_api.addnode(tank_id, EpanetConstants.EN_TANK)
+
+                node_idx = epanet_api.get_node_idx(tank_id)
+                tank_info = self.get_node_info(tank_id)
+                if tank_info["cylindric"] is False:
+                    raise NotImplementedError("Non-cylindric tanks are not supported!")
+                else:
+                    epanet_api.setnodevalue(node_idx, EpanetConstants.EN_ELEVATION,
+                                            tank_info["elevation"])
+                    epanet_api.setcoord(node_idx, tank_info["coord"][0], tank_info["coord"][1])
+                    epanet_api.setcomment(EpanetConstants.EN_NODE, node_idx, tank_info["comment"])
+                    epanet_api.setnodevalue(node_idx, EpanetConstants.EN_TANKDIAM,
+                                            tank_info["diameter"])
+                    epanet_api.setnodevalue(node_idx, EpanetConstants.EN_MIXFRACTION,
+                                            tank_info["mixing_fraction"])
+                    epanet_api.setnodevalue(node_idx, EpanetConstants.EN_MIXMODEL,
+                                            tank_info["mixing_model"])
+                    epanet_api.setnodevalue(node_idx, EpanetConstants.EN_CANOVERFLOW,
+                                            float(tank_info["can_overflow"]))
+
+                    tank_info["min_level"] = tank_info["min_vol"] / \
+                        (math.pi * (0.5 * tank_info["diameter"])**2)
+                    tank_info["init_level"] = tank_info["init_vol"] / \
+                        (math.pi * (0.5 * tank_info["diameter"])**2)
+
+                    epanet_api.settankdata(node_idx, tank_info["elevation"],
+                                           tank_info["init_level"], tank_info["min_level"],
+                                           tank_info["max_level"], tank_info["diameter"],
+                                           tank_info["min_vol"], tank_info["vol_curve_id"])
+
+            for pipe_id, (node_a, node_b) in self.get_all_pipes():
+                epanet_api.addlink(pipe_id, EpanetConstants.EN_PIPE, node_a, node_b)
+
+                pipe_idx = epanet_api.get_link_idx(pipe_id)
+                pipe_info = self.get_link_info(pipe_id)
+                epanet_api.setlinkvalue(pipe_idx, EpanetConstants.EN_LENGTH, pipe_info["length"])
+                epanet_api.setlinkvalue(pipe_idx, EpanetConstants.EN_DIAMETER,
+                                        pipe_info["diameter"])
+                epanet_api.setlinkvalue(pipe_idx, EpanetConstants.EN_ROUGHNESS,
+                                        pipe_info["roughness_coeff"])
+                epanet_api.setlinkvalue(pipe_idx, EpanetConstants.EN_KBULK, pipe_info["bulk_coeff"])
+                epanet_api.setlinkvalue(pipe_idx, EpanetConstants.EN_KWALL, pipe_info["wall_coeff"])
+                epanet_api.setlinkvalue(pipe_idx, EpanetConstants.EN_MINORLOSS,
+                                        pipe_info["loss_coeff"])
+                epanet_api.setlinkvalue(pipe_idx, EpanetConstants.EN_INITSETTING,
+                                        pipe_info["init_setting"])
+                epanet_api.setlinkvalue(pipe_idx, EpanetConstants.EN_INITSTATUS,
+                                        pipe_info["init_status"])
+
+            for valve_id in self.get_all_valves():
+                valve_info = self.get_valve_info(valve_id)
+                node_a, node_b = valve_info["end_points"]
+                epanet_api.addlink(valve_id, valve_info["type"], node_a, node_b)
+                link_idx = epanet_api.get_link_idx(valve_id)
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_DIAMETER,
+                                        valve_info["diameter"])
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_INITSETTING,
+                                        valve_info["initial_setting"])
+                if valve_info["type"] not in [EpanetConstants.EN_GPV, EpanetConstants.EN_PRV,
+                                              EpanetConstants.EN_CVPIPE]:
+                    epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_INITSTATUS,
+                                            valve_info["initial_status"])
+
+            for pump_id in self.get_all_pumps():
+                pump_info = self.get_pump_info(pump_id)
+                node_a, node_b = pump_info["end_points"]
+                epanet_api.addlink(pump_id, pump_info["type"], node_a, node_b)
+
+                link_idx = link_idx = epanet_api.get_link_idx(pump_id)
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_INITSETTING,
+                                        pump_info["init_setting"])
+                epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_INITSTATUS,
+                                        pump_info["init_status"])
+
+                if pump_info["curve_id"] is not None:
+                    curve_idx = epanet_api.getcurveindex(pump_info["curve_id"])
+                    epanet_api.setheadcurveindex(link_idx, curve_idx)
+
+            epanet_api.saveinpfile(inp_file_out)
+
     def convert_units(self, units: int) -> Any:
         """
         Converts this instance to a :class:`~epyt_flow.topology.NetworkTopology` instance
@@ -138,6 +287,7 @@ class NetworkTopology(nx.Graph, JsonSerializable):
         # Get all data and convert units
         inch_to_millimeter = 25.4
         feet_to_meter = 0.3048
+        cubicmeter_to_cubicfeet = 35.3146667215
 
         nodes = []
         for node_id in self.get_all_nodes():
@@ -146,10 +296,23 @@ class NetworkTopology(nx.Graph, JsonSerializable):
                 conv_factor = 1. / feet_to_meter
             else:
                 conv_factor = feet_to_meter
+
             node_info["elevation"] *= conv_factor
             if "diameter" in node_info:
                 node_info["diameter"] *= conv_factor
 
+            if "max_level" in node_info:
+                node_info["max_level"] *= conv_factor
+            if "min_level" in node_info:
+                node_info["min_level"] *= conv_factor
+            if "init_level" in node_info:
+                node_info["init_level"] *= conv_factor
+            if "min_vol" in node_info:
+                if units == UNITS_USCUSTOM:
+                    node_info["min_vol"] *= cubicmeter_to_cubicfeet
+                else:
+                    node_info["min_vol"] *= 1. / cubicmeter_to_cubicfeet
+
             nodes.append((node_id, node_info))
 
         links = []
@@ -171,7 +334,8 @@ class NetworkTopology(nx.Graph, JsonSerializable):
             links.append((link_id, link_nodes, link_info))
 
         return NetworkTopology(f_inp=self.name, nodes=nodes, links=links, pumps=self.pumps,
-                               valves=self.valves, units=units)
+                               valves=self.valves, units=units, curves=self.__curves,
+                               patterns=self.__patterns)
 
     def get_all_nodes(self) -> list[str]:
         """
@@ -455,6 +619,30 @@ class NetworkTopology(nx.Graph, JsonSerializable):
         else:
             raise ValueError(f"Unknown valve: '{valve_id}'")
 
+    @property
+    def curves(self) -> dict[str, tuple[int, list[tuple[float, float]]]]:
+        """
+        Gets all curves -- i.e., ID and list of points.
+
+        Returns
+        -------
+        `dict[str, tuple[int, list[tuple[float, float]]]]`
+            All curves.
+        """
+        return deepcopy(self.__curves)
+
+    @property
+    def patterns(self) -> dict[str, list[float]]:
+        """
+        Returns all time patterns -- i.e., ID and list of multipliers.
+
+        Returns
+        -------
+        `dict[str, list[float]]`
+            All time patterns.
+        """
+        return deepcopy(self.__patterns)
+
     @property
     def pumps(self) -> dict:
         """
@@ -504,8 +692,7 @@ class NetworkTopology(nx.Graph, JsonSerializable):
         adj_matrix = self.get_adj_matrix()
         other_adj_matrix = other.get_adj_matrix()
 
-        return super().__eq__(other) and \
-            self.name == other.name \
+        return self.name == other.name \
             and not np.any(adj_matrix.data != other_adj_matrix.data) \
             and not np.any(adj_matrix.indices != other_adj_matrix.indices) \
             and not np.any(adj_matrix.indptr != other_adj_matrix.indptr) \
@@ -514,7 +701,9 @@ class NetworkTopology(nx.Graph, JsonSerializable):
                     for link_a, link_b in zip(self.get_all_links(), other.get_all_links())) \
             and self.__units == other.units \
             and self.get_all_pumps() == other.get_all_pumps() \
-            and self.get_all_valves() == other.get_all_valves()
+            and self.get_all_valves() == other.get_all_valves() \
+            and self.__curves == other.curves \
+            and self.__patterns == other.patterns
 
     def __str__(self) -> str:
         return f"f_inp: {self.name} nodes: {self.__nodes} links: {self.__links} " +\
@@ -527,6 +716,8 @@ class NetworkTopology(nx.Graph, JsonSerializable):
                                            "links": self.__links,
                                            "pumps": self.__pumps,
                                            "valves": self.__valves,
+                                           "curves": self.__curves,
+                                           "patterns": self.__patterns,
                                            "units": self.__units}
 
     def to_gis(self, coord_reference_system: str = None, pumps_as_points: bool = False,

epyt_flow/uncertainty/model_uncertainty.py

@@ -328,6 +328,8 @@ class ModelUncertainty(JsonSerializable):
         self._cache_msx_tanks_parameters = None
         self._cache_msx_patterns = None
 
+        self.__np_rand_gen = np.random.default_rng(seed=self.__seed)
+
         super().__init__(**kwds)
 
     @property
@@ -703,13 +705,12 @@ class ModelUncertainty(JsonSerializable):
         epanet_api : `epanet_plus.EPyT <https://epanet-plus.readthedocs.io/en/stable/api.html#epanet_plus.epanet_toolkit.EPyT>`_
             Interface to EPANET and EPANET-MSX.
         """
-        np_rand_gen = np.random.default_rng(seed=self.__seed)
 
         all_links_idx = epanet_api.get_all_links_idx()
         all_nodes_idx = epanet_api.get_all_nodes_idx()
 
         if self._global_pipe_length is not None:
-            self._global_pipe_length.set_random_generator(np_rand_gen)
+            self._global_pipe_length.set_random_generator(self.__np_rand_gen)
 
             link_length = np.array([epanet_api.getlinkvalue(link_idx, EpanetConstants.EN_LENGTH)
                                     for link_idx in all_links_idx])
@@ -720,7 +721,7 @@ class ModelUncertainty(JsonSerializable):
                 epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_LENGTH, link_value)
 
         if self._local_pipe_length is not None:
-            self._local_pipe_length.set_random_generator(np_rand_gen)
+            self._local_pipe_length.set_random_generator(self.__np_rand_gen)
             self._cache_links_length = np.array([epanet_api.getlinkvalue(link_idx, EpanetConstants.EN_LENGTH)
                                                  for link_idx in all_links_idx])
 
@@ -732,7 +733,7 @@ class ModelUncertainty(JsonSerializable):
                 epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_LENGTH, link_length)
 
         if self._global_pipe_diameter is not None:
-            self._global_pipe_diameter.set_random_generator(np_rand_gen)
+            self._global_pipe_diameter.set_random_generator(self.__np_rand_gen)
 
             link_diameters = np.array([epanet_api.getlinkvalue(link_idx, EpanetConstants.EN_DIAMETER)
                                        for link_idx in all_links_idx])
@@ -743,7 +744,7 @@ class ModelUncertainty(JsonSerializable):
                 epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_DIAMETER, link_value)
 
         if self._local_pipe_diameter is not None:
-            self._local_pipe_diameter.set_random_generator(np_rand_gen)
+            self._local_pipe_diameter.set_random_generator(self.__np_rand_gen)
             self._cache_links_diameter = np.array([epanet_api.getlinkvalue(link_idx,
                                                                            EpanetConstants.EN_DIAMETER)
                                                    for link_idx in all_links_idx])
@@ -756,7 +757,7 @@ class ModelUncertainty(JsonSerializable):
                 epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_DIAMETER, link_diameter)
 
         if self._global_pipe_roughness is not None:
-            self._global_pipe_roughness.set_random_generator(np_rand_gen)
+            self._global_pipe_roughness.set_random_generator(self.__np_rand_gen)
 
             coeffs = np.array([epanet_api.getlinkvalue(link_idx, EpanetConstants.EN_ROUGHNESS)
                                for link_idx in all_links_idx])
@@ -767,7 +768,7 @@ class ModelUncertainty(JsonSerializable):
                 epanet_api.setlinkvalue(link_idx, EpanetConstants.EN_ROUGHNESS, link_value)
 
         if self._local_pipe_roughness is not None:
-            self._local_pipe_roughness.set_random_generator(np_rand_gen)
+            self._local_pipe_roughness.set_random_generator(self.__np_rand_gen)
             self._cache_links_roughness_coeff = \
                 np.array([epanet_api.getlinkvalue(link_idx, EpanetConstants.EN_ROUGHNESS)
                           for link_idx in all_links_idx])
@@ -782,7 +783,7 @@ class ModelUncertainty(JsonSerializable):
                                         link_roughness_coeff)
 
         if self._global_base_demand is not None:
-            self._global_base_demand.set_random_generator(np_rand_gen)
+            self._global_base_demand.set_random_generator(self.__np_rand_gen)
 
             self._cache_nodes_base_demand = {}
             for node_idx in all_nodes_idx:
@@ -796,7 +797,7 @@ class ModelUncertainty(JsonSerializable):
                     epanet_api.setbasedemand(node_idx, demand_idx + 1, base_demand)
 
         if self._local_base_demand is not None:
-            self._local_base_demand.set_random_generator(np_rand_gen)
+            self._local_base_demand.set_random_generator(self.__np_rand_gen)
 
             self._cache_nodes_base_demand = {}
             for node_id, uncertainty in self._local_base_demand.items():
@@ -811,14 +812,16 @@ class ModelUncertainty(JsonSerializable):
                     epanet_api.setbasedemand(node_idx, demand_idx + 1, base_demand)
 
         if self._global_demand_pattern is not None:
-            self._global_demand_pattern.set_random_generator(np_rand_gen)
+            self._global_demand_pattern.set_random_generator(self.__np_rand_gen)
 
             self._cache_nodes_demand_pattern = {}
             demand_patterns_idx = np.array([epanet_api.getdemandpattern(node_idx, demand_idx + 1)
                                             for node_idx in epanet_api.get_all_nodes_idx()
                                             for demand_idx in range(epanet_api.getnumdemands(node_idx))])
 
-            for pattern_idx in list(set(demand_patterns_idx)):
+            demand_patterns_idx = set(demand_patterns_idx)
+            demand_patterns_idx.discard(0)
+            for pattern_idx in list(demand_patterns_idx):
                 demand_pattern = np.array(epanet_api.get_pattern(pattern_idx))
                 self._cache_nodes_demand_pattern[pattern_idx] = np.copy(demand_pattern)
 
@@ -826,7 +829,7 @@ class ModelUncertainty(JsonSerializable):
                 epanet_api.set_pattern(pattern_idx, demand_pattern.tolist())
 
         if self._local_demand_pattern is not None:
-            self._local_demand_pattern.set_random_generator(np_rand_gen)
+            self._local_demand_pattern.set_random_generator(self.__np_rand_gen)
 
             self._cache_nodes_demand_pattern = {}
 
@@ -839,7 +842,7 @@ class ModelUncertainty(JsonSerializable):
                 epanet_api.set_pattern(pattern_idx, demand_pattern.tolist())
 
         if self._global_elevation is not None:
-            self._global_elevation.set_random_generator(np_rand_gen)
+            self._global_elevation.set_random_generator(self.__np_rand_gen)
 
             elevations = np.array([epanet_api.get_node_elevation(node_idx)
                                    for node_idx in epanet_api.get_all_nodes_idx()])
@@ -850,7 +853,7 @@ class ModelUncertainty(JsonSerializable):
                 epanet_api.setnodevalue(node_idx + 1, EpanetConstants.EN_ELEVATION, node_elev)
 
         if self._local_elevation is not None:
-            self._local_elevation.set_random_generator(np_rand_gen)
+            self._local_elevation.set_random_generator(self.__np_rand_gen)
             self._cache_nodes_elevation = np.array([epanet_api.get_node_elevation(node_idx)
                                                     for node_idx in epanet_api.get_all_nodes_idx()])
 
@@ -862,7 +865,7 @@ class ModelUncertainty(JsonSerializable):
                 epanet_api.setnodevalue(node_idx, EpanetConstants.EN_ELEVATION, elevation)
 
         if self._local_patterns is not None:
-            self._local_patterns.set_random_generator(np_rand_gen)
+            self._local_patterns.set_random_generator(self.__np_rand_gen)
             self._cache_patterns = {}
 
             for pattern_id, uncertainty in self._local_patterns.items():
@@ -875,7 +878,7 @@ class ModelUncertainty(JsonSerializable):
 
         if epanet_api.msx_file is not None:
             if self._global_constants is not None:
-                self._global_constants.set_random_generator(np_rand_gen)
+                self._global_constants.set_random_generator(self.__np_rand_gen)
 
                 constants = np.array([epanet_api.MSXgetconstant(const_idx + 1)
                                       for const_idx in range(epanet_api.MSXgetcount(EpanetConstants.MSX_CONSTANT))])
@@ -886,7 +889,7 @@ class ModelUncertainty(JsonSerializable):
                     epanet_api.MSXsetconstant(const_idx + 1, const_value)
 
             if self._local_constants:
-                self._local_constants.set_random_generator(np_rand_gen)
+                self._local_constants.set_random_generator(self.__np_rand_gen)
 
                 self._cache_msx_patterns = np.array([epanet_api.MSXgetconstant(const_idx + 1)
                                                      for const_idx in range(epanet_api.MSXgetcount(EpanetConstants.MSX_CONSTANT))])
@@ -899,7 +902,7 @@ class ModelUncertainty(JsonSerializable):
                     epanet_api.MSXsetconstant(idx, constant)
 
             if self._global_parameters is not None:
-                self._global_parameters.set_random_generator(np_rand_gen)
+                self._global_parameters.set_random_generator(self.__np_rand_gen)
 
                 self._cache_msx_links_parameters = {}
                 num_params = epanet_api.MSXgetcount(EpanetConstants.MSX_PARAMETER)
@@ -934,7 +937,7 @@ class ModelUncertainty(JsonSerializable):
                         epanet_api.MSXsetparameter(EpanetConstants.MSX_NODE, tank_idx, idx + 1, val)
 
             if self._local_parameters is not None:
-                self._local_parameters.set_random_generator(np_rand_gen)
+                self._local_parameters.set_random_generator(self.__np_rand_gen)
                 self._cache_msx_links_parameters = {}
                 self._cache_msx_tanks_parameters = {}
 
@@ -959,7 +962,7 @@ class ModelUncertainty(JsonSerializable):
                     epanet_api.MSXsetparameter(item_type, item_idx, idx, parameter)
 
             if self._local_msx_patterns is not None:
-                self._local_msx_patterns.set_random_generator(np_rand_gen)
+                self._local_msx_patterns.set_random_generator(self.__np_rand_gen)
                 self._cache_msx_patterns = {}
 
                 for pattern_id, uncertainty in self._local_msx_patterns.items():

epyt_flow/uncertainty/sensor_noise.py

@@ -50,9 +50,9 @@ class SensorNoise(JsonSerializable):
                 raise TypeError("'local_uncertainties' must be an instance of " +
                                 "'dict[tuple[int, str], epyt_flow.uncertainty.Uncertainty]'")
 
-        self.__global_uncertainty = global_uncertainty
-        self.__local_uncertainties = local_uncertainties
-        self.__np_rand_gen = default_rng(seed)
+        self._global_uncertainty = global_uncertainty
+        self._local_uncertainties = local_uncertainties
+        self._np_rand_gen = default_rng(seed)
 
         super().__init__(**kwds)
 
@@ -66,7 +66,7 @@ class SensorNoise(JsonSerializable):
         :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`
             Global sensor readings uncertainty.
         """
-        return deepcopy(self.__global_uncertainty)
+        return deepcopy(self._global_uncertainty)
 
     @property
     def local_uncertainties(self) -> dict[int, str, Uncertainty]:
@@ -78,23 +78,23 @@ class SensorNoise(JsonSerializable):
         dict[tuple[int, str], :class:`~epyt_flow.uncertainty.uncertainties.Uncertainty`]
             Local (i.e. sensor specific) uncertainties.
         """
-        return deepcopy(self.__local_uncertainties)
+        return deepcopy(self._local_uncertainties)
 
     def get_attributes(self) -> dict:
-        return super().get_attributes() | {"global_uncertainty": self.__global_uncertainty,
-                                           "local_uncertainties": self.__local_uncertainties}
+        return super().get_attributes() | {"global_uncertainty": self._global_uncertainty,
+                                           "local_uncertainties": self._local_uncertainties}
 
     def __eq__(self, other) -> bool:
         if not isinstance(other, SensorNoise):
             raise TypeError("Can not compare 'SensorNoise' instance " +
                             f"with '{type(other)}' instance")
 
-        return super().__eq__(other) and self.__global_uncertainty == other.global_uncertainty and \
-            self.__local_uncertainties == other.local_uncertainties
+        return super().__eq__(other) and self._global_uncertainty == other.global_uncertainty and \
+            self._local_uncertainties == other.local_uncertainties
 
     def __str__(self) -> str:
-        return f"global_uncertainty: {self.__global_uncertainty} " + \
-            f"local_uncertainties: {self.__local_uncertainties}"
+        return f"global_uncertainty: {self._global_uncertainty} " + \
+            f"local_uncertainties: {self._local_uncertainties}"
 
     def apply_local_uncertainty(self, map_sensor_to_idx: Callable[[int, str], int],
                                 sensor_readings: numpy.ndarray) -> numpy.ndarray:
@@ -115,10 +115,10 @@ class SensorNoise(JsonSerializable):
         `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
             Perturbed sensor readings.
         """
-        if self.__local_uncertainties is None:
+        if self._local_uncertainties is None:
             return sensor_readings
         else:
-            self.__local_uncertainties.set_random_generator(self.__np_rand_gen)
+            self._local_uncertainties.set_random_generator(self._np_rand_gen)
 
             for (sensor_type, sensor_id), uncertainty in map_sensor_to_idx.items():
                 idx = map_sensor_to_idx(sensor_type, sensor_id)
@@ -144,9 +144,9 @@ class SensorNoise(JsonSerializable):
         `numpy.ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_
             Perturbed sensor readings.
         """
-        if self.__global_uncertainty is None:
+        if self._global_uncertainty is None:
             return sensor_readings
         else:
-            self.__global_uncertainty.set_random_generator(self.__np_rand_gen)
+            self._global_uncertainty.set_random_generator(self._np_rand_gen)
 
-            return self.__global_uncertainty.apply_batch(sensor_readings)
+            return self._global_uncertainty.apply_batch(sensor_readings)

epyt_flow/uncertainty/uncertainties.py

@@ -101,9 +101,11 @@ class Uncertainty(ABC):
         return {"min_value": self.__min_value, "max_value": self.__max_value}
 
     def __eq__(self, other) -> bool:
-        if not isinstance(other, Uncertainty):
+        if not isinstance(other, (Uncertainty, type(None))):
             raise TypeError("Can not compare 'Uncertainty' instance " +
                             f"with '{type(other)}' instance")
+        if other is None:
+            return False
 
         return self.__min_value == other.min_value and self.__max_value == other.max_value and \
             self._random_generator == other.random_generator
@@ -221,7 +223,7 @@ class GaussianUncertainty(Uncertainty):
         return super().get_attributes() | {"mean": self._mean, "scale": self._scale}
 
     def __eq__(self, other) -> bool:
-        if not isinstance(other, GaussianUncertainty):
+        if not isinstance(other, (GaussianUncertainty, type(None))):
             raise TypeError("Can not compare 'GaussianUncertainty' instance " +
                             f"with '{type(other)}' instance")
 
@@ -320,7 +322,7 @@ class UniformUncertainty(Uncertainty):
         return super().get_attributes() | {"low": self.__low, "high": self.__high}
 
     def __eq__(self, other) -> bool:
-        if not isinstance(other, UniformUncertainty):
+        if not isinstance(other, (UniformUncertainty, type(None))):
             raise TypeError("Can not compare 'UniformUncertainty' instance " +
                             f"with '{type(other)}' instance")
 
@@ -562,7 +564,7 @@ class DeepUncertainty(Uncertainty):
                                            "max_noise_value": self.__max_noise_value}
 
     def __eq__(self, other) -> bool:
-        if not isinstance(other, DeepUncertainty):
+        if not isinstance(other, (DeepUncertainty, type(None))):
             raise TypeError("Can not compare 'DeepUncertainty' instance " +
                             f"with '{type(other)}' instance")