pyvale 2025.4.1__py3-none-any.whl → 2025.5.1__py3-none-any.whl

pyvale/errorcalculator.py

@@ -1,8 +1,8 @@
-# ================================================================================
+# ==============================================================================
 # pyvale: the python validation engine
 # License: MIT
 # Copyright (C) 2025 The Computer Aided Validation Team
-# ================================================================================
+# ==============================================================================
 
 import enum
 from abc import ABC, abstractmethod
@@ -27,14 +27,14 @@ class EErrType(enum.Enum):
     RANDOM = enum.auto()
 
 
-class EErrDependence(enum.Enum):
+class EErrDep(enum.Enum):
     """Enumeration defining error dependence.
 
-    EErrDependence.INDEPENDENT:
+    EErrDep.INDEPENDENT:
         Errors are calculated based on the ground truth sensor values
         interpolated from the input simulation.
 
-    EErrDependence.DEPENDENT:
+    EErrDep.DEPENDENT:
         Errors are calculated based on the accumulated sensor reading due
         to all preceeding errors in the chain.
     """
@@ -46,6 +46,7 @@ class IErrCalculator(ABC):
     """Interface (abstract base class) for sensor error calculation allowing for
     chaining of errors.
     """
+
     @abstractmethod
     def get_error_type(self) -> EErrType:
         """Abstract method for getting the error type.
@@ -55,10 +56,9 @@ class IErrCalculator(ABC):
         EErrType
             Enumeration definining RANDOM or SYSTEMATIC error types.
         """
-        pass
 
     @abstractmethod
-    def get_error_dep(self) -> EErrDependence:
+    def get_error_dep(self) -> EErrDep:
         """Abstract method for getting the error dependence.
 
         Returns
@@ -66,10 +66,9 @@ class IErrCalculator(ABC):
         EErrDependence
             Enumeration definining RANDOM or SYSTEMATIC error types.
         """
-        pass
 
     @abstractmethod
-    def set_error_dep(self, dependence: EErrDependence) -> None:
+    def set_error_dep(self, dependence: EErrDep) -> None:
         """Abstract method for setting the error dependence.
 
         Parameters
@@ -104,7 +103,6 @@ class IErrCalculator(ABC):
             the error chain. Note that many errors do not modify the sensor data
             so the sensor data class is passed through this function unchanged.
         """
-        pass
 
 
 

pyvale/errordriftcalc.py

@@ -1,8 +1,8 @@
-# ================================================================================
+# ==============================================================================
 # pyvale: the python validation engine
 # License: MIT
 # Copyright (C) 2025 The Computer Aided Validation Team
-# ================================================================================
+# ==============================================================================
 
 from abc import ABC, abstractmethod
 import numpy as np
@@ -32,7 +32,6 @@ class IDriftCalculator(ABC):
             Array of drift errors having the same shape as the input drift_var
             array.
         """
-        pass
 
 
 class DriftConstant(IDriftCalculator):
@@ -40,9 +39,10 @@ class DriftConstant(IDriftCalculator):
 
     Implements the IDriftCalculator interface.
     """
-    def __init__(self, offset: float) -> None:
-        """Initialiser for the `DriftConstant` class.
+    __slots__ = ("_offset",)
 
+    def __init__(self, offset: float) -> None:
+        """
         Parameters
         ----------
         offset : float
@@ -73,10 +73,10 @@ class DriftLinear(IDriftCalculator):
 
     Implements the IDriftCalculator interface.
     """
+    __slots__ = ("_slope","_offset")
 
     def __init__(self, slope: float, offset: float = 0.0) -> None:
-        """Initialiser for the `DriftLinear` class.
-
+        """
         Parameters
         ----------
         slope : float
@@ -113,9 +113,10 @@ class DriftPolynomial(IDriftCalculator):
     Implements the IDriftCalculator interface.
     """
 
-    def __init__(self, coeffs: np.ndarray) -> None:
-        """Initialiser for the `DriftPolynomial` class.
+    __slots__ = ("_coeffs",)
 
+    def __init__(self, coeffs: np.ndarray) -> None:
+        """
         Parameters
         ----------
         coeffs : np.ndarray

pyvale/errorintegrator.py

@@ -1,15 +1,15 @@
-# ================================================================================
+# ==============================================================================
 # pyvale: the python validation engine
 # License: MIT
 # Copyright (C) 2025 The Computer Aided Validation Team
