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

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

@@ -1,13 +1,12 @@
-"""
-================================================================================
-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
-from pyvale.core.sensordata import SensorData
+from pyvale.sensordata import SensorData
 
 
 def create_int_pt_array(sens_data: SensorData,
@@ -72,7 +71,7 @@ class IIntegratorSpatial(ABC):
             Array of simulated sensor measurements. shape=(num_sensors,
             num_field_components,num_time_steps).
         """
-        pass
+
 
     @abstractmethod
     def get_averages(self) -> np.ndarray:
@@ -86,5 +85,5 @@ class IIntegratorSpatial(ABC):
             Array of simulated sensor measurements. shape=(num_sensors,
             num_field_components,num_time_steps).
         """
-        pass
+
 

pyvale/{core/integratortype.py → integratortype.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
+# ==============================================================================
+
 import enum
 
 
@@ -25,7 +24,7 @@ class EIntSpatialType(enum.Enum):
         Gaussian quadrature 2D integrator over 4 points.
 
     QUAD9PT
-        Gaussia quadrature 2D integrator over 9 points.
+        Gaussian quadrature 2D integrator over 9 points.
     """
 
     RECT1PT = enum.auto()

pyvale/output.py

@@ -0,0 +1,17 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+from dataclasses import dataclass
+from pathlib import Path
+
+"""
+NOTE: this module is a feature under developement.
+"""
+
+# TODO: remove this? but check blender tests
+
+@dataclass(slots=True)
+class Outputs():
+    base_dir = Path.home()

pyvale/pyvaleexceptions.py

@@ -0,0 +1,11 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+class BlenderError(Exception):
+    pass
+
+class VisError(Exception):
+    pass

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

@@ -1,16 +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
-================================================================================
+NOTE: this module is a feature under developement.
 """
+
 from abc import ABC, abstractmethod
 import numpy as np
 
-# NOTE: This module is a feature under developement.
-
-
 # NOTE:
 # - Need to render a single frame static/deformed
 # - Need to render all frames static/deformed

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

@@ -1,18 +1,19 @@
+# ==============================================================================
+# 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
-================================================================================
+NOTE: this module is a feature under developement.
 """
+
 from pathlib import Path
 from multiprocessing.pool import Pool
 import numpy as np
-from pyvale.core.cameradata import CameraData
-from pyvale.core.rendermesh import RenderMeshData
-import pyvale.core.cython.rastercyth as rastercyth
-
-# NOTE: This module is a feature under developement.
+from pyvale.cameradata import CameraData
+from pyvale.rendermesh import RenderMeshData
+import pyvale.cython.rastercyth as rastercyth
 
 class RasterCY:
     @staticmethod

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

@@ -1,22 +1,21 @@
+# ==============================================================================
+# 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
-================================================================================
+NOTE: this module is a feature under developement.
 """
+
 from pathlib import Path
 from multiprocessing.pool import Pool
 import numpy as np
 import numba
-from pyvale.core.cameradata import CameraData
-from pyvale.core.cameratools import CameraTools
-from pyvale.core.rendermesh import RenderMeshData
-import pyvale.core.cython.rastercyth as rastercyth
-
-
-# NOTE: This module is a feature under developement.
-
+from pyvale.cameradata import CameraData
+from pyvale.cameratools import CameraTools
+from pyvale.rendermesh import RenderMeshData
+import pyvale.cython.rastercyth as rastercyth
 
 class RasterNP:
     @staticmethod

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

@@ -1,27 +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
-================================================================================
+NOTE: this module is a feature under developement.
 """
+
 from enum import Enum
 from dataclasses import dataclass, field
 import numpy as np
 import mooseherder as mh
-from pyvale.core.fieldconverter import simdata_to_pyvista
-
-
-# class ImageFormat(Enum):
-#     NPY = 0
-#     TIFF = 1
-
-# @dataclass(slots=True)
-# class RenderOpts:
-#     image_tag: str = "image"
-#     image_formats: tuple[ImageFormat,...]
-#     bits_per_unit: int = 1
-#     parallel: int | None = None
+from pyvale.fieldconverter import simdata_to_pyvista
 
 
 @dataclass(slots=True)
@@ -64,7 +55,7 @@ def create_render_mesh(sim_data: mh.SimData,
 
     (pv_grid,_) = simdata_to_pyvista(sim_data,
                                      extract_keys,
-                                     spat_dim=sim_spat_dim)
+                                     elem_dims=sim_spat_dim)
 
     pv_surf = pv_grid.extract_surface()
     faces = np.array(pv_surf.faces)

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

