epyt-flow 0.14.0__py3-none-any.whl → 0.14.1__py3-none-any.whl

epyt_flow/EPANET/EPANET/SRC_engines/validate.c

@@ -0,0 +1,408 @@
+/*
+ ******************************************************************************
+ Project:      OWA EPANET
+ Version:      2.3
+ Module:       validate.c
+ Description:  validates project data
+ Authors:      see AUTHORS
+ Copyright:    see AUTHORS
+ License:      see LICENSE
+ Last Updated: 03/18/2024
+ ******************************************************************************
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h> 
+
+#include "types.h"
+#include "funcs.h"
+#include "text.h"
+
+// Exported functions
+int  validateproject(Project *);
+void reindextanks(Project *);
+
+int validatetanks(Project *pr)
+/*
+**-------------------------------------------------------------------
+**  Input:   none
+**  Output:  returns 1 if successful, 0 if not
+**  Purpose: checks for valid tank levels.
+**-------------------------------------------------------------------
+*/
+{
+    Network *net = &pr->network;
+    int i, j, n, result = 1, levelerr;
+    char errmsg[MAXMSG+1] = "";
+    Stank *tank;
+    Scurve *curve;
+    double elev;
+    
+    for (j = 1; j <= net->Ntanks; j++)
+    {
+        tank = &net->Tank[j];
+        if (tank->A == 0.0) continue;  // Skip reservoirs
+
+        // Check for valid lower/upper tank levels
+        levelerr = 0;
+        if (tank->H0 > tank->Hmax ||
+            tank->Hmin > tank->Hmax ||
+            tank->H0 < tank->Hmin
+        ) levelerr = 1;
+
+        // Check that tank heights are within volume curve
+        elev = net->Node[tank->Node].El;
+        i = tank->Vcurve;
+        if (i > 0)
+        {
+            curve = &net->Curve[i];
+            n = curve->Npts - 1;
+            if ((tank->Hmin - elev) * pr->Ucf[ELEV] < curve->X[0] - TINY ||
+                (tank->Hmax - elev) * pr->Ucf[ELEV] > curve->X[n] + TINY)
+            {
+                levelerr = 1;
+            }
+        }
+        
+        // Report error in levels if found
+        if (levelerr)
+        {
+            sprintf(pr->Msg, "Error 225: %s node %s", geterrmsg(225, errmsg),
+                    net->Node[tank->Node].ID);
+            writeline(pr, pr->Msg);
+            result = 0;
+        }
+    }
+    return result;
+}
+
+int validatepatterns(Project *pr)
+/*
+**-------------------------------------------------------------------
+**  Input:   none
+**  Output:  returns 1 if successful, 0 if not
+**  Purpose: checks if time patterns have data.
+**-------------------------------------------------------------------
+*/
+{
+    Network *net = &pr->network;
+    int j, result = 1;
+    char errmsg[MAXMSG+1] = "";
+
+    if (pr->network.Pattern != NULL)
+    {
+        for (j = 0; j <= pr->network.Npats; j++)
+        {
+            if (pr->network.Pattern[j].Length == 0)
+            {
+                sprintf(pr->Msg, "Error 232: %s %s", geterrmsg(232, errmsg),
+                    pr->network.Pattern[j].ID);
+                writeline(pr, pr->Msg);
+                result = 0;
+            }
+        }
+    }
+    return result;            
+}
+
+int validatecurves(Project *pr)
+/*
+**-------------------------------------------------------------------
+**  Input:   none
+**  Output:  returns 1 if successful, 0 if not
+**  Purpose: checks if data curves have data.
+**-------------------------------------------------------------------
+*/
+{
+    int i, j, npts, result = 1;
+    char errmsg[MAXMSG+1] = "";
+    Scurve *curve;
+
+    if (pr->network.Curve != NULL)
+    {
+        for (j = 1; j <= pr->network.Ncurves; j++)
+        {
+            // Check that curve has data
+            curve = &pr->network.Curve[j];
+            npts = curve->Npts;
+            if (npts == 0)
+            {
+                sprintf(pr->Msg, "Error 231: %s %s", geterrmsg(231, errmsg),
+                    curve->ID);
+                writeline(pr, pr->Msg);
+                result = 0;
+            }
+            
+            // Check that x values are increasing
+            for (i = 1; i < npts; i++)
+            {
+                if (curve->X[i-1] >= curve->X[i])
+                {
+                    sprintf(pr->Msg, "Error 230: %s %s", geterrmsg(230, errmsg),
+                        curve->ID);
+                    writeline(pr, pr->Msg);
+                    result = 0;
+                    break;
+                }
+            }       
+        }
+    }
+    return result;
+}
+
+int powerfuncpump(double h0, double h1, double h2, double q1, double q2,
+                  double *a, double *b, double *c)
+/*
+**---------------------------------------------------------
+**  Input:   h0 = shutoff head
+**           h1 = design head
+**           h2 = head at max. flow
+**           q1 = design flow
+**           q2 = max. flow
+**  Output:  *a, *b, *c = pump curve coeffs. (H = a-bQ^c),
+**           Returns 1 if successful, 0 otherwise.
+**  Purpose: computes coeffs. for a power function pump curve
+**----------------------------------------------------------
+*/
+{
+    double h4, h5;
+
+    if (h0 < TINY || h0 - h1 < TINY || h1 - h2 < TINY ||
+        q1 < TINY || q2 - q1 < TINY
+       ) return 0;
+    *a = h0;
+    h4 = h0 - h1;
+    h5 = h0 - h2;
+    *c = log(h5 / h4) / log(q2 / q1);
+    if (*c <= 0.0 || *c > 20.0) return 0;
+    *b = -h4 / pow(q1, *c);
+    if (*b >= 0.0) return 0;
+    return 1;
+}
+
+int customcurvepump(Project *pr, Spump *pump, Scurve *curve)
+/*
+**-------------------------------------------------------------------
+**  Input:   pump = a pump object
+**           curve = a data curve object
+**  Output:  returns an error code
+**  Purpose: computes properties for a pump with a custom pump curve.
+**-------------------------------------------------------------------
+*/
+{
+    int m, npts = curve->Npts;
+    pump->Ptype = CUSTOM;
+    for (m = 1; m < npts; m++)
+    {
+        // Curve must have continuously decreasing head (the Y value)
+        if (curve->Y[m] >= curve->Y[m - 1])
+        {
+            pump->Ptype = NOCURVE;
+            return 227;
+        }
+    }
+    pump->Qmax = curve->X[npts - 1];
+    pump->Q0 = (curve->X[0] + pump->Qmax) / 2.0 / pr->Ucf[FLOW];
+    pump->Qmax /= pr->Ucf[FLOW];
+    pump->Hmax = curve->Y[0] / pr->Ucf[HEAD];
+    return 0;
+}
+
+int pumpcurvepump(Project *pr, Spump *pump, Scurve *curve)
+/*
+**-------------------------------------------------------------------
+**  Input:   pump = a pump object
+**           curve = a data curve object
+**  Output:  returns an error code
+**  Purpose: computes properties for a pump assigned a pump curve.
+**-------------------------------------------------------------------
+*/
+{
+    double a, b, c, h0 = 0.0, h1 = 0.0, h2 = 0.0, q1 = 0.0, q2 = 0.0;
+    int npts = curve->Npts;
+
+    curve->Type = PUMP_CURVE;
+
+    // Generic power function curve
+    if (npts == 1)
+    {
+        pump->Ptype = POWER_FUNC;
+        q1 = curve->X[0];
+        h1 = curve->Y[0];
+        h0 = 1.33334 * h1;
+        q2 = 2.0 * q1;
+        h2 = 0.0;
+    }
+
+    // 3 point curve with shutoff head
+    else if (npts == 3 && curve->X[0] == 0.0)
+    {
+        pump->Ptype = POWER_FUNC;
+        h0 = curve->Y[0];
+        q1 = curve->X[1];
+        h1 = curve->Y[1];
+        q2 = curve->X[2];
+        h2 = curve->Y[2];
+    }
+    else return customcurvepump(pr, pump, curve);
+
+    // Compute shape factors & limits of power function curves
+    if (!powerfuncpump(h0, h1, h2, q1, q2, &a, &b, &c))
+    {
+        pump->Ptype = NOCURVE;
+        return 227;
+    }
+    else
+    {
+        pump->H0 = -a / pr->Ucf[HEAD];
+        pump->R = -b * (pow(pr->Ucf[FLOW], c) / pr->Ucf[HEAD]);
+        pump->N = c;
+        pump->Q0 = q1 / pr->Ucf[FLOW];
+        pump->Qmax = pow((-a / b), (1.0 / c)) / pr->Ucf[FLOW];
+        pump->Hmax = h0 / pr->Ucf[HEAD];
+    }
+    return 0;
+}
+   
+int constpowerpump(Project *pr, Spump *pump)
+/*
+**-------------------------------------------------------------------
+**  Input:   pump = a pump object
+**  Output:  returns an error code
+**  Purpose: computes properties for a constant power pump.
+**-------------------------------------------------------------------
+*/
+{
+    pump->Ptype = CONST_HP;
+    pump->H0 = 0.0;
+    pump->R = -8.814 * pr->network.Link[pump->Link].Km / pr->Ucf[POWER];
+    pump->N = -1.0;
+    pump->Hmax = BIG; // No head limit
+    pump->Qmax = BIG; // No flow limit
+    pump->Q0 = 1.0;   // Init. flow = 1 cfs
+    return 0;
+}
+ 
+int validatepumps(Project *pr)
+/*
+**-------------------------------------------------------------------
+**  Input:   none
+**  Output:  returns 1 if successful, 0 if not
+**  Purpose: checks if pumps are assigned valid pump curve data.
+**-------------------------------------------------------------------
+*/
+{
+    Network *net = &pr->network;
+    int i, errcode, result = 1;
+    char errmsg[MAXMSG+1] = "";
+    Spump  *pump;
+    
+    for (i = 1; i <= net->Npumps; i++)
+    {
+        // Pump has a designated pump curve
+        pump = &net->Pump[i];
+        if (pump->Hcurve > 0)
+            errcode = pumpcurvepump(pr, pump, &net->Curve[pump->Hcurve]);
+        
+        // Pump has a constant power setting
+        else if (net->Link[pump->Link].Km > 0.0)
+            errcode = constpowerpump(pr, pump);
+        
+        // Pump has no pump curve info assigned
+        else
+        {
+            pump->Ptype = NOCURVE;
+            errcode = 226;
+        }
+        
+        if (errcode)
+        {
+            sprintf(pr->Msg, "Error %d: %s %s",
+                errcode, geterrmsg(errcode, errmsg), net->Link[pump->Link].ID);
+            writeline(pr, pr->Msg);
+            result = 0;
+        }
+    }
+    return result;
+}
+        
+int validateproject(Project *pr)
+/*
+ *--------------------------------------------------------------
+ *  Input:   none
+ *  Output:  returns error code
+ *  Purpose: checks for valid network data.
+ *--------------------------------------------------------------
+*/
+{
+    int errcode = 0;
+    if (pr->network.Nnodes < 2) return 223;
+    if (pr->network.Ntanks == 0) return 224;
+    if (!validatetanks(pr)) errcode = 110;
+    if (!validatepumps(pr)) errcode = 110;
+    if (!validatepatterns(pr)) errcode = 110;
+    if (!validatecurves(pr)) errcode = 110;
+    return errcode;
+}
+
+void reindextanks(Project *pr)
+/*
+ *--------------------------------------------------------------
+ *  Input:   none
+ *  Output:  none
+ *  Purpose: adjusts tank node indexes when the number of
+ *           junctions created from an input file is less than
+ *           the total number of junction lines in the file.
+ *--------------------------------------------------------------
+*/
+{
+    Network *net = &pr->network;
+    Parser  *parser = &pr->parser;
+    Quality *qual   = &pr->quality;
+    Scontrol *control;
+    int i, j, ndiff, n1, n2, size;
+    
+    // ndiff = # unused entries in Node array before first tank node
+    ndiff = parser->MaxJuncs - net->Njuncs;
+    if (ndiff > 0)
+    {   
+        for (i = 1; i <= net->Ntanks; ++i)
+        {
+            // n1 is current tank index in Node array, n2 is adjusted index
+            n1 = net->Tank[i].Node;
+            n2 = n1 - ndiff;
+            
+            // Update the tank node's hash table entry
+            hashtable_update(net->NodeHashTable, net->Node[n1].ID, n2);
+            
+            // Update the tank's node index
+            net->Tank[i].Node = n2;
+            
+            // Re-position tank node in Node array
+            net->Node[n2] = net->Node[n1];
+            
+            // Replace all references to old tank node index with new one
+            for (j = 1; j <= net->Nlinks; ++j)
+            {
+                if (net->Link[j].N1 == n1) net->Link[j].N1 = n2;
+                if (net->Link[j].N2 == n1) net->Link[j].N2 = n2;
+            }
+            for (j = 1; j <= net->Ncontrols; ++j)
+            {
+                control = &net->Control[j];
+                if (control->Node == n1) control->Node = n2;
+            }
+            adjusttankrules(pr, -ndiff);
+            if (qual->TraceNode == n1) qual->TraceNode = n2;
+        }
+        
+        // Reallocate the Node array (shouldn't fail as new size < old size)
+        parser->MaxJuncs = net->Njuncs;
+        parser->MaxNodes = net->Njuncs + net->Ntanks;
+        size = (net->Nnodes + 2) * sizeof(Snode);
+        net->Node = (Snode *)realloc(net->Node, size);
+    }
+}    
+    