-# ================================================================================
+# ==============================================================================
 
 import copy
 from dataclasses import dataclass
 import numpy as np
 from pyvale.errorcalculator import (IErrCalculator,
-                                        EErrType,
-                                        EErrDependence)
+                                    EErrType,
+                                    EErrDep)
 from pyvale.sensordata import SensorData
 
 
@@ -19,12 +19,9 @@ class ErrIntOpts:
     errors are calculated and stored in memory for later use.
     """
 
-    force_dependence: bool = False
-    """Forces all errors to be calculated as dependent if True. Otherwise errors
-    will use individual dependence set in the errors initialiser. Independent
-    errors are calculated based on the ground truth whereas dependent errors are
-    calculated based on the accumulated sensor measurement at that stage in the
-    error chain.
+    force_dependence: EErrDep | None = None
+    """Forces all errors to be calculated with the specified dependence. If set
+    to None then all errors will use their default/preset dependence.
 
     Note that some errors are inherently independent so will not change. For
     example: `ErrRandNormal` is purely independent whereas `ErrRandNormPercent`
@@ -71,8 +68,7 @@ class ErrIntegrator:
                  sensor_data_initial: SensorData,
                  meas_shape: tuple[int,int,int],
                  err_int_opts: ErrIntOpts | None = None) -> None:
-        """Initialiser for the `ErrIntegrator` class.
-
+        """
         Parameters
         ----------
         err_chain : list[IErrCalculator]
@@ -117,7 +113,7 @@ class ErrIntegrator:
         """Sets the error chain that will be looped over to calculate the sensor
         measurement errors. If the error integration options are forcing error
         dependence then all errors in the chain will have their dependence set
-        to `EErrDependence.DEPENDENT`.
+        to the specified value.
 
         Parameters
         ----------
@@ -126,9 +122,9 @@ class ErrIntegrator:
         """
         self._err_chain = err_chain
 
-        if self._err_int_opts.force_dependence:
+        if self._err_int_opts.force_dependence is not None:
             for ee in self._err_chain:
-                ee.set_error_dep(EErrDependence.DEPENDENT)
+                ee.set_error_dep(self._err_int_opts.force_dependence)
 
 
     def calc_errors_from_chain(self, truth: np.ndarray) -> np.ndarray:
@@ -187,14 +183,15 @@ class ErrIntegrator:
 
         for ii,ee in enumerate(self._err_chain):
 
-            if ee.get_error_dep() == EErrDependence.DEPENDENT:
+            if ee.get_error_dep() == EErrDep.DEPENDENT:
                 (error_array,sens_data) = ee.calc_errs(truth+accumulated_error,
                                                        self._sens_data_accumulated)
-                self._sens_data_accumulated = sens_data
+
             else:
                 (error_array,sens_data) = ee.calc_errs(truth,
                                                        self._sens_data_initial)
 
+            self._sens_data_accumulated = sens_data
             self._sens_data_by_chain.append(sens_data)
 
             if ee.get_error_type() == EErrType.SYSTEMATIC:
@@ -233,10 +230,11 @@ class ErrIntegrator:
 
         for ee in self._err_chain:
 
-            if ee.get_error_dep() == EErrDependence.DEPENDENT:
-                (error_array,sens_data) = ee.calc_errs(truth+accumulated_error,
-                                                       self._sens_data_accumulated)
-                self._sens_data_accumulated = sens_data
+            if ee.get_error_dep() == EErrDep.DEPENDENT:
+                (error_array,sens_data) = ee.calc_errs(
+                    truth+accumulated_error,
+                    self._sens_data_accumulated
+                )
             else:
                 (error_array,sens_data) = ee.calc_errs(truth,
                                                        self._sens_data_initial)

pyvale/errorrand.py

@@ -1,18 +1,18 @@
-# ================================================================================
+# ==============================================================================
 # pyvale: the python validation engine
 # License: MIT
 # Copyright (C) 2025 The Computer Aided Validation Team
-# ================================================================================
+# ==============================================================================
 
 import numpy as np
 from pyvale.sensordata import SensorData
 from pyvale.errorcalculator import (IErrCalculator,
                                          EErrType,
-                                         EErrDependence)
-from pyvale.generatorsrandom import IGeneratorRandom
+                                         EErrDep)
+from pyvale.generatorsrandom import IGenRandom
 
 
-class ErrRandUniform(IErrCalculator):
+class ErrRandUnif(IErrCalculator):
     """Random error calculator based on uniform sampling of an interval
     specified by its upper and lower bound.
 
