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

pyvale/{core/dataset.py → dataset.py}

@@ -1,30 +1,66 @@
+#===============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+#===============================================================================
+
 """
-================================================================================
-pyvale: the python validation engine
-License: MIT
-Copyright (C) 2025 The Computer Aided Validation Team
-================================================================================
+Accesors for data that comes pre-packaged with pyvale for demonstrating its
+functionality. This includes moose simulation outputs as exodus files, input
+files for moose and gmsh for additional simulation cases, and images required
+for testing the image deformation and digital image correlation modules.
 """
+
+from enum import Enum
 from pathlib import Path
 from importlib.resources import files
 
 
 SIM_CASE_COUNT = 26
+"""Constant describing the number of simulation test case input files for moose
+and gmsh that come packaged with pyvale.
+"""
+
+class EElemTest(Enum):
+    """Enumeration used to specify different 3D element types for extracting
+    specific test simulation datasets.
+    """
+
+    TET4 = "TET4"
+    """Tetrahedral element, linear with 4 nodes.
+    """
+
+    TET10 = "TET10"
+    """Tetrahedral element, quadratic with 10 nodes.
+    """
+
+    TET14 = "TET14"
+    """Tetrahedral element, quadratic with 14 nodes.
+    """
+
+    HEX8 = "HEX8"
+    """Hexahedral element, linear with 8 nodes.
+    """
+
+    HEX20 = "HEX20"
+    """Hexahedral element, quadratic with 20 nodes.
+    """
+
+    HEX27 = "HEX27"
+    """Hexahedral element, quadratic with 27 nodes.
+    """
+
+    def __str__(self):
+        return self.value
 
 
 class DataSetError(Exception):
     """Custom error class for file io errors associated with retrieving datasets
     and files packaged with pyvale.
     """
-    pass
 
 
 class DataSet:
-    """A static namespace class for handling datasets packaged with pyvale.
-    Contains a series of static methods returning a Path object to each data
-    file that is packaged with pyvale.
-    """
-
     @staticmethod
     def sim_case_input_file_path(case_num: int) -> Path:
         """Gets the path to MOOSE input file (*.i) for a particular simulation
@@ -50,7 +86,7 @@ class DataSet:
             raise DataSetError("Simulation case number must be greater than 0")
         elif case_num > SIM_CASE_COUNT:
             raise DataSetError("Simulation case number must be less than " \
-                               + f"{SIM_CASE_COUNT}")
+                                + f"{SIM_CASE_COUNT}")
 
         case_num_str = str(case_num).zfill(2)
         case_file = f"case{case_num_str}.i"
@@ -85,7 +121,7 @@ class DataSet:
             raise DataSetError("Simulation case number must be greater than 0")
         elif case_num > SIM_CASE_COUNT:
             raise DataSetError("Simulation case number must be less than " \
-                               + f"{SIM_CASE_COUNT}")
+                                + f"{SIM_CASE_COUNT}")
 
         case_num_str = str(case_num).zfill(2)
         case_file = f"case{case_num_str}.geo"
@@ -236,15 +272,54 @@ class DataSet:
 
     @staticmethod
     def render_mechanical_3d_path() -> Path:
-        """_summary_
+        """Path to a MOOSE simulation output in exodus format. This case is a
+        purely mechanical test case in 3D meant for testing image rendering
+        algorithms for digital image correlation simulation. The simulation
+        consists of a linear elastic thin plate with a hole loaded in tension.
+        The simulation uses linear tetrahedral elements for rendering tests.
 
         Returns
         -------
         Path
-            _description_
+            Path to the exodus (*.e) output file for this simulation case.
         """
         return Path(files("pyvale.data").joinpath("case26_out.e"))
 
     @staticmethod
     def render_simple_block_path() -> Path:
-        return Path(files("pyvale.data").joinpath("case25_out.e"))
+        """Path to a MOOSE simulation output in exodus format. This case is a
+        a simple rectangular block in 3D loaded in tension. It uses a minimum
+        number of elements and is intended purely for testing image rendering
+        algorithms. This simulation uses linear tetrahedral elements.
+
+        Returns
+        -------
+        Path
+            Path to the exodus (*.e) output file for this simulation case.
+        """
+        return Path(files("pyvale.data").joinpath("case25_out.e"))
+
+    @staticmethod
+    def element_case_path(elem_type: EElemTest) -> Path:
+        """Path to a MOOSE simulation output in exodus format. This case is a
+        10mm cube undergoing thermo-mechanical loading solved for the
+        temperature displacement and strain fields. This case is solved using a
+        variety of tetrahedral and hexahedral elements with linear or quadratic
+        shapes functions. These simulation cases are intended for testing
+        purposes and contain a minimal number of elements.
+
+        Parameters
+        ----------
+        elem_type : EElemTest
+            Enumeration specifying the element type for this test case.
+
+        Returns
+        -------
+        Path
+            Path to the exodus (*.e) output file for this simulation case.
+        """
+        return Path(files("pyvale.data")
+                    .joinpath(f"case00_{elem_type.value}_out.e"))
+
+
+

pyvale/{core/errorcalculator.py → errorcalculator.py}

@@ -1,14 +1,13 @@
-"""
-================================================================================
-pyvale: the python validation engine
-License: MIT
-Copyright (C) 2025 The Computer Aided Validation Team
-================================================================================
-"""
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
 import enum
 from abc import ABC, abstractmethod
 import numpy as np
-from pyvale.core.sensordata import SensorData
+from pyvale.sensordata import SensorData
 
 
 class EErrType(enum.Enum):
@@ -28,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.
     """
@@ -47,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.
@@ -56,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
@@ -67,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
@@ -105,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/{core/errordriftcalc.py → errordriftcalc.py}

@@ -1,10 +1,9 @@
-"""
-================================================================================
-pyvale: the python validation engine
-License: MIT
-Copyright (C) 2025 The Computer Aided Validation Team
-================================================================================
-"""
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
 from abc import ABC, abstractmethod
 import numpy as np
 
@@ -33,7 +32,6 @@ class IDriftCalculator(ABC):
             Array of drift errors having the same shape as the input drift_var
             array.
         """
-        pass
 
 
 class DriftConstant(IDriftCalculator):
@@ -41,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
@@ -74,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
@@ -114,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/{core/errorintegrator.py → errorintegrator.py}

@@ -1,17 +1,16 @@
-"""
-================================================================================
-pyvale: the python validation engine
-License: MIT
-Copyright (C) 2025 The Computer Aided Validation Team
-================================================================================
-"""
+# ==============================================================================
+# 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.core.errorcalculator import (IErrCalculator,
-                                        EErrType,
-                                        EErrDependence)
-from pyvale.core.sensordata import SensorData
+from pyvale.errorcalculator import (IErrCalculator,
+                                    EErrType,
+                                    EErrDep)
+from pyvale.sensordata import SensorData
 
 
 @dataclass(slots=True)
@@ -20,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`
@@ -72,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]
@@ -118,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
         ----------
@@ -127,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:
@@ -188,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:
@@ -234,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/{core/errorrand.py → errorrand.py}

@@ -1,19 +1,18 @@
-"""
-================================================================================
-pyvale: the python validation engine
-License: MIT
-Copyright (C) 2025 The Computer Aided Validation Team
-================================================================================
-"""
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
 import numpy as np
-from pyvale.core.sensordata import SensorData
-from pyvale.core.errorcalculator import (IErrCalculator,
+from pyvale.sensordata import SensorData
+from pyvale.errorcalculator import (IErrCalculator,
                                          EErrType,
-                                         EErrDependence)
-from pyvale.core.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.
 
@@ -24,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
@@ -55,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
@@ -70,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
@@ -139,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
@@ -171,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
@@ -184,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
@@ -235,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
@@ -247,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
@@ -265,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
@@ -280,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
@@ -350,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
@@ -369,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
@@ -382,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
@@ -442,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
@@ -456,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
@@ -471,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
@@ -537,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
@@ -551,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
@@ -564,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
@@ -609,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)