@@ -1,13 +1,12 @@
-"""
-================================================================================
-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
-from pyvale.core.field import IField
+from pyvale.field import IField
 
 
 class ISensorArray(ABC):

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

@@ -1,26 +1,27 @@
-"""
-================================================================================
-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
 
 import mooseherder as mh
 
-from pyvale.core.fieldscalar import FieldScalar
-from pyvale.core.fieldvector import FieldVector
-from pyvale.core.fieldtensor import FieldTensor
-from pyvale.core.sensordescriptor import SensorDescriptorFactory
-from pyvale.core.sensorarraypoint import SensorArrayPoint, SensorData
-from pyvale.core.errorintegrator import ErrIntegrator
-from pyvale.core.errorsysindep import ErrSysUniformPercent
-from pyvale.core.errorrand import ErrRandNormPercent
-from pyvale.core.errorsysdep import (ErrSysDigitisation,
+from pyvale.fieldscalar import FieldScalar
+from pyvale.fieldvector import FieldVector
+from pyvale.fieldtensor import FieldTensor
+from pyvale.sensordescriptor import SensorDescriptorFactory
+from pyvale.sensorarraypoint import SensorArrayPoint, SensorData
+from pyvale.errorintegrator import ErrIntegrator
+from pyvale.errorsysindep import ErrSysUnifPercent
+from pyvale.errorrand import ErrRandNormPercent
+from pyvale.errorsysdep import (ErrSysDigitisation,
                                      ErrSysSaturation)
 
-#TODO: Docstrings
+# TODO:
+# - docstrings
+# - more sensor models
 
 class SensorArrayFactory:
     """Namespace for static methods used to build common types of sensor arrays
@@ -30,35 +31,13 @@ class SensorArrayFactory:
     @staticmethod
     def thermocouples_no_errs(sim_data: mh.SimData,
                               sensor_data: SensorData,
+                              elem_dims: int,
                               field_name: str = "temperature",
-                              spat_dims: int = 3,
                               ) -> SensorArrayPoint:
-        """Builds and returns a point sensor array with common parameters used
-        for thermocouples applied to a temperature field without any simulated
-        measurement errors. Allows the user to build and attach their own error
-        chain or use this for fast interpolation to sensor locations without
-        errors.
-
-        Parameters
-        ----------
-        sim_data : mh.SimData
-            Simulation data containing a mesh and a temperature field for the
-            thermocouple array to sample.
-        sensor_data : SensorData
-            _description_
-        field_name : str, optional
-            _description_, by default "temperature"
-        spat_dims : int, optional
-            , by default 3
-
-        Returns
-        -------
-        SensorArrayPoint
-            _description_
-        """
+
         descriptor = SensorDescriptorFactory.temperature_descriptor()
 
-        t_field = FieldScalar(sim_data,field_name,spat_dims)
+        t_field = FieldScalar(sim_data,field_name,elem_dims)
 
         sens_array = SensorArrayPoint(sensor_data,
                                       t_field,
@@ -69,19 +48,20 @@ class SensorArrayFactory:
     @staticmethod
     def thermocouples_basic_errs(sim_data: mh.SimData,
                                  sensor_data: SensorData,
+                                 elem_dims: int,
                                  field_name: str = "temperature",
-                                 spat_dims: int = 3,
                                  errs_pc: float = 1.0
                                  ) -> SensorArrayPoint:
 
         sens_array = SensorArrayFactory.thermocouples_no_errs(sim_data,
                                                               sensor_data,
-                                                              field_name,
-                                                              spat_dims)
+                                                              elem_dims,
+                                                              field_name)
 
         err_int = basic_err_integrator(sens_array.get_measurement_shape(),
                                        sensor_data,
-                                       errs_pc)
+                                       sys_err_pc=errs_pc,
+                                       rand_err_pc=errs_pc)
 
         # Normal thermcouple amp = 5mV / K
         err_int._err_chain.append(ErrSysDigitisation(bits_per_unit=2**16/1000))
@@ -90,19 +70,22 @@ class SensorArrayFactory:
         sens_array.set_error_integrator(err_int)
         return sens_array
 
+
+
     @staticmethod
     def disp_sensors_no_errs(sim_data: mh.SimData,
-                            sensor_data: SensorData,
-                            field_name: str = "displacement",
-                            spat_dims: int = 3,
-                            ) -> SensorArrayPoint:
+                             sensor_data: SensorData,
+                             elem_dims: int,
+                             field_name: str,
+                             field_comps: tuple[str,...],
+                             ) -> SensorArrayPoint:
 
         descriptor = SensorDescriptorFactory.displacement_descriptor()
 
         disp_field = FieldVector(sim_data,
                                  field_name,
-                                 ('disp_x','disp_y'),
-                                 spat_dims)
+                                 field_comps,
+                                 elem_dims)
 
         sens_array = SensorArrayPoint(sensor_data,
                                       disp_field,
@@ -113,18 +96,21 @@ class SensorArrayFactory:
     @staticmethod
     def disp_sensors_basic_errs(sim_data: mh.SimData,
                                 sensor_data: SensorData,
-                                field_name: str = "displacement",
-                                spat_dims: int = 3,
-                                errs_pc: float = 1
+                                elem_dims: int,
+                                field_name: str,
+                                field_comps: tuple[str,...],
+                                errs_pc: float = 1.0,
                                 ) -> SensorArrayPoint:
 
         sens_array = SensorArrayFactory.disp_sensors_no_errs(sim_data,
-                                                            sensor_data,
-                                                            field_name,
-                                                            spat_dims)
+                                                             sensor_data,
+                                                             elem_dims,
+                                                             field_name,
+                                                             field_comps)
         err_int = basic_err_integrator(sens_array.get_measurement_shape(),
                                        sensor_data,
-                                       errs_pc)
+                                       sys_err_pc=errs_pc,
+                                       rand_err_pc=errs_pc)
         sens_array.set_error_integrator(err_int)
 
         return sens_array
@@ -132,23 +118,18 @@ class SensorArrayFactory:
     @staticmethod
     def strain_gauges_no_errs(sim_data: mh.SimData,
                               sensor_data: SensorData,
-                              field_name: str = "strain",
-                              spat_dims: int = 3
+                              elem_dims: int,
+                              field_name: str,
+                              norm_comps: tuple[str,...],
+                              dev_comps: tuple[str,...]
                               ) -> SensorArrayPoint:
-        descriptor = SensorDescriptorFactory.strain_descriptor(spat_dims)
-
-        if spat_dims == 2:
-            norm_components = ('strain_xx','strain_yy')
-            dev_components = ('strain_xy',)
-        else:
-            norm_components = ('strain_xx','strain_yy','strain_zz')
-            dev_components = ('strain_xy','strain_yz','strain_xz')
+        descriptor = SensorDescriptorFactory.strain_descriptor(elem_dims)
 
         strain_field = FieldTensor(sim_data,
-                                 field_name,
-                                 norm_components,
-                                 dev_components,
-                                 spat_dims)
+                                   field_name,
+                                   norm_comps,
+                                   dev_comps,
+                                   elem_dims)
 
         sens_array = SensorArrayPoint(sensor_data,
                                       strain_field,
@@ -160,19 +141,24 @@ class SensorArrayFactory:
     @staticmethod
     def strain_gauges_basic_errs(sim_data: mh.SimData,
                                 sensor_data: SensorData,
-                                field_name: str = "strain",
-                                spat_dims: int = 3,
+                                elem_dims: int,
+                                field_name: str,
+                                norm_comps: tuple[str,...],
+                                dev_comps: tuple[str,...],
                                 errs_pc: float = 1.0
                                 ) -> SensorArrayPoint:
 
         sens_array = SensorArrayFactory.strain_gauges_no_errs(sim_data,
                                                               sensor_data,
+                                                              elem_dims,
                                                               field_name,
-                                                              spat_dims)
+                                                              norm_comps,
+                                                              dev_comps)
 
         err_int = basic_err_integrator(sens_array.get_measurement_shape(),
                                        sensor_data,
-                                       errs_pc)
+                                       sys_err_pc=errs_pc,
+                                       rand_err_pc=errs_pc)
         sens_array.set_error_integrator(err_int)
 
         return sens_array
@@ -204,7 +190,7 @@ def basic_err_integrator(meas_shape: np.ndarray,
         a normal percentage random error.
     """
     err_chain = []
-    err_chain.append(ErrSysUniformPercent(-sys_err_pc,sys_err_pc))
+    err_chain.append(ErrSysUnifPercent(-sys_err_pc,sys_err_pc))
     err_chain.append(ErrRandNormPercent(rand_err_pc))
     err_int = ErrIntegrator(err_chain,sensor_data,meas_shape)
     return err_int