@@ -23,10 +23,9 @@ class ErrRandUniform(IErrCalculator):
     def __init__(self,
                  low: float,
                  high: float,
-                 err_dep: EErrDependence = EErrDependence.INDEPENDENT,
+                 err_dep: EErrDep = EErrDep.INDEPENDENT,
                  seed: int | None = None) -> None:
-        """Initialiser for `ErrRandUniform` class.
-
+        """
         Parameters
         ----------
         low : float
@@ -54,7 +53,7 @@ class ErrRandUniform(IErrCalculator):
         self.rng = np.random.default_rng(seed)
         self.err_dep = err_dep
 
-    def get_error_dep(self) -> EErrDependence:
+    def get_error_dep(self) -> EErrDep:
         """Gets the error dependence state for this error calculator. An
         independent error is calculated based on the input truth values as the
         error basis. A dependent error is calculated based on the accumulated
@@ -69,7 +68,7 @@ class ErrRandUniform(IErrCalculator):
         """
         return self.err_dep
 
-    def set_error_dep(self, dependence: EErrDependence) -> None:
+    def set_error_dep(self, dependence: EErrDep) -> None:
         """Sets the error dependence state for this error calculator. An
         independent error is calculated based on the input truth values as the
         error basis. A dependent error is calculated based on the accumulated
@@ -138,10 +137,9 @@ class ErrRandUnifPercent(IErrCalculator):
     def __init__(self,
                  low_percent: float,
                  high_percent: float,
-                 err_dep: EErrDependence = EErrDependence.INDEPENDENT,
+                 err_dep: EErrDep = EErrDep.INDEPENDENT,
                  seed: int | None = None) -> None:
-        """Initialiser for the `ErrRandUnifPercent` class.
-
+        """
         Parameters
         ----------
         low_percent : float
@@ -170,7 +168,7 @@ class ErrRandUnifPercent(IErrCalculator):
         self.rng = np.random.default_rng(seed)
         self.err_dep = err_dep
 
-    def get_error_dep(self) -> EErrDependence:
+    def get_error_dep(self) -> EErrDep:
         """Gets the error dependence state for this error calculator. An
         independent error is calculated based on the input truth values as the
         error basis. A dependent error is calculated based on the accumulated
@@ -183,7 +181,7 @@ class ErrRandUnifPercent(IErrCalculator):
         """
         return self.err_dep
 
-    def set_error_dep(self, dependence: EErrDependence) -> None:
+    def set_error_dep(self, dependence: EErrDep) -> None:
         """Sets the error dependence state for this error calculator. An
         independent error is calculated based on the input truth values as the
         error basis. A dependent error is calculated based on the accumulated
@@ -234,7 +232,7 @@ class ErrRandUnifPercent(IErrCalculator):
         return (err_basis*norm_rand,sens_data)
 
 
-class ErrRandNormal(IErrCalculator):
+class ErrRandNorm(IErrCalculator):
     """Random error calculator based on sampling of a normal (Gaussian)
     distribution specified using the standard deviation with an assumed zero
     mean. A non-zero mean is a systematic error and should be specified using
@@ -246,10 +244,9 @@ class ErrRandNormal(IErrCalculator):
 
     def __init__(self,
                  std: float,
-                 err_dep: EErrDependence = EErrDependence.INDEPENDENT,
+                 err_dep: EErrDep = EErrDep.INDEPENDENT,
                  seed: int | None = None) -> None:
-        """Initialiser for `ErrRandNormal` class.
-
+        """
         Parameters
         ----------
         std : float
@@ -264,7 +261,7 @@ class ErrRandNormal(IErrCalculator):
         self.rng = np.random.default_rng(seed)
         self.err_dep = err_dep
 
-    def get_error_dep(self) -> EErrDependence:
+    def get_error_dep(self) -> EErrDep:
         """Gets the error dependence state for this error calculator. An
         independent error is calculated based on the input truth values as the
         error basis. A dependent error is calculated based on the accumulated
@@ -279,7 +276,7 @@ class ErrRandNormal(IErrCalculator):
         """
         return self.err_dep
 
-    def set_error_dep(self, dependence: EErrDependence) -> None:
+    def set_error_dep(self, dependence: EErrDep) -> None:
         """Sets the error dependence state for this error calculator. An
         independent error is calculated based on the input truth values as the
         error basis. A dependent error is calculated based on the accumulated
@@ -349,10 +346,9 @@ class ErrRandNormPercent(IErrCalculator):
 
     def __init__(self,
                  std_percent: float,
-                 err_dep: EErrDependence = EErrDependence.INDEPENDENT,
+                 err_dep: EErrDep = EErrDep.INDEPENDENT,
                  seed: int | None = None) -> None:
-        """Initialiser for `ErrRandNormPercent` class.
-
+        """
         Parameters
         ----------
         std_percent : float
@@ -368,7 +364,7 @@ class ErrRandNormPercent(IErrCalculator):
         self._rng = np.random.default_rng(seed)
         self._err_dep = err_dep
 
-    def get_error_dep(self) -> EErrDependence:
+    def get_error_dep(self) -> EErrDep:
         """Gets the error dependence state for this error calculator. An
         independent error is calculated based on the input truth values as the
         error basis. A dependent error is calculated based on the accumulated
@@ -381,7 +377,7 @@ class ErrRandNormPercent(IErrCalculator):
         """
         return self._err_dep
 
-    def set_error_dep(self, dependence: EErrDependence) -> None:
+    def set_error_dep(self, dependence: EErrDep) -> None:
         """Sets the error dependence state for this error calculator. An
         independent error is calculated based on the input truth values as the
         error basis. A dependent error is calculated based on the accumulated
@@ -441,10 +437,9 @@ class ErrRandGenerator(IErrCalculator):
     __slots__ = ("_generator","_err_dep")
 
     def __init__(self,
-                 generator: IGeneratorRandom,
-                 err_dep: EErrDependence = EErrDependence.INDEPENDENT) -> None:
-        """Initiliaser for the `ErrRandGenerator` class.
-
+                 generator: IGenRandom,
+                 err_dep: EErrDep = EErrDep.INDEPENDENT) -> None:
+        """
         Parameters
         ----------
         generator : IGeneratorRandom
@@ -455,7 +450,7 @@ class ErrRandGenerator(IErrCalculator):
         self._generator = generator
         self._err_dep = err_dep
 
-    def get_error_dep(self) -> EErrDependence:
+    def get_error_dep(self) -> EErrDep:
         """Gets the error dependence state for this error calculator. An
         independent error is calculated based on the input truth values as the
         error basis. A dependent error is calculated based on the accumulated
@@ -470,7 +465,7 @@ class ErrRandGenerator(IErrCalculator):
         """
         return self._err_dep
 
-    def set_error_dep(self, dependence: EErrDependence) -> None:
+    def set_error_dep(self, dependence: EErrDep) -> None:
         """Sets the error dependence state for this error calculator. An
         independent error is calculated based on the input truth values as the
         error basis. A dependent error is calculated based on the accumulated
@@ -536,10 +531,9 @@ class ErrRandGenPercent(IErrCalculator):
     __slots__ = ("_generator","_err_dep")
 
     def __init__(self,
-                 generator: IGeneratorRandom,
-                 err_dep: EErrDependence = EErrDependence.INDEPENDENT) -> None:
-        """Initiliaser for the `ErrRandGenerator` class.
-
+                 generator: IGenRandom,
+                 err_dep: EErrDep = EErrDep.INDEPENDENT) -> None:
+        """
         Parameters
         ----------
         generator : IGeneratorRandom
@@ -550,7 +544,7 @@ class ErrRandGenPercent(IErrCalculator):
         self._generator = generator
         self._err_dep = err_dep
 
-    def get_error_dep(self) -> EErrDependence:
+    def get_error_dep(self) -> EErrDep:
         """Gets the error dependence state for this error calculator. An
         independent error is calculated based on the input truth values as the
         error basis. A dependent error is calculated based on the accumulated
@@ -563,7 +557,7 @@ class ErrRandGenPercent(IErrCalculator):
         """
         return self._err_dep
 
-    def set_error_dep(self, dependence: EErrDependence) -> None:
+    def set_error_dep(self, dependence: EErrDep) -> None:
         """Sets the error dependence state for this error calculator. An
         independent error is calculated based on the input truth values as the
         error basis. A dependent error is calculated based on the accumulated
@@ -608,6 +602,6 @@ class ErrRandGenPercent(IErrCalculator):
             error array has the same shape as the input error basis.
         """
         rand_errs = err_basis \
-            * self._generator.generate(shape=err_basis.shape)/100
+            * self._generator.generate(shape=err_basis.shape)/100.0
 
         return (rand_errs,sens_data)

pyvale/errorsyscalib.py