epyt_flow/EPANET/compile_linux.sh

@@ -1,4 +1,4 @@
 #!/bin/bash
 mkdir -p "../customlibs/"
-gcc -w -O3 -march=native -shared -Wl,-soname,libepanet2_2.so -fPIC -o "../customlibs/libepanet2_2.so" EPANET/SRC_engines/*.c -IEPANET/SRC_engines/include -lc -lm -pthread
+gcc -w -O3 -march=native -shared -Wl,-soname,libepanet2_2.so -fPIC -o "../customlibs/libepanet2_2.so" EPANET/SRC_engines/*.c -IEPANET/SRC_engines/include EPANET/SRC_engines/util/*.c -IEPANET/SRC_engines/util/ -lc -lm -pthread
 gcc -w -O3 -march=native -fPIC -shared -Wl,-soname,libepanetmsx2_2_0.so -o "../customlibs/libepanetmsx2_2_0.so" -fopenmp -Depanetmsx_EXPORTS -IEPANET-MSX/Src/include -IEPANET/SRC_engines/include EPANET-MSX/Src/*.c -Wl,-rpath=. "../customlibs/libepanet2_2.so" -lm -lgomp -lpthread

epyt_flow/EPANET/compile_macos.sh

@@ -1,4 +1,4 @@
 #!/bin/bash
 mkdir -p "../customlibs/"
-gcc-15 -w -O3 -march=native -dynamiclib -fPIC -install_name libepanet2_2.dylib -o "../customlibs/libepanet2_2.dylib" EPANET/SRC_engines/*.c -IEPANET/SRC_engines/include -lc -lm -pthread
+gcc-15 -w -O3 -march=native -dynamiclib -fPIC -install_name libepanet2_2.dylib -o "../customlibs/libepanet2_2.dylib" EPANET/SRC_engines/*.c -IEPANET/SRC_engines/include EPANET/SRC_engines/util/*.c -IEPANET/SRC_engines/util/ -lc -lm -pthread
 gcc-15 -w -O3 -march=native -dynamiclib -fPIC -install_name libepanetmsx2_2_0.dylib -o "../customlibs/libepanetmsx2_2_0.dylib" -fopenmp -Depanetmsx_EXPORTS -IEPANET-MSX/Src/include -IEPANET/SRC_engines/include EPANET-MSX/Src/*.c -L'../customlibs' -lepanet2_2 -lm -lgomp -lpthread

epyt_flow/VERSION

@@ -1 +1 @@
-0.14.0
+0.14.1

epyt_flow/gym/scenario_control_env.py

@@ -23,6 +23,10 @@ class ScenarioControlEnv(ABC):
     autoreset : `bool`, optional
         If True, environment is automatically reset if terminated.
 
+        The default is False.
+    reapply_uncertainties_at_reset : `bool`, optional
+        If True, the uncertainties are re-applied to the original properties at each reset.
+
         The default is False.
 
     Attributes
@@ -36,7 +40,9 @@ class ScenarioControlEnv(ABC):
     _hydraulic_scada_data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData`, protected
         SCADA data from the hydraulic simulation -- only used if EPANET-MSX is used in the control scenario.
     """
-    def __init__(self, scenario_config: ScenarioConfig, autoreset: bool = False, **kwds):
+    def __init__(self, scenario_config: ScenarioConfig, autoreset: bool = False,
+                 reapply_uncertainties_at_reset: bool = False,
+                 **kwds):
         if not isinstance(scenario_config, ScenarioConfig):
             raise TypeError("'scenario_config' must be an instance of " +
                             "'epyt_flow.simulation.ScenarioConfig' " +
@@ -44,12 +50,15 @@ class ScenarioControlEnv(ABC):
         if not isinstance(autoreset, bool):
             raise TypeError("'autoreset' must be an instance of 'bool' " +
                             f"but not of '{type(autoreset)}'")
+        if not isinstance(reapply_uncertainties_at_reset, bool):
+            raise TypeError("")
 
         self._scenario_config = scenario_config
         self._scenario_sim = None
         self._sim_generator = None
         self.__autoreset = autoreset
         self._hydraulic_scada_data = None
+        self.__reapply_uncertainties_at_reset = reapply_uncertainties_at_reset
 
         super().__init__(**kwds)
 
@@ -65,6 +74,18 @@ class ScenarioControlEnv(ABC):
         """
         return self.__autoreset
 
+    @property
+    def reapply_uncertainties_at_reset(self) -> bool:
+        """
+        True, if the uncertainties are re-applied to the original properties at each reset.
+
+        Returns
+        -------
+        `bool`
+            True, if the uncertainties are re-applied to the original properties at each reset.
+        """
+        return self.__reapply_uncertainties_at_reset
+
     def __enter__(self):
         return self
 
@@ -117,14 +138,16 @@ class ScenarioControlEnv(ABC):
             # Run hydraulic simulation first
             hyd_export = os.path.join(get_temp_folder(), f"epytflow_env_MSX_{uuid.uuid4()}.hyd")
             sim = self._scenario_sim.run_hydraulic_simulation
-            self._hydraulic_scada_data = sim(hyd_export=hyd_export)
+            self._hydraulic_scada_data = sim(hyd_export=hyd_export,
+                                             reapply_uncertainties=self.__reapply_uncertainties_at_reset)
 
             # Run advanced quality analysis (EPANET-MSX) on top of the computed hydraulics
             gen = self._scenario_sim.run_advanced_quality_simulation_as_generator
             self._sim_generator = gen(hyd_export, support_abort=True)
         else:
             gen = self._scenario_sim.run_hydraulic_simulation_as_generator
-            self._sim_generator = gen(support_abort=True)
+            self._sim_generator = gen(support_abort=True,
+                                      reapply_uncertainties=self.__reapply_uncertainties_at_reset)
 
         return self._next_sim_itr()
 

epyt_flow/simulation/events/quality_events.py

@@ -64,7 +64,7 @@ class SpeciesInjectionEvent(SystemEvent, JsonSerializable):
 
         self.__species_id = species_id
         self.__node_id = node_id
-        self.__profile = profile
+        self._profile = profile
         self.__source_type = source_type
 
         super().__init__(**kwds)
@@ -103,7 +103,7 @@ class SpeciesInjectionEvent(SystemEvent, JsonSerializable):
         `numpy.ndarray`
             Pattern of the injection.
         """
-        return deepcopy(self.__profile)
+        return deepcopy(self._profile)
 
     @property
     def source_type(self) -> int:
@@ -125,17 +125,17 @@ class SpeciesInjectionEvent(SystemEvent, JsonSerializable):
 
     def get_attributes(self) -> dict:
         return super().get_attributes() | {"species_id": self.__species_id,
-                                           "node_id": self.__node_id, "profile": self.__profile,
+                                           "node_id": self.__node_id, "profile": self._profile,
                                            "source_type": self.__source_type}
 
     def __eq__(self, other) -> bool:
         return super().__eq__(other) and self.__species_id == other.species_id and \
-            self.__node_id == other.node_id and np.all(self.__profile == other.profile) and \
+            self.__node_id == other.node_id and np.all(self._profile == other.profile) and \
             self.__source_type == other.source_type
 
     def __str__(self) -> str:
         return f"{super().__str__()} species_id: {self.__species_id} " +\
-            f"node_id: {self.__node_id} profile: {self.__profile} source_type: {self.__source_type}"
+            f"node_id: {self.__node_id} profile: {self._profile} source_type: {self.__source_type}"
 
     def _get_pattern_id(self) -> str:
         return f"{self.__species_id}_{self.__node_id}"
@@ -160,7 +160,7 @@ class SpeciesInjectionEvent(SystemEvent, JsonSerializable):
         injection_time_start_idx = int(self.start_time / time_step)
 
         injection_pattern = None
-        if len(self.__profile) == injection_pattern_length:
+        if len(self._profile) == injection_pattern_length:
             injection_pattern = self.profile
         else:
             injection_pattern = np.tile(self.profile,

epyt_flow/simulation/events/sensor_faults.py

@@ -93,7 +93,7 @@ class SensorFaultConstant(SensorFault, JsonSerializable):
             raise TypeError("'constant_shift' must be an instance of 'float' but no of " +
                             f"'{type(constant_shift)}'")
 
-        self.__constant_shift = constant_shift
+        self._constant_shift = constant_shift
 
         super().__init__(**kwds)
 
@@ -107,20 +107,20 @@ class SensorFaultConstant(SensorFault, JsonSerializable):
         `float`
             Constant that is added to the sensor reading.
         """
-        return self.__constant_shift
+        return self._constant_shift
 
     def get_attributes(self) -> dict:
-        return super().get_attributes() | {"constant_shift": self.__constant_shift}
+        return super().get_attributes() | {"constant_shift": self._constant_shift}
 
     def __eq__(self, other) -> bool:
-        return super().__eq__(other) and self.__constant_shift == other.constant_shift
+        return super().__eq__(other) and self._constant_shift == other.constant_shift
 
     def __str__(self) -> str:
-        return f"{type(self).__name__} {super().__str__()} constant: {self.__constant_shift}"
+        return f"{type(self).__name__} {super().__str__()} constant: {self._constant_shift}"
 
     def apply_sensor_fault(self, cur_multiplier: float, sensor_reading: float,
                            cur_time: int) -> float:
-        return sensor_reading + cur_multiplier * self.__constant_shift
+        return sensor_reading + cur_multiplier * self._constant_shift
 
 
 @serializable(SENSOR_FAULT_DRIFT_ID, ".epytflow_sensorfault_drift")
@@ -134,7 +134,7 @@ class SensorFaultDrift(SensorFault, JsonSerializable):
         Coefficient of the drift.
     """
     def __init__(self, coef: float, **kwds):
-        self.__coef = coef
+        self._coef = coef
 
         super().__init__(**kwds)
 
@@ -148,20 +148,20 @@ class SensorFaultDrift(SensorFault, JsonSerializable):
         `float`
             Coefficient of the drift.
         """
-        return self.__coef
+        return self._coef
 
     def get_attributes(self) -> dict:
-        return super().get_attributes() | {"coef": self.__coef}
+        return super().get_attributes() | {"coef": self._coef}
 
     def __eq__(self, other) -> bool:
-        return super().__eq__(other) and self.__coef == other.coef
+        return super().__eq__(other) and self._coef == other.coef
 
     def __str__(self) -> str:
-        return f"{type(self).__name__} {super().__str__()} coef: {self.__coef}"
+        return f"{type(self).__name__} {super().__str__()} coef: {self._coef}"
 
     def apply_sensor_fault(self, cur_multiplier: float, sensor_reading: float,
                            cur_time: int) -> float:
-        return sensor_reading + cur_multiplier * (self.__coef * (cur_time - self.start_time))
+        return sensor_reading + cur_multiplier * (self._coef * (cur_time - self.start_time))
 
 
 @serializable(SENSOR_FAULT_GAUSSIAN_ID, ".epytflow_sensorfault_gaussian")
@@ -179,7 +179,7 @@ class SensorFaultGaussian(SensorFault, JsonSerializable):
         if not isinstance(std, float) or not std > 0:
             raise ValueError("'std' must be an instance of 'float' and be greater than 0")
 
-        self.__std = std
+        self._std = std
 
         super().__init__(**kwds)
 
@@ -193,20 +193,20 @@ class SensorFaultGaussian(SensorFault, JsonSerializable):
         `float`
             Standard deviation of the Gaussian noise.
         """
-        return self.__std
+        return self._std
 
     def get_attributes(self) -> dict:
-        return super().get_attributes() | {"std": self.__std}
+        return super().get_attributes() | {"std": self._std}
 
     def __eq__(self, other) -> bool:
-        return super().__eq__(other) and self.__std == other.std
+        return super().__eq__(other) and self._std == other.std
 
     def __str__(self) -> str:
-        return f"{type(self).__name__} {super().__str__()} std: {self.__std}"
+        return f"{type(self).__name__} {super().__str__()} std: {self._std}"
 
     def apply_sensor_fault(self, cur_multiplier: float, sensor_reading: float,
                            cur_time: int) -> float:
-        return sensor_reading + cur_multiplier * np.random.normal(loc=0, scale=self.__std)
+        return sensor_reading + cur_multiplier * np.random.normal(loc=0, scale=self._std)
 
 
 @serializable(SENSOR_FAULT_PERCENTAGE_ID, ".epytflow_sensorfault_percentage",)
@@ -223,7 +223,7 @@ class SensorFaultPercentage(SensorFault, JsonSerializable):
         if not isinstance(coef, float) or not coef > 0:
             raise ValueError("'coef' must be an instance of 'float' and be greater than zero.")
 
-        self.__coef = coef
+        self._coef = coef
 
         super().__init__(**kwds)
 
@@ -237,20 +237,20 @@ class SensorFaultPercentage(SensorFault, JsonSerializable):
         `float`
             Coefficient (percentage) of the shift.
         """
-        return self.__coef
+        return self._coef
 
     def get_attributes(self) -> dict:
-        return super().get_attributes() | {"coef": self.__coef}
+        return super().get_attributes() | {"coef": self._coef}
 
     def __eq__(self, other) -> bool:
-        return super().__eq__(other) and self.__coef == other.coef
+        return super().__eq__(other) and self._coef == other.coef
 
     def __str__(self) -> str:
-        return f"{type(self).__name__} {super().__str__()} coef: {self.__coef}"
+        return f"{type(self).__name__} {super().__str__()} coef: {self._coef}"
 
     def apply_sensor_fault(self, cur_multiplier: float, sensor_reading: float,
                            cur_time: int) -> float:
-        return sensor_reading + cur_multiplier * self.__coef * sensor_reading
+        return sensor_reading + cur_multiplier * self._coef * sensor_reading
 
 
 @serializable(SENSOR_FAULT_STUCKATZERO_ID, ".epytflow_sensorfault_zero")