@@ -0,0 +1,134 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+from typing import Callable
+import numpy as np
+from pyvale.errorcalculator import (IErrCalculator,
+                                         EErrType,
+                                         EErrDep)
+from pyvale.sensordata import SensorData
+
+# TODO: add option to use Newton's method for function inversion instead of a
+# cal table.
+
+class ErrSysCalibration(IErrCalculator):
+    """Systematic error calculator for calibration errors. The user specifies an
+    assumed calibration and a ground truth calibration function. The ground
+    truth calibration function is inverted and linearly interpolated numerically
+    based on the number of divisions specified by the user.
+
+    Implements the `IErrCalculator` interface.
+    """
+    __slots__ = ("_assumed_cali","_truth_calib","_cal_range","_n_cal_divs",
+                 "_err_dep","_truth_calc_table")
+
+    def __init__(self,
+                 assumed_calib: Callable[[np.ndarray],np.ndarray],
+                 truth_calib: Callable[[np.ndarray],np.ndarray],
+                 cal_range: tuple[float,float],
+                 n_cal_divs: int = 10000,
+                 err_dep: EErrDep = EErrDep.INDEPENDENT) -> None:
+        """
+        Parameters
+        ----------
+        assumed_calib : Callable[[np.ndarray],np.ndarray]
+            Assumed calibration function taking the input unitless 'signal' and
+            converting it to the same units as the physical field being sampled
+            by the sensor array.
+        truth_calib : Callable[[np.ndarray],np.ndarray]
+            Assumed calibration function taking the input unitless 'signal' and
+            converting it to the same units as the physical field being sampled
+            by the sensor array.
+        cal_range : tuple[float,float]
+            Range over which the calibration functions are valid. This is
+            normally based on a voltage range such as (0,10) volts.
+        n_cal_divs : int, optional
+            Number of divisions to discretise the the truth calibration function
+            for numerical inversion, by default 10000.
+        err_dep : EErrDependence, optional
+            Error calculation dependence, by default EErrDependence.INDEPENDENT.
+        """
+        self._assumed_calib = assumed_calib
+        self._truth_calib = truth_calib
+        self._cal_range = cal_range
+        self._n_cal_divs = n_cal_divs
+        self._err_dep = err_dep
+
+        self._truth_cal_table = np.zeros((n_cal_divs,2))
+        self._truth_cal_table[:,0] = np.linspace(cal_range[0],
+                                                cal_range[1],
+                                                n_cal_divs)
+        self._truth_cal_table[:,1] = self._truth_calib(
+                                        self._truth_cal_table[:,0])
+
+    def get_error_dep(self) -> EErrDep:
+        """Gets the error dependence state for this error calculator. An
+        independent error is calculated based on the input truth values as the
+        error basis. A dependent error is calculated based on the accumulated
+        sensor reading from all preceeding errors in the chain.
+
+        Returns
+        -------
+        EErrDependence
+            Enumeration defining INDEPENDENT or DEPENDENT behaviour.
+        """
+        return self._err_dep
+
+    def set_error_dep(self, dependence: EErrDep) -> None:
+        """Sets the error dependence state for this error calculator. An
+        independent error is calculated based on the input truth values as the
+        error basis. A dependent error is calculated based on the accumulated
+        sensor reading from all preceeding errors in the chain.
+
+        Parameters
+        ----------
+        dependence : EErrDependence
+            Enumeration defining INDEPENDENT or DEPENDENT behaviour.
+        """
+        self._err_dep = dependence
+
+    def get_error_type(self) -> EErrType:
+        """Gets the error type.
+
+        Returns
+        -------
+        EErrType
+            Enumeration definining RANDOM or SYSTEMATIC error types.
+        """
+        return EErrType.SYSTEMATIC
+
+    def calc_errs(self,
+                  err_basis: np.ndarray,
+                  sens_data: SensorData,
+                  ) -> tuple[np.ndarray, SensorData]:
+        """Calculates the error array based on the size of the input.
+
+        Parameters
+        ----------
+        err_basis : np.ndarray
+            Array of values with the same dimensions as the sensor measurement
+            matrix.
+        sens_data : SensorData
+            The accumulated sensor state data for all errors prior to this one.
+
+        Returns
+        -------
+        tuple[np.ndarray, SensorData]
+            Tuple containing the calculated error array and pass through of the
+            sensor data object as it is not modified by this class. The returned
+            error array has the same shape as the input error basis.
+        """
+        # shape=(n_sens,n_comps,n_time_steps)
+        signal_from_field = np.interp(err_basis,
+                                    self._truth_cal_table[:,1],
+                                    self._truth_cal_table[:,0])
+        # shape=(n_sens,n_comps,n_time_steps)
+        field_from_assumed_calib = self._assumed_calib(signal_from_field)
+
+        sys_errs = field_from_assumed_calib - err_basis
+
+        return (sys_errs,sens_data